// Prepare for entry to Go.
	BL	runtime·load_g(SB)

	// Call cgocallback, which will call callbackWrap(frame).
	MOVW	$0, R0
	MOVW	R0, 12(R13)	// context
	MOVW	$16(R13), R1	// R1 = &callbackArgs{...}
	MOVW	R1, 8(R13)	// frame (address of callbackArgs)
	MOVW	$·callbackWrap(SB), R1
	MOVW	R1, 4(R13)	// PC of function to call
	BL	runtime·cgocallback(SB)

	// Get callback result.

  }

  override fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
    logWithTime("responseHeadersEnd: $response")

    delegate.responseHeadersEnd(call, response)
  }

  override fun responseBodyStart(call: Call) {
    logWithTime("responseBodyStart")

    delegate.responseBodyStart(call)
  }

  override fun responseBodyEnd(
    call: Call,

    call.plansToCancel -= connectPlan
  }

  override fun updateRouteDatabaseAfterSuccess(route: Route) {
    call.client.routeDatabase.connected(route)
  }

  override fun connectStart(route: Route) {
    eventListener.connectStart(call, route.socketAddress, route.proxy)
    poolConnectionListener.connectStart(route, call)
  }

  override fun connectFailed(
    route: Route,
    protocol: Protocol?,

	public fun cacheConditionalHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheHit (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun cacheMiss (Lokhttp3/Call;)V
	public fun callEnd (Lokhttp3/Call;)V
	public fun callFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun callStart (Lokhttp3/Call;)V
	public fun canceled (Lokhttp3/Call;)V
	public fun connectEnd (Lokhttp3/Call;Ljava/net/InetSocketAddress;Ljava/net/Proxy;Lokhttp3/Protocol;)V

   * [synchronously][Call.execute] and [asynchronously][Call.enqueue].
   */
  fun cancelAll() {
    this.withLock {
      for (call in readyAsyncCalls) {
        call.call.cancel()
      }
      for (call in runningAsyncCalls) {
        call.call.cancel()
      }
      for (call in runningSyncCalls) {
        call.cancel()
      }
    }
  }

  /**

    find ./test/integration/ -name '*_test.go' -print0 \
      | xargs -0n1 dirname \
      | LC_ALL=C sort -u
    find ./staging/src/k8s.io/apiextensions-apiserver/test/integration/ -name '*_test.go' -print0 \
      | xargs -0n1 dirname \
      | LC_ALL=C sort -u
  )
}

CLEANUP_REQUIRED=
cleanup() {
  if [[ -z "${CLEANUP_REQUIRED}" ]]; then
    return
  fi

    override val timestampNs: Long,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectFailed(
    override val timestampNs: Long,
    val route: Route,
    val call: Call,
    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(

) : EventSource, ServerSentEventReader.Callback, Callback {
  private var call: Call? = null

  @Volatile private var canceled = false

  fun connect(callFactory: Call.Factory) {
    call =
      callFactory.newCall(request).apply {
        enqueue(this@RealEventSource)
      }
  }

  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    processResponse(response)
  }

  // CHECK: call{{.*}}(%arg0, %arg1)
  %1 = func.call @f(%arg0, %arg1) : (tensor<f32>, tensor<f32>) -> tensor<f32>
  return %1 : tensor<f32>
}

// -----

func.func private @f(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  return
}

// CHECK-LABEL: removes_all_args
func.func @removes_all_args(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  // CHECK: call{{.*}}() :

        @ClosureParams(value = SimpleType, options = "InterceptorTestReceiver") Closure<?> call
    ) {
        def receiver = new InterceptorTestReceiver()
        def closure = instrumentedClasses.instrumentedClosure(call)
        if (shouldDelegate) {
            closure.delegate = receiver
            closure.call()
        } else {
            closure.call(receiver)
        }
        receiver.intercepted
    }