auto variableOp = globalBuilder.create<ml_program::GlobalOp>(
        globalTensor.getLoc(), name, globalTensor.getType(),
        globalTensor.getIsMutable(), initial_value,
        /*visibility=*/globalBuilder.getStringAttr("private"));
    variableOp.setPrivate();
  }

  SymbolTable syms(module);
  for (auto func : module.getOps<func::FuncOp>()) {
    if (!tf_saved_model::IsExported(func)) {
      continue;
    }

                                    Block* insertion_point) {
  rewriter.setInsertionPointToStart(insertion_point);

  auto ftype = FunctionType::get(rewriter.getContext(), {type}, {type});
  auto name = rewriter.getStringAttr("gelu_decomp");
  func::FuncOp new_func = rewriter.create<func::FuncOp>(
      insertion_point->front().getLoc(), name, ftype);
  new_func.setPrivate();
  new_func.addEntryBlock();

            attrs.push_back(named_attr);
          } else {
            std::vector<StringRef> temp;
            for (size_t i = 0; i < vector.size(); i++) {
              auto conf_str =
                  builder->getStringAttr(vector[i].AsString().str());
              temp.push_back(conf_str);
            }
            ArrayRef<StringRef> values(temp);
            auto named_attr =

                                        ",", group_annotation);
      }
      for (auto& op : execute_island.GetBody()) {
        op.setAttr(TF::kParallelExecAnnotation,
                   builder->getStringAttr(group_annotation));
      }
    }

    executes.push_back(execute_island);
  }
}

void CreateIslandsFromParallelExecute(
    tf_executor::IslandOp island_op,

  BlockArgument new_file_prefix_arg =
      main_func_op.getBody().front().addArgument(
          file_prefix_arg_type,
          NameLoc::get(builder.getStringAttr(kTfFilePrefix)));

  SmallVector<Type> input_types(main_func_op.getArgumentTypes());
  input_types.emplace_back(file_prefix_arg_type);

  main_func_op.setType(

         llvm::zip_equal(quantizable_values, aggregator_ids)) {
      // ID attribute will have empty value for now.
      SmallVector<NamedAttribute, 5> attributes{
          rewriter.getNamedAttr("id", rewriter.getStringAttr(aggregator_id)),
          rewriter.getNamedAttr(
              "calibration_method",
              rewriter.getI32IntegerAttr(calib_opts_.calibration_method())),
          rewriter.getNamedAttr("num_bins",

      CreateEinsumEquation(dot_dimension_numbers, lhs_rank, rhs_rank);

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

// Restores the collapsed dimensions to the `tensor_type`. `collapsed_dims`
// designate the dimension indices that were collapsed to produce `tensor_type`.

      output_types = {output_type.clone(elem_type.getStorageType())};
    }

    SmallVector<Value> args = {q_op.getArg(), scale, zero_point};
    FlatSymbolRefAttr func_name =
        FlatSymbolRefAttr::get(rewriter.getStringAttr(kQuantizeFuncName));

    auto quantize_call = rewriter.create<TF::PartitionedCallOp>(
        loc, output_types, args, func_name,
        /*config=*/"", /*config_proto=*/"", /*executor_type=*/"");

      input_cell_state_, input_layer_norm_coefficients_,
      forget_layer_norm_coefficients_, cell_layer_norm_coefficients_,
      output_layer_norm_coefficients_, builder_.getStringAttr("TANH"),
      builder_.getF32FloatAttr(10.0), builder_.getF32FloatAttr(0.0),
      mlir::TFL::LSTMKernelTypeAttr::get(builder_.getContext(),
                                         mlir::TFL::LSTMKernelType::FULL),

// MatrixSetDiag op patterns.
//===----------------------------------------------------------------------===//

class GetStrAttr<string x>: NativeCodeCall<
  "$_builder.getStringAttr(\"" # x # "\")">;

def MatrixSetDiagToV3 : Pat<
  (TF_MatrixSetDiagOp:$src $input, $diag),
  (TF_MatrixSetDiagV3Op:$dest $input, $diag, (TF_ConstOp (GetI32Attr<0>)),
    (GetStrAttr<"RIGHT_LEFT">)),