The `tf.IfrtCall` kernel uses the output $array_key.
    Other ops executed by TFRT may make use of $tensor_future.
  }];

  let arguments = (ins
    TFTensorType:$variable,
    DefaultValuedAttr<BoolAttr, "false">:$used_by_host
  );

  let results = (outs
    TFTensorType:$array_key,
    MlrtFutureType: $tensor_future
  );
}

def IfrtRestoreVariableOp: TensorflowMlrt_Op<"ifrt_restore_variable", []> {

  auto operands = adaptor.getOperands();
  assert(operands.size() == 2 && "equal op has two operands");
  auto ctx = getContext();
  if (operands[0] == operands[1]) return BoolAttr::get(ctx, true);
  return BoolAttr::get(ctx, false);
}

OpFoldResult ConstOp::fold(FoldAdaptor adaptor) {
  auto operands = adaptor.getOperands();
  (void)operands;
  assert(operands.empty() && "constant has no operands");

                          lhs_dot_dimensions_info.FlattenedOutDimensionSize()},
                      llvm::ArrayRef<int64_t>{
                          rhs_dot_dimensions_info.FlattenedOutDimensionSize()});
  BoolAttr false_attr = rewriter.getBoolAttr(false);
  auto matmul = rewriter.create<TFL::BatchMatMulOp>(
      loc, RankedTensorType::get(matmul_shape, result_type.getElementType()),

                                      ImplicitLocOpBuilder& builder,
                                      bool is_lhs) {
  auto operand_type = mlir::cast<ShapedType>(operand.getType());
  BoolAttr true_attr = builder.getBoolAttr(true);
  auto operand_shape = builder.create<TF::ShapeOp>(operand, true_attr);
  const int64_t operand_rank = operand_type.getRank();

           << "]";

  return success();
}

bool VariableIsInitialized(TF::VarHandleOp var_handle_op) {
  auto is_variable_initialized =
      var_handle_op->getAttrOfType<BoolAttr>("_is_initialized");
  // Assume variable is initialized if attribute is not set.
  // There are paths that doesn't mark the variables. All variables
  // that doesn't have the attribute will be promoted.

  NativeCodeCall<"GetI64ElementsAttr({" # value # "}, &$_builder)">;

class GetF32Scalar<int value> :
  NativeCodeCall<"GetF32Scalar(&$_builder, " # value # ")">;

def TrueBoolAttr : AttrConstraint<CPred<"$_self.cast<::mlir::BoolAttr>().getValue()">>;

def CreateTFShapeOp : NativeCodeCall<
    "$_builder.create<TF::ShapeOp>($0.getLoc(), $1, $2)">;

def IsI32 : NativeCodeCall<

    return true;
  }

  OpBuilder builder(func);
  bool is_signed = quant_specs_.IsSignedInferenceType();
  IntegerAttr num_bits =
      builder.getI32IntegerAttr(quant_specs_.GetQuantizationTypeWidth());
  BoolAttr narrow_range = builder.getBoolAttr(false);

  auto add_quantize_op = [&](Location loc, Type input_type, Block* block,
                             Block::iterator insertion_point, Value arg,

bool IsStatefulFunctionalControlFlowOp(Operation* op) {
  if (!isa<TF::IfOp, TF::CaseOp, TF::WhileOp>(op)) {
    return false;
  }

  if (auto is_stateless = op->getAttrOfType<BoolAttr>("is_stateless")) {
    return !is_stateless.getValue();
  }
  return false;
}

// Add control dependencies from stateful control-flow ops to graph fetch op.

    return true;
  }

  OpBuilder builder(func);
  bool is_signed = quant_specs_.IsSignedInferenceType();
  IntegerAttr num_bits =
      builder.getI32IntegerAttr(quant_specs_.GetQuantizationTypeWidth());
  BoolAttr narrow_range = builder.getBoolAttr(false);

  auto add_quantize_op = [&](Location loc, Type input_type, Block* block,
                             Block::iterator insertion_point, Value arg,

        // the asymmetric_quantize_inputs attribute in the builtin option.
        dynamic_range_quantized_user->setAttr(
            kAsymmetricQuantizeInputsAttr,
            BoolAttr::get(rewriter.getContext(), true));
        changed = true;
      }
    }
    return changed;
  }

  // Convert ConstantOp-CastOp-Operation sequence into new ConstantOp