ConstantOpDeviceAssignmentPass> {
  void runOnOperation() override;
};

void ConstantOpDeviceAssignmentPass::runOnOperation() {
  ModuleOp module = getOperation();

  module.walk([&](TF::ConstOp op) {
    // Keep the ConstOp if the op already have the device attribute.
    if (StringAttr device_attr = op->getAttrOfType<StringAttr>(kDeviceAttr)) {
      return WalkResult::advance();
    }
    OpBuilder builder(op);

      .replaceAllUsesWith(cloned_const_op->getResult(0));
}

bool IsConstOrQConstInt(Operation* op) {
  if (!llvm::isa<TFL::ConstOp, TFL::QConstOp, arith::ConstantOp>(op))
    return false;

  if (auto arith_const_op = dyn_cast_or_null<arith::ConstantOp>(op)) {
    // arith ConstOp path.
    auto type =
        mlir::cast<ShapedType>(arith_const_op.getType()).getElementType();

      loc, mlir::RankedTensorType::get({}, getElementTypeOrSelf(shape)), shape,
      /*begin=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({idx})),
      /*end=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({idx + 1})),
      /*strides=*/
      builder->create<TF::ConstOp>(loc, builder->getI32TensorAttr({1})),
      /*begin_mask=*/0, /*end_mask=*/0, /*ellipsis_mask=*/0,

  builder.setInsertionPointAfter(op);
  for (const auto& result_value : result_values) {
    results.push_back(builder.create<TF::ConstOp>(op->getLoc(), result_value));
  }
  return success();
}

bool IsOperationFoldable(Operation* op) {
  if (isa<TF::ConstOp>(op)) return true;

  if (op->getDialect()->getNamespace() != "tf" || !TF::CanBeFolded(op)) {
    return false;
  }

  // Check if the operands are foldable as well.

type Prog struct {
	Inst   []Inst
	Start  int // index of start instruction
	NumCap int // number of InstCapture insts in re
}

// An InstOp is an instruction opcode.
type InstOp uint8

const (
	InstAlt InstOp = iota
	InstAltMatch
	InstCapture
	InstEmptyWidth
	InstMatch
	InstFail
	InstNop
	InstRune
	InstRune1
	InstRuneAny
	InstRuneAnyNotNL
)

class QuantizeConstWeights : public OpRewritePattern<TF::ConstOp> {
 public:
  explicit QuantizeConstWeights(
      MLIRContext* context,
      const tensorflow::quantization::QuantizationOptions& quantization_options)
      : OpRewritePattern<TF::ConstOp>(context),
        quant_options_(quantization_options) {}

  LogicalResult matchAndRewrite(TF::ConstOp op,

	s.parseState = s.parseState[0:0]
	s.err = nil
	s.endTop = false
}

// eof tells the scanner that the end of input has been reached.
// It returns a scan status just as s.step does.
func (s *scanner) eof() int {
	if s.err != nil {
		return scanError
	}
	if s.endTop {
		return scanEnd
	}
	s.step(s, ' ')
	if s.endTop {
		return scanEnd
	}
	if s.err == nil {

                  .Input(inputs)
                  .Attr("ids", ids)
                  .Attr("calibration_methods", calibration_methods)
                  .Finalize(node_def()));
  ASSERT_THAT(InitOp(),
              StatusIs(tsl::error::INVALID_ARGUMENT,
                       HasSubstr("NodeDef missing attr 'output_file_path'")));
}

TEST_F(CalibrationStatisticsSaverTest, WrongNumInputs) {

      // defined above and sink these constants in the region body.
      // The sunk_constant map keeps a mapping from a ConstOp defined above to
      // a sunk clone of it. This allows for reusing a sunk constant with
      // multiple uses in the region.
      llvm::DenseMap<Value, TF::ConstOp> sunk_constant;
      Region &body = cluster.getBody();
      visitUsedValuesDefinedAbove(body, [&](OpOperand *use) {

    Value step_size = rewriter.create<ConstOp>(loc, GetScalarOfType(u64, 256));
    Value increment =
        rewriter.create<MulOp>(loc, u64_scalar, step_size, rng_op.getDelta());

    // Increment the counter.
    SmallVector<Value, 4> pack_args;
    RankedTensorType word_u64_type = RankedTensorType::get({}, u64);
    Value zero_u64 = rewriter.create<ConstOp>(loc, GetScalarOfType(u64, 0));