func Sort(mapValue reflect.Value) SortedMap {
	if mapValue.Type().Kind() != reflect.Map {
		return nil
	}
	// Note: this code is arranged to not panic even in the presence
	// of a concurrent map update. The runtime is responsible for
	// yelling loudly if that happens. See issue 33275.
	n := mapValue.Len()
	sorted := make(SortedMap, 0, n)
	iter := mapValue.MapRange()
	for iter.Next() {

	activation := &testActivation{variables: variablesMap}

	// add foo as a string
	variablesType.Fields["foo"] = apiservercel.NewDeclField("foo", apiservercel.StringType, true, nil, nil)
	variablesMap.Append("foo", func(_ *MapValue) ref.Val {
		return types.String("foo-string")
	})

	exp := "variables.foo == 'foo-string'"
	v, err := compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}

            ? 'getInputs().property("input", "value");'
            : ""}
                    Map<String, Object> mapValues = new HashMap<String, Object>();
                    mapValues.put("mapInput", "mapValue");
                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.properties(mapValues);
                }

                @TaskAction
                public void doGet() {

	return cost
}

type variableAccessor struct {
	name       string
	result     CompilationResult
	activation any
	context    *compositionContext
}

func (a *variableAccessor) Callback(_ *lazy.MapValue) ref.Val {
	if a.result.Error != nil {
		return types.NewErr("composited variable %q fails to compile: %v", a.name, a.result.Error)
	}

	v, details, err := a.result.Program.ContextEval(a.context, a.activation)

            abstract class CustomTask : DefaultTask() {
                @get:Input
                abstract val mapValues: MapProperty<String, Int>

                @TaskAction
                fun customAction() {
                    println("Hello from custom task")
                    // println("- mapValues['alma'] = \${mapValues['alma']}")
                }
            }
        """

        expect:

        val sortedChanges = originalChanges.mapValues {
            sortChanges(it.value)
        }

        val mismatches = originalChanges.mapValues {
            findMismatches(it.value, sortedChanges[it.key]!!)
        }.filterValues {
            it.isNotEmpty()
        }

        if (mismatches.isNotEmpty()) {
            val formattedMismatches = mismatches.mapValues { mismatch ->

        store.flush();
    }

    private void verify(FreeListBlock block, int maxValue) {
        if (block.largestInNextBlock > maxValue) {
            throw new RuntimeException("corrupt free list");
        }
        int current = 0;
        for (FreeListEntry entry : block.entries) {
            if (entry.size > maxValue) {
                throw new RuntimeException("corrupt free list");
            }

        val importAnalysisRendered = buildString {
            val sortedUsedDeclarations = importsAnalysis.usedDeclarations
                .toSortedMap(compareBy { importPath -> importPath.toString() })
                .mapValues { (_, importedNames) -> importedNames.sorted() }

            appendLine("USED DECLARATIONS:")
            for ((path, elements) in sortedUsedDeclarations) {
                appendLine()

 */
@CacheableTask
abstract class SortAcceptedApiChangesTask : AbstractAcceptedApiChangesMaintenanceTask() {

    @TaskAction
    fun execute() {
        loadChanges().mapValues {
            formatChanges(sortChanges(it.value))
        }.forEach {
            it.key.bufferedWriter().use { out -> out.write(it.value) }
        }
    }

    private

    if (!q_type) return failure();

    const float scale = q_type.getScale();
    const float zp = q_type.getZeroPoint();

    auto input_values = input_dequant.getValue();

    // mapValues always takes a function returning APInt, even when the output
    // is actually float.
    using DequantizeFuncType = llvm::APInt(const llvm::APInt&);
    auto dequantize_func = [&](const APInt& ap_int_value) -> APInt {