return firSymbolBuilder.buildSymbol(argument)
}

private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
}

private fun convertArgument(argument: FirNamedFunctionSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {

        require(callableSymbol is KtFirSymbol<*>)
        if (callableSymbol is KtFirBackingFieldSymbol) return emptyList()
        if (callableSymbol is KtValueParameterSymbol) {
            return callableSymbol.getAllOverriddenSymbols()
        }
        (callableSymbol.firSymbol as? FirIntersectionCallableSymbol)?.let { intersectionSymbol ->
            return intersectionSymbol.intersections.flatMap {

  private fun buildGoogle(bootstrapClient: OkHttpClient): DnsOverHttps {
    return DnsOverHttps.Builder()
      .client(bootstrapClient)
      .url("https://dns.google/dns-query".toHttpUrl())
      .bootstrapDnsHosts(getByIp("8.8.4.4"), getByIp("8.8.8.8"))
      .build()
  }

  private fun buildGooglePost(bootstrapClient: OkHttpClient): DnsOverHttps {
    return DnsOverHttps.Builder()
      .client(bootstrapClient)

      if (methodName == "supports" && Boolean::class.javaPrimitiveType == returnType) {
        return true // ALPN is supported.
      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null
      } else if (methodName == "protocols" && callArgs.isEmpty()) {
        return protocols // Client advertises these protocols.

      result.add(value(i))
    }
  }
  return result?.toList().orEmpty()
}

internal fun Headers.commonIterator(): Iterator<Pair<String, String>> {
  return Array(size) { name(it) to value(it) }.iterator()
}

internal fun Headers.commonNewBuilder(): Headers.Builder {
  val result = Headers.Builder()
  result.namesAndValues += namesAndValues
  return result
}

            if (descriptor.isDynamic()) return null
            val getter = descriptor.getter ?: return KtFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KtFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

    override val setter: KtPropertySetterSymbol?
        get() = withValidityAssertion {
            if (descriptor.isDynamic()) return null
            if (!descriptor.isVar) {

        val samResolver = FirSamResolver(
            firSession,
            analysisSession.getScopeSessionFor(firSession),
        )
        return samResolver.isSamType(coneType)
    }

    override fun getFunctionClassKind(type: KtType): FunctionTypeKind? {
        return (type as KtFirType).coneType.functionTypeKind(analysisSession.useSiteSession)
    }

      val uri = url.toUri()
      if (uri.host == null) return immutableListOf(Proxy.NO_PROXY)

      // Try each of the ProxySelector choices until one connection succeeds.
      val proxiesOrNull = address.proxySelector.select(uri)
      if (proxiesOrNull.isNullOrEmpty()) return immutableListOf(Proxy.NO_PROXY)

      return proxiesOrNull.toImmutableList()
    }

    connectionUser.proxySelectStart(url)

      this.readUtf8().lines().filter { it.isNotBlank() }.map {
        SuiteId(id = null, name = it.trim())
      }
    }
  return Client(
    userAgent = "OkHttp",
    version = version,
    enabled = enabled,
  )
}

fun currentVm(ianaSuites: IanaSuites): Client {
  return systemDefault(
    name = System.getProperty("java.vm.name"),
    version = System.getProperty("java.version"),
    ianaSuites = ianaSuites,

        }
      }

      // There's another part. Parse its headers and return it.
      val headers = HeadersReader(source).readHeaders()
      val partSource = PartSource()
      currentPart = partSource
      return Part(headers, partSource.buffer())
    }

    /** A single part in the stream. It is an error to read this after calling [nextPart]. */