code: def get_callee_address(
      global_state: GlobalState,
      dynamic_loader: DynLoader,
      symbolic_to_address: Expression,
  ):
      
      environment = global_state.environment
  
      try:
          callee_address = hex(util.get_concrete_int(symbolic_to_address))
      except TypeError:
          log.debug("Symbolic call encountered")
  
          match = re.search(r"storage_(\d+)", str(simplify(symbolic_to_address)))
          log.debug("CALL to: " + str(simplify(symbolic_to_address)))
  
          if match is None or dynamic_loader is None:
              raise ValueError()
  
          index = int(match.group(1))
          log.debug("Dynamic contract address at storage index {}".format(index))
  
          # attempt to read the contract address from instance storage
          try:
              callee_address = dynamic_loader.read_storage(
                  environment.active_account.address, index
              )
          # TODO: verify whether this happens or not
          except:
              log.debug("Error accessing contract storage.")
              raise ValueError
  
          # testrpc simply returns the address, geth response is more elaborate.
          if not re.match(r"^0x[0-9a-f]{40}$", callee_address):
              callee_address = "0x" + callee_address[26:]
  
      return callee_address
docs: Gets the address of the callee.
  
      :param global_state: state to look in
      :param dynamic_loader:  dynamic loader to use
      :param symbolic_to_address: The (symbolic) callee address
      :return: Address of the callee