return buildString {
            appendLine("$expression.mapKeys { ($keyName, _) ->")
            appendLine(keyTransformation.withIndent(context.increaseIndent()))
            appendLine("}.mapValues { (_, $valueName) -> ".withIndent(context))
            appendLine(valueTransformation.withIndent(context.increaseIndent()))
            append("}".withIndent(context))
        }
    }

                        os to (testProject to performanceTestDuration)
                    }
            }
        }
        return pairs.groupBy({ it.first }, { it.second })
            .mapValues { entry -> entry.value.groupBy({ it.first }, { it.second }) }
    }

    private
    fun readPerformanceTestConfigurations(performanceTestsCiJson: File): List<PerformanceTestConfiguration> {

}

private fun convertArgument(argument: Map<*, *>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return argument.mapKeys { (key, _) ->
        convertArgument(key, firSymbolBuilder)
    }.mapValues { (_, value) -> 
        convertArgument(value, firSymbolBuilder)
    }
}

private fun convertArgument(argument: Collection<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return argument.map { value ->

        ActualWithoutExpectImpl(
            firSymbolBuilder.buildSymbol(firDiagnostic.a),
            firDiagnostic.b.mapKeys { (expectActualCompatibility, _) ->
                expectActualCompatibility
            }.mapValues { (_, collection) -> 
                collection.map { firBasedSymbol ->
                                    firSymbolBuilder.buildSymbol(firBasedSymbol)
                                }
            },

            ?.createConeSubstitutorFromTypeArguments(rootModuleSession, discardErrorTypes = !substituteWithErrorTypes)
            ?: ConeSubstitutor.Empty

        return resolvedArgumentMapping?.mapValuesTo(LinkedHashMap()) { (_, parameter) ->
            SubstitutedValueParameter(parameter, substitutor.substituteOrSelf(parameter.returnTypeRef.coneType))
        }
    }