}

    @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;
    }

    if (!mlir::cast<ShapedType>(lhs.getType()).hasStaticShape() ||
        !mlir::cast<ShapedType>(rhs.getType()).hasStaticShape() ||
        !mlir::cast<ShapedType>(cond.getType()).hasStaticShape()) {
      return rewriteOpWithDynamicInput(op, rewriter);
    }

    auto lhs_shape = mlir::cast<ShapedType>(lhs.getType()).getShape();
    auto rhs_shape = mlir::cast<ShapedType>(rhs.getType()).getShape();

  for (int i : llvm::seq<int>(1, num_dims - 1)) {
    Value input_size_i = GetDimValue(builder, loc, input_shape_value, i);
    const int stride_i = mlir::cast<IntegerAttr>(strides[i]).getInt();
    const int dilation_i = mlir::cast<IntegerAttr>(dilations[i]).getInt();
    const int filter_i = filter_shape.getDimSize(i - 1);
    Value pad_i_low, pad_i_high;
    GetSamePaddingValues(builder, loc, input_size_i, filter_i, dilation_i,

            return Cast.uncheckedNonnullCast(STRING_SERIALIZER);
        }
        if (type.equals(Long.class)) {
            return Cast.uncheckedNonnullCast(LONG_SERIALIZER);
        }
        if (type.equals(File.class)) {
            return Cast.uncheckedNonnullCast(FILE_SERIALIZER);
        }
        if (type.equals(byte[].class)) {
            return Cast.uncheckedNonnullCast(BYTE_ARRAY_SERIALIZER);
        }

  "$0.isa<DenseElementsAttr>() && "
  "$0.cast<DenseElementsAttr>().getNumElements() == 1 && "
  "(($0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isLargest() && "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegative()) || "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegInfinity())">>;

def L2NormValidReduceIndex : Constraint<CPred<
  "L2NormalizeReduceAxis($0, $1.cast<DenseElementsAttr>())">>;

// StableHLO+TFL --> VHLO+TFL Ops
//===----------------------------------------------------------------------===//

// Wrap op result uses in an unrealized cast to create a cast to buffer
// any type changes to result, and apply type converter to result:
//   result = op(V0)
//   V1     = op2(result)
//   ==>
//   result = op(V0)
//   V1     = unrealized_cast(result)

        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.
     *

    Operation* filter_op = filter_value.getDefiningOp();
    auto filter_uniform_quantized_type =
        GetElementType(filter_value).cast<UniformQuantizedPerAxisType>();
    auto filter_constant_value_attr = cast<DenseIntElementsAttr>(
        cast<stablehlo::ConstantOp>(filter_value.getDefiningOp()).getValue());
    const DenseIntElementsAttr new_filter_value_attr =

  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();

                    compatible.add(new AssessedAttribute<>(attribute, Cast.uncheckedCast(consumerValue.get()), Cast.uncheckedCast(producerValue.get())));
                } else {
                    incompatible.add(new AssessedAttribute<>(attribute, Cast.uncheckedCast(consumerValue.get()), Cast.uncheckedCast(producerValue.get())));
                }
            } else if (consumerValue.isPresent()) {