// 000 0105673E ABS    notype       Static       | @comp.id
            // 001 80000191 ABS    notype       Static       | @feat.00
            // 002 00000000 SECT1  notype       Static       | .drectve
            // 005 00000000 SECT2  notype       Static       | .debug$S
            // 008 00000000 SECT3  notype       Static       | .debug$T
            // 00B 00000000 SECT4  notype       Static       | .text$mn

      for (auto operand : candidate_op->getOperands()) {
        Type operand_type = operand.getType();
        if (mlir::isa<NoneType>(operand_type)) {
          inputs.push_back(operand);
          continue;
        }

        auto ele_type =
            mlir::cast<TensorType>(operand.getType()).getElementType();
        if (auto dq_op =

  auto cast_op =
      OpBuilder(old_val.getDefiningOp())
          .create<tensor::CastOp>(old_val.getLoc(), old_val.getType(), new_val);
  old_val.replaceAllUsesWith(cast_op);
}

void ReplaceAllUsesExceptTerminator(Value old_val, Value new_val) {
  if (old_val.getType() == new_val.getType()) {
    old_val.replaceAllUsesWith(new_val);
    return;
  }
  Operation* old_op = old_val.getDefiningOp();

		t.Run(tt.name, func(t *testing.T) {
			gotMajorVersion, gotVType, gotMinorVersion, gotOk := parseKubeVersion(tt.v)
			if gotMajorVersion != tt.wantMajorVersion {
				t.Errorf("parseKubeVersion() gotMajorVersion = %v, want %v", gotMajorVersion, tt.wantMajorVersion)
			}
			if gotVType != tt.wantVType {
				t.Errorf("parseKubeVersion() gotVType = %v, want %v", gotVType, tt.wantVType)
			}
			if gotMinorVersion != tt.wantMinorVersion {

    if (!mlir::isa<quant::UniformQuantizedType>(
            (getElementTypeOrSelf(op.getOutput().getType()))))
      return failure();

    ElementsAttr input_tensor = qconst_op.getValue();

    assert(perm_tensor.getType().getRank() == 1);
    const int num_dimensions = input_tensor.getShapedType().getRank();
    assert(perm_tensor.getType().getNumElements() == num_dimensions);

                    _INVOKESTATIC(getType(InstrumentedGroovyMetaClassHelper.class).getInternalName(), "addInvocationHooksInClosureDispatchObject", descriptor, false);

                    _ALOAD(0);
                    _ALOAD(1);
                    _INVOKESPECIAL(getType(Closure.class).getInternalName(), "setDelegate", "(Ljava/lang/Object;)V", false);

    // we have separate ops for them. If only one of them is used then the other
    // one will be garbage collected later.
    if (!mlir::isa<ShapedType>(operand.getType())) return failure();
    auto operand_type = mlir::cast<ShapedType>(operand.getType());
    if (operand_type.getElementType().isInteger(1)) {
      // TF does not support min or max on boolean (int1) arguments.
      // Use AnyOp for MaxOp and AllOp for MinOp.

    BuildableType<"$_builder.getType<::mlrt::compiler::FutureType>()"> {
  let description = [{
    `!mlrt.future type` represents a C++ mlrt::Future.
  }];
}

def MlrtPromiseType : DialectType<Mlrt_Dialect,
    CPred<"$_self.isa<::mlrt::compiler::PromiseType>()">, "!mlrt.promise type">,
    BuildableType<"$_builder.getType<::mlrt::compiler::PromiseType>()"> {
  let description = [{

    const size_t idx = shape_offset_idx.index();

    if (failed(verifyCompatibleShape(shape.getType(), offset.getType())))
      return op.emitOpError() << "requires operand and result " << idx
                              << " to have compatible shapes";

    auto ranked_shape = mlir::dyn_cast<RankedTensorType>(shape.getType());
    if (!ranked_shape) continue;

    if (ranked_shape.getRank() != 1)

  const int lhs_rank = mlir::cast<ShapedType>(lhs.getType()).getShape().size();
  const int rhs_rank = mlir::cast<ShapedType>(rhs.getType()).getShape().size();

  const std::string einsum_equation =
      CreateEinsumEquation(dot_dimension_numbers, lhs_rank, rhs_rank);

  return builder.create<TF::EinsumOp>(loc, output.getType(), input_arguments,