return "$first to $second"
    }

    override fun convertType(type: KType): KType {
        val first = type.arguments.getOrNull(0)?.type ?: return type
        val second = type.arguments.getOrNull(1)?.type ?: return type
        return Pair::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,

                mappingConversion = createConversion(elementType)
            )
        }
        if (kClass.isSubclassOf(Map::class)) {
            val keyType = type.arguments.getOrNull(0)?.type
            val valueType = type.arguments.getOrNull(1)?.type

            val keyConversion = keyType?.let { createConversion(it) } ?: HLIdParameterConversion

package okhttp3.internal

import okhttp3.Headers

internal fun Headers.commonName(index: Int): String = namesAndValues.getOrNull(index * 2) ?: throw IndexOutOfBoundsException("name[$index]")

internal fun Headers.commonValue(index: Int): String =
  namesAndValues.getOrNull(index * 2 + 1) ?: throw IndexOutOfBoundsException("value[$index]")

internal fun Headers.commonValues(name: String): List<String> {

import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
import org.jetbrains.kotlin.utils.exceptions.withPsiEntry
import java.util.Optional
import kotlin.collections.ArrayList
import kotlin.jvm.optionals.getOrNull
import kotlin.math.sign

@OptIn(KtAnalysisNonPublicApi::class)
internal class KtFirDataFlowInfoProvider(override val analysisSession: KtFirAnalysisSession) : KtDataFlowInfoProvider() {

        val mapping = mutableMapOf<TypeParameterDescriptor, BoundTypeArgument>()
        arguments.forEachIndexed { index, typeProjection ->
            val typeParameter = typeParameterOwner.declaredTypeParameters.getOrNull(index) ?: return@forEachIndexed
            var boundTypeArgument: BoundTypeArgument = when {
                typeProjection.isStarProjection -> return@forEachIndexed

        val result = mutableMapOf<KtTypeParameterSymbol, KtType>()
        for ((parameter, type) in typeArguments) {
            val ktParameter = typeParameters.getOrNull(parameter.index) ?: return emptyMap()

            // i.e. we were not able to infer some types
            if (type.contains { it: UnwrappedType -> it.constructor is TypeVariableTypeConstructor }) return emptyMap()