code: def __process_instr(self, instr, avoid, next_addr, initial_state, execution_state, trace_current):
          
          # Process branch (JCC oprnd0, empty, oprnd2).
          if instr.mnemonic == ReilMnemonic.JCC:
              not_taken_addr = next_addr
              address, index = split_address(instr.address)
  
              logger.debug("[+] Processing branch: {:#08x}:{:02x} : {}".format(address, index, instr))
  
              # Process conditional branch (oprnd0 is a REGISTER).
              if isinstance(instr.operands[0], ReilRegisterOperand):
                  next_ip = self.__process_branch_cond(instr, avoid, initial_state, execution_state, trace_current, not_taken_addr)
  
              # Process unconditional branch (oprnd0 is an INTEGER).
              else:
                  next_ip = self.__process_branch_uncond(instr, trace_current, not_taken_addr)
  
          # Process the rest of the instructions.
          else:
              trace_current += [(instr, None)]
  
              self.__cpu.execute(instr)
  
              next_ip = next_addr
  
          return next_ip
docs: Process a REIL instruction.
  
          Args:
              instr (ReilInstruction): Instruction to process.
              avoid (list): List of addresses to avoid while executing the code.
              next_addr (int): Address of the following instruction.
              initial_state (State): Initial execution state.
              execution_state (Queue): Queue of execution states.
              trace_current (list): Current trace.
  
          Returns:
              int: Returns the next address to execute.