%1 = "tf.Round"(%0) : (tensor<1x100x100x1xf32>) -> tensor<1x100x100x1xf32>
  %2 = "tf.Cast"(%1) : (tensor<1x100x100x1xf32>) -> tensor<1x100x100x1xi32>
  %3 = "tf.AddV2"(%2, %cst) : (tensor<1x100x100x1xi32>, tensor<i32>) -> tensor<1x100x100x1xi32>

  %4 = "tf.ClipByValue"(%3, %cst, %cst_9) : (tensor<1x100x100x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x100x100x1xi32>
  %5 = "tf.Cast"(%4) {Truncate = false} : (tensor<1x100x100x1xi32>) -> tensor<1x100x100x1xi8>

// CHECK: %[[quant:.*]] = "tf.Cast"(%[[round]]) : (tensor<1x3x4x3xf32>) -> tensor<1x3x4x3xi8>
// CHECK: %[[pad:.*]] = "tf.PadV2"(%[[quant]]
// CHECK: %[[xlaconv:.*]] = "tf.XlaConvV2"(%[[pad]]
// CHECK: %[[sub:.*]] = "tf.Sub"(%[[xlaconv]]
// CHECK: %[[cast:.*]] = "tf.Cast"(%[[sub]]) <{Truncate = false}> : (tensor<1x3x2x2xi32>) -> tensor<1x3x2x2xf32>
// CHECK: %[[dequant1:.*]] = "tf.Mul"(%[[cast]]
// CHECK: %[[relu:.*]] = "tf.Relu"(%[[dequant1]]

      new_unit.set_node_name(name_loc_id.str());
    }
  };

  ArrayRef<Location> locations = mlir::cast<FusedLoc>(loc).getLocations();
  if (IsImportLocPattern(mlir::cast<FusedLoc>(loc))) {
    QuantizationUnit new_unit;
    // Op type is a NameLoc with the ":" suffix.
    StringRef op_type_with_suffix =
        mlir::cast<NameLoc>(locations.front()).getName().strref();
    StringRef op_type =

    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isInstance(value)) {
            return type.cast(value);
        }
        if (type.isEnum() && type.getName().equals(value.getDeclaringClass().getName())) {
            return type.cast(Enum.valueOf(Cast.uncheckedNonnullCast(type.asSubclass(Enum.class)), value.name()));
        }
        return null;
    }

  TF_ASSERT_OK_AND_ASSIGN(tf::libtf::Dictionary node,
                          Cast<tf::libtf::Dictionary>(objects.front()));

  // The next three nodes of data-structure-model are lists.
  for (unsigned int i = 1; i < 4; i++) {
    TF_ASSERT_OK_AND_ASSIGN(tf::libtf::List node,
                            Cast<tf::libtf::List>(objects.at(i)));
  }
  // The last three nodes of data-structure-model are dictionaries.

import groovy.lang.Closure;
import org.gradle.api.specs.AndSpec;
import org.gradle.api.specs.CompositeSpec;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.internal.ClosureSpec;
import org.gradle.internal.Cast;

import javax.annotation.Nullable;

/**
 * A {@link CompositeSpec} that requires all component specs to provide a description.
 * The aggregation is based on an {@link AndSpec}.
 *

        if (leftType.isInstance(left) && rightType.isInstance(right)) {
            return doIntersect(leftType.cast(left), rightType.cast(right), factory);
        } else {
            return doIntersect(leftType.cast(right), rightType.cast(left), factory);
        }
    }

    /**
     * Intersects the given exclude specs.
     *

     * @param object
     * @return object cast to type
     * @throws PACDecodingException
     */
    public static <T> T as ( Class<T> type, Object object ) throws PACDecodingException {
        if ( !type.isInstance(object) ) {
            throw new PACDecodingException("Incompatible object types " + type + " " + object.getClass());
        }

        return type.cast(object);
    }


    /**
     * 

            ValueSupplier.SideEffect<?> sideEffect = value.getSideEffect();
            return sideEffect == null ? provider : provider.withSideEffect(Cast.uncheckedCast(sideEffect));
        }
    }

    public static <T> ProviderInternal<T> notDefined() {
        return Cast.uncheckedCast(NULL_PROVIDER);
    }

    public static <T> ProviderInternal<T> of(T value) {
        if (value == null) {

  StringRef caller_name =
      mlir::cast<NameLoc>(callsite_loc.getCaller()).getName().strref();
  return caller_name.starts_with(kQuantizationUnitPrefix) &&
         caller_name.ends_with(kQuantizationUnitSuffix);
}

std::optional<QuantizationUnitLoc::QuantizationUnit>
FindQuantizationUnitFromLoc(Location loc) {
  if (isa<QuantizationUnitLoc>(loc)) {
    Location caller = mlir::cast<CallSiteLoc>(loc).getCaller();