void runOnOperation() override;
};

void GetArithmeticCountPass::runOnOperation() {
  auto func = getOperation();
  OpBuilder builder(func);
  func->walk([&](TflArithmeticCountOpInterface arithmetic_count_op) {
    Operation* op = arithmetic_count_op.getOperation();
    int64_t arithmetic_count = arithmetic_count_op.GetArithmeticCount(op);
    auto attr =

		expected: []string{"all"},
	}}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			actual := MergeTolerations(getTolerations(test.a), getTolerations(test.b))
			require.Len(t, actual, len(test.expected))
			for i, expect := range getTolerations(test.expected) {
				assert.Equal(t, expect, actual[i], "expected[%d] = %s", i, test.expected[i])
			}
		})
	}
}

  explicit RuntimeVerifyPass() {}

 private:
  void runOnOperation() override;
};

void RuntimeVerifyPass::runOnOperation() {
  getOperation().walk([&](TflRuntimeVerifyOpInterface op) {
    if (failed(op.VerifyTflRuntimeConstraints(
            op.getOperation(), /*emit_error_on_verify_fail=*/true)))
      signalPassFailure();
  });
}
}  // namespace

// Verifies TFL runtime constraints.

    mlir::SymbolRefAttr sym = callable.dyn_cast<mlir::SymbolRefAttr>();
    auto symbol =
        mlir::SymbolTable::lookupNearestSymbolFrom(call.getOperation(), sym);
    if (!symbol) return failure();
    auto f = llvm::dyn_cast<mlir::func::FuncOp>(symbol);

    if (call.getOperation()->getNumOperands() !=
        f.getBody().front().getNumArguments()) {
      return failure();  // RemoteCall et al
    }

    auto call = llvm::cast<CallOpInterface>(pcall_op.getOperation());
    auto callee =
        llvm::cast<FuncOp>(call.resolveCallable(&symbol_table_collection));
    callee->setAttr(noinline_attr_name, builder.getBoolAttr(true));
  }
  return mlir::success();
}

void XlaClusterFormationPass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTableCollection symbol_table_collection;

  if (llvm::isa<WhileOp, WhileRegionOp>(op))
    op->removeAttr(kShapeInvariantAttr);
}
void DropWhileShapeInvariantPass::runOnOperation() {
  getOperation().walk([](Operation* op) { DropWhileShapeInvariantAttr(op); });
}

void DropWhileShapeInvariantInDeviceClusterPass::runOnOperation() {
  getOperation().walk([](tf_device::ClusterOp cluster) {
    cluster.walk([](Operation* op) { DropWhileShapeInvariantAttr(op); });
  });
}
}  // namespace

    Operation* inlined_point = call_op.getOperation();
    Operation* after_inlined_point =
        &*std::next(Block::iterator(call_op.getOperation()));

    // Use the inliner to replace all the uses of the call_op by its
    // composition.
    if (failed(inlineCall(inliner,
                          cast<CallOpInterface>(call_op.getOperation()),

  int64_t total_size_transferred = 0;
  for (auto input : to_graph.getOperands()) {
    Operation* input_op = input.getDefiningOp();
    if (input_op && input_op == from_graph.getOperation()) {
      auto input_type =
          mlir::dyn_cast_or_null<RankedTensorType>(input.getType());
      if (input_type == nullptr || !input_type.hasStaticShape()) continue;

 public:
  using OpRewritePattern<SrcOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(SrcOp srcop,
                                PatternRewriter &rewriter) const final {
    Operation *op = srcop.getOperation();
    bool allTypesFp = true;
    bool allTypesQuantizedOrInt = true;
    for (auto operand : op->getOperands()) {
      ShapedType type = mlir::dyn_cast<ShapedType>(operand.getType());
      if (!type) continue;

    }
    // Use the min/max from the operands and the num_bits and narrow_range
    // attribute to create the quantization parameter for the new quantize op.
    rewriter.setInsertionPointAfter(tf_op.getOperation());
    IntegerAttr num_bits = rewriter.getI64IntegerAttr(tf_op.getNumBits());
    BoolAttr narrow_range = rewriter.getBoolAttr(tf_op.getNarrowRange());
    Type res_type = tf_op.getType();