// is a part of a match set.
  auto back = cluster.operations.back();
  auto loc = back->getLoc();
  OpBuilder builder(back);

  auto cluster_op =
      builder.create<tf_device::ClusterOp>(loc, return_types, policy);

  // Create block in cluster_op's region and move 'cluster.operations' into
  // it.
  auto block = builder.createBlock(&cluster_op.getBody());
  auto block_end = block->end();

      for (const auto& item : value.list().i())
        attrs.push_back(builder->getI64IntegerAttr(item));
      for (const auto& item : value.list().s())
        attrs.push_back(builder->getStringAttr(item));
      for (const auto& item : value.list().f())
        attrs.push_back(builder->getFloatAttr(builder->getF32Type(), item));
      for (const auto& item : value.list().b())

  // Removes relevant ops in topological order.
  for (auto& op : vars) RecursiveRemove(op, erase_list, dead_ops);

  // Erases the ops.
  for (auto op : erase_list) op->erase();
}

void RemoveVariablesInSessionInitializerPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  for (auto init_func_op : GetInitializerFunctions(module_op)) {
    if (!init_func_op) return;

  if (options.has_chain) result.types.push_back(chain_type);
  result.types.append(num_results, tensor_type);

  llvm::SmallVector<mlir::Attribute, 4> op_attr_array;
  for (const auto &key_value : op_attrs) {
    auto key = key_value.getName();
    auto value = key_value.getValue();
    op_attr_array.push_back(builder.getArrayAttr({key, value}));
  }

  result.attributes.push_back(

    }

    // Make a copy of the quantized function.
    auto module = call_op->getParentOfType<ModuleOp>();
    SymbolTable symbol_table(module);

    const auto f_attr = mlir::dyn_cast<FlatSymbolRefAttr>(call_op.getFAttr());
    const auto float_func =
        dyn_cast<func::FuncOp>(symbol_table.lookup(f_attr.getValue()));
    rewriter.setInsertionPointAfter(float_func);

    SmallVectorImpl<Type>* output_types) const {
  for (auto res : llvm::enumerate(signature.getResults())) {
    if (auto tensor_type = mlir::dyn_cast<TFRTensorType>(res.value())) {
      // tfr.tensor should only have one attribute attached.
      auto attr_key = tensor_type.getAttrKeys().front();
      Builder builder(signature.getContext());
      if (auto attr = attrs.lookup(attr_key.getValue())) {
        output_types->push_back(

  bool metadata_updated = false;
  auto maybe_replicate =
      execute_launches.front()->getParentOfType<tf_device::ReplicateOp>();

  for (auto execute_and_input_mapping :
       llvm::zip(execute_launches, input_mappings)) {
    auto& execute_launch = std::get<0>(execute_and_input_mapping);
    auto execute =
        llvm::cast<TF::TPUExecuteOp>(execute_launch.GetBody().front());

  StringRef func_name = func.getName();
  auto has_quantize_op = [&](const Value arg) {
    return (arg.hasOneUse() &&
            llvm::isa<quantfork::QuantizeCastOp>(*arg.user_begin()));
  };

  bool need_to_set_input_nodes_quantization_params = false;
  for (const BlockArgument arg : func.getArguments()) {
    auto shaped = mlir::dyn_cast<ShapedType>(arg.getType());

  GlobalTensorUsesMap global_tensor_uses;

  SymbolTable symbol_table(module);
  for (auto func : module.getOps<func::FuncOp>()) {
    for (size_t i = 0, e = func.getNumArguments(); i < e; i++) {
      auto sym =
          func.getArgAttrOfType<SymbolRefAttr>(i, "tf_saved_model.bound_input");
      if (!sym) {
        continue;
      }
      auto global_tensor = symbol_table.lookup<GlobalTensorOp>(

                                PatternRewriter &rewriter) const override {
    auto const_type = mlir::dyn_cast<ShapedType>(op.getType());
    if (!const_type || !const_type.getElementType().isSignlessInteger(8)) {
      return failure();
    }

    auto attr = mlir::cast<ElementsAttr>(op.getValue());
    for (mlir::APInt v : attr.getValues<mlir::APInt>()) {
      auto v_int = static_cast<int8_t>(*(v.getRawData()));
      if (v_int > 7 || v_int < -8) {