// RUN: tf-quant-opt %s -split-input-file -quant-preprocess-op | FileCheck %s

module {
  // For UniformQuantized depthwise convolution, tensor shape should have
  // transformed from [H,W,C,M] to [H,W,1,CxM],
  func.func @depthwise_conv(%arg0: tensor<1x3x4x3xf32>) -> (tensor<*xf32>) {
    %cst_0 = "tf.Const"() {value = dense<0.000000e+00> : tensor<6xf32>} : () -> tensor<6xf32>

      // Uniform Quantized op requires weights of tf.DepthwiseConv2dNative to
      // be transformed from [H,W,C,M] to [H,W,1,CxM] where
      // H=height,W=width,C=channel,M=multiplier. Therefore, a reshape op is
      // inserted between the constant op and the function op so that the
      // constant is safely transformed for the multi-use cases as well. Note

import org.gradle.internal.operations.BuildOperationQueue;
import org.gradle.internal.operations.RunnableBuildOperation;

import java.io.File;
import java.util.Collection;

/**
 * An artifact set containing transformed project artifacts.
 */
public class TransformedProjectArtifactSet implements TransformedArtifactSet, FileCollectionInternal.Source, ResolvedArtifactSet.Artifacts {

    private final ComponentVariantIdentifier targetVariant;

import org.eclipse.aether.metadata.Metadata;
import org.eclipse.aether.util.ConfigUtils;

/**
 * Maven local GAV level metadata generator.
 * <p>
 * Local snapshot metadata contains non-transformed snapshot version.
 */
class LocalSnapshotMetadataGenerator implements MetadataGenerator {

    private final Map<Object, LocalSnapshotMetadata> snapshots;

    private final Date timestamp;

 *
 * <p>
 *     For example, when a project depends on {@code spring-web}, when the project is transformed (i.e. the project is the input artifact),
 *     the input artifact dependencies are the file collection containing the {@code spring-web} JAR and all its dependencies like e.g. the {@code spring-core} JAR.
 *

     * to tasks that use the new provider for input values.
     * </p>
     *
     * @param transformer The transformer to apply to values. May return {@code null}, in which case the provider will have no value.
     * @since 4.3
     */
    <S> Provider<S> map(Transformer<? extends @org.jetbrains.annotations.Nullable S, ? super T> transformer);

    /**

	// amd64:`LEAQ\ttype:\[3\]uint8`
	// amd64:`CALL\truntime\.newobject`
	// amd64:-`.*runtime.stringtoslicebyte`
	return []byte("foo")
}

// Loading from read-only symbols should get transformed into constants.
func ConstantLoad() {
	// 12592 = 0x3130
	//    50 = 0x32
	// amd64:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
	//   386:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
	//   arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50`

// the user did not explicitly specify.
QuantizationConfig PopulateDefaults(
    const QuantizationConfig& user_provided_config);

// Returns a copy of `QuantizationConfig` where presets are expanded and
// transformed into other fields in `QuantizationConfig`.
//
// The expansion rules are as follows:
// * StaticRangePtqPreset
//   - The preset's `representative_datasets` field will be transferred to

     * foo -> foo.bar
     * foo.baz -> foo.bar
     *
     * @param filePath the file path to transform
     * @param extension the extension to use in the transformed path
     * @return the transformed path
     */
    public static String withExtension(String filePath, String extension) {
        if (filePath.toLowerCase(Locale.ROOT).endsWith(extension)) {
            return filePath;
        }

        assertTransformChain(result.first(), sourceVariant, compatible, transform2)

        and:
        // sourceVariant can be transformed by a transform starting with fromSource attributes
        1 * attributeMatcher.isMatching(sourceVariant.getAttributes(), fromSource) >> true
        // otherVariant cannot be transformed by a transform starting with fromSource attributes
        1 * attributeMatcher.isMatching(otherVariant.getAttributes(), fromSource) >> false