code: def __fa_process_sequence(self, sequence, avoid, initial_state, execution_state, trace_current, next_addr):
          
          # TODO: Process execution intra states.
  
          ip = sequence.address
          next_ip = None
  
          while ip:
              # Fetch next instruction in the sequence.
              try:
                  instr = sequence.fetch(ip)
              except ReilSequenceInvalidAddressError:
                  # At this point, ip should be a native instruction address, therefore
                  # the index should be zero.
                  assert split_address(ip)[1] == 0x0
                  next_ip = ip
                  break
  
              try:
                  target_addr = sequence.get_next_address(ip)
              except ReilSequenceInvalidAddressError:
                  # We reached the end of the sequence. Execution continues on the next native instruction
                  # (it's a REIL address).
                  target_addr = next_addr
  
              next_ip = self.__process_instr(instr, avoid, target_addr, initial_state, execution_state, trace_current)
  
              # Update instruction pointer.
              try:
                  ip = next_ip if next_ip else sequence.get_next_address(ip)
              except ReilSequenceInvalidAddressError:
                  break
  
          return next_ip
docs: Process a REIL sequence.
  
          Args:
              sequence (ReilSequence): A REIL sequence to process.
              avoid (list): List of address to avoid.
              initial_state: Initial state.
              execution_state: Execution state queue.
              trace_current (list): Current trace.
              next_addr: Address of the next instruction following the current one.
  
          Returns:
              Returns the next instruction to execute in case there is one, otherwise returns None.