code: def finish_async_rpc(self, address, rpc_id, response):
          
  
          pending = self._pending_rpcs.get(address)
  
          if pending is None:
              raise ArgumentError("No asynchronously RPC currently in progress on tile %d" % address)
  
          responder = pending.get(rpc_id)
          if responder is None:
              raise ArgumentError("RPC %04X is not running asynchronous on tile %d" % (rpc_id, address))
  
          del pending[rpc_id]
  
          responder.set_result(response)
          self._rpc_queue.task_done()
docs: Finish a previous asynchronous RPC.
  
          This method should be called by a peripheral tile that previously
          had an RPC called on it and chose to response asynchronously by
          raising ``AsynchronousRPCResponse`` in the RPC handler itself.
  
          The response passed to this function will be returned to the caller
          as if the RPC had returned it immediately.
  
          This method must only ever be called from a coroutine inside the
          emulation loop that is handling background work on behalf of a tile.
  
          Args:
              address (int): The tile address the RPC was called on.
              rpc_id (int): The ID of the RPC that was called.
              response (bytes): The bytes that should be returned to
                  the caller of the RPC.