internal
fun MethodVisitor.ARETURN() {
    visitInsn(Opcodes.ARETURN)
}


internal
fun MethodVisitor.RETURN() {
    visitInsn(Opcodes.RETURN)
}


internal
fun MethodVisitor.ALOAD(`var`: Int) {
    visitVarInsn(Opcodes.ALOAD, `var`)
}


internal
fun MethodVisitor.ASTORE(`var`: Int) {
    visitVarInsn(Opcodes.ASTORE, `var`)
}


internal
fun MethodVisitor.GOTO(label: Label) {

  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionReleased")
  }

  override fun requestHeadersStart(call: Call) {
    logWithTime("requestHeadersStart")
  }

  override fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) {
    logWithTime("requestHeadersEnd")
  }

  override fun requestBodyStart(call: Call) {

    protected
    fun withDefaultSettings() =
        withDefaultSettingsIn(".")

    protected
    fun withDefaultSettingsIn(baseDir: String) =
        withSettingsIn(baseDir, defaultSettingsScript)

    protected
    fun withSettings(script: String, produceFile: (String) -> File = ::newFile): File =
        withSettingsIn(".", script, produceFile)

    protected

	public fun close ()V
	public final fun delete ()V
	public final fun directory ()Ljava/io/File;
	public final fun directoryPath ()Lokio/Path;
	public final fun evictAll ()V
	public fun flush ()V
	public final fun hitCount ()I
	public final fun initialize ()V
	public final fun isClosed ()Z
	public static final fun key (Lokhttp3/HttpUrl;)Ljava/lang/String;
	public final fun maxSize ()J
	public final fun networkCount ()I

import kotlin.coroutines.suspendCoroutine


fun <T> singleton(value: T): Codec<T> =
    SingletonCodec(value)


fun <T> codec(
    encode: suspend WriteContext.(T) -> Unit,
    decode: suspend ReadContext.() -> T?
): Codec<T> = object : Codec<T> {
    override suspend fun WriteContext.encode(value: T) = encode(value)
    override suspend fun ReadContext.decode(): T? = decode()
}

	public final fun requireClientAuth ()V
	public final fun setBodyLimit (J)V
	public final fun setDispatcher (Lokhttp3/mockwebserver/Dispatcher;)V
	public final fun setProtocolNegotiationEnabled (Z)V
	public final fun setProtocols (Ljava/util/List;)V
	public final fun setServerSocketFactory (Ljavax/net/ServerSocketFactory;)V
	public final fun shutdown ()V
	public final fun start ()V
	public final fun start (I)V

    SKIP,

    ;

    open fun encode(codePoint: Int): String {
      throw UnsupportedOperationException()
    }
  }

  enum class Component {
    USER {
      override fun urlString(value: String): String = "http://$******@****.***/"

      override fun encodedValue(url: HttpUrl): String = url.encodedUsername

      override operator fun set(
        builder: HttpUrl.Builder,

    override fun localGroovy(): Dependency =
        delegate.localGroovy()

    override fun getConstraints(): DependencyConstraintHandler =
        delegate.constraints

    override fun constraints(configureAction: Action<in DependencyConstraintHandler>) =
        delegate.constraints(configureAction)

    override fun getComponents(): ComponentMetadataHandler =
        delegate.components

fun a(){}
private fun b() {}

class A {
    private fun a() {}

    class B {
        private fun b() {}

        class C {
            private fun c() {}

        }
    }
}

interface D {
    private fun d() {}
    inner class E {
        private fun e() {}
        enum class F {
            private fun f() {}
        }
    }
}

enum class G {
    H, I;

    private fun g() {}
}

  }

  @Test
  fun call() {
    val call: Call =
      object : Call {
        override fun request(): Request = TODO()

        override fun execute(): Response = TODO()

        override fun enqueue(responseCallback: Callback) = TODO()

        override fun cancel() = TODO()

        override fun isExecuted(): Boolean = TODO()