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 {

                it.name.endsWith(".json")
            }?.associate {
                it to it.readAcceptedChanges()
            }?.filterValues {
                it.acceptedApiChanges != null
            }?.mapValues {
                it.value.acceptedApiChanges!!
            } ?: emptyMap()
    }

    private
    fun File.readAcceptedChanges(): AcceptedApiChanges {
        val jsonString = this.readText()

        private
        fun replaceInArgs(
            parameterValueBinding: ParameterValueBinding,
        ): ParameterValueBinding =
            parameterValueBinding.copy(parameterValueBinding.bindingMap.mapValues { replace(it.value) })
    }

                      shape.end(), 1, std::multiplies<int64_t>());
  Type new_element_type =
      IntegerType::get(attr.getContext(), storage_bit_width_);
  return attr.mapValues(new_element_type, [&](const APFloat &old) {
    int chunk_index = flatten_index / chunk_size;
    flatten_index++;
    return converters[chunk_index % dim_size].quantizeFloatToInt(old);
  });
}

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

        return collected
    }

    private
    fun keepOnlyInstrumentedSuperTypes(superTypes: Map<String, Set<String>>, instrumentedClasses: Set<String>): Map<String, Set<String>> {
        return superTypes.mapValues {
            it.value.filter { superType -> instrumentedClasses.contains(superType) }.toSet()
        }.filter { it.value.isNotEmpty() }
    }

    private

        val getters = functionsByName
            .filterKeys { it.startsWith("get") && it.substringAfter("get").firstOrNull()?.isUpperCase() == true }
            .mapValues { (_, functions) -> functions.singleOrNull { fn -> fn.parameters.all { it == fn.instanceParameter } } }
            .filterValues { it != null && includeMemberFilter.shouldIncludeMember(it) && isGradlePropertyType(it.returnType) }

        val getters = functionsByName
            .filterKeys { it.startsWith("get") && it.substringAfter("get").firstOrNull()?.isUpperCase() == true }
            .mapValues { (_, functions) -> functions.singleOrNull { fn -> fn.parameters.all { it == fn.instanceParameter } } }
            .filterValues { it != null && includeMemberFilter.shouldIncludeMember(it) }

static DenseElementsAttr convertDenseFPElementsAttr(
    DenseFPElementsAttr realFPElementsAttr,
    quant::QuantizedType quantizedElementType,
    const UniformQuantizedValueConverter &converter) {
  return realFPElementsAttr.mapValues(
      quantizedElementType.getStorageType(),
      [&converter](const APFloat &realVal) {
        return converter.quantizeFloatToInt(realVal);
      });
}

    protected
    abstract fun read(decoder: Decoder): V

    /**
     * Collects all values used during execution
     */
    fun collectAccessedValues(): Map<K, BlockAddress> =
        currentValues.mapValues { it.value.get() }

    fun restoreFromCacheEntry(entryDetails: Map<K, BlockAddress>, checkedFingerprint: CheckedFingerprint.ProjectsInvalid) {
        for (entry in entryDetails) {