mlir::Builder builder(ctx);

  // Collect devices with attached metadata.
  llvm::SmallVector<mlir::NamedAttribute, 8> devices;
  devices.reserve(device_set->devices().size());

  // For device that do not have any metadata, or if we failed to parse metadata
  // from the DeviceSet, we add a unit attribute to the `tf.devices` attribute.
  for (Device* device : device_set->devices()) {

    }

    auto layout = mlir::GetTPUInfeedLayout(
        mlir::TupleType::get(builder.getContext(), result_types), builder);
    if (failed(layout)) return mlir::WalkResult::interrupt();
    // Do not append a UnitAttr for the "token" operand here to avoid
    // compilation failure when exporting the "layouts" attribute to a graph
    // node. Instead, add the UnitAttr during LegalizeTF pass.

  if (absl::Status status = AddCalibrationStatistics(
          module_op, calibration_data_dir, config.calibration_options(),
          *py_function_lib_);
      !status.ok()) {
    LOG(WARNING) << "Some CustomAggregator ops do not have min or max "
                    "values. Parts of the graph are not quantized. "
                 << status;
  }

  return module_op;
}

==============================================================================*/

// This file wraps TensorFlow Graph(Def) to MLIR module conversion into passes
// to satisfy the API of MLIR pass registration. In order to do this, the
// command-line option header is pulled in.

#include <memory>
#include <utility>

#include "absl/container/flat_hash_set.h"
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project

Status CreateCond(const Scope& scope, const CondGraphBuilderFn& cond,
                  const std::vector<Output>& inputs, Output* output) {
  // The control dependency is for constants in the cond graph, and other ops
  // that do not depend on the loop variables. This ensures that these ops are
  // in the while loop frame (since they will indirectly depend on an Enter node
  // defining the frame) and that they are executed once per loop iteration.
  //

      BlankLine();
      BlockOpen("void TestFunction()");
      {
        Statement("int i = 1");
        BlankLine();
        BlockOpen("while (i == 1)");
        {
          CommentLine("Do nothing, really....");
          CodeLine("#if 0");
          Statement("call()");
          CodeLine("#endif");
          BlockClose();
        }
        BlockClose("  // comment ending TestFunction");
      }

    rewriter.eraseOp(call_op);
    func_op.eraseResult(0);
    func_op.insertResult(0, new_call_op.getResult(0).getType(),
                         /*resultAttrs=*/nullptr);

    // Modify the quantized fused function to do dequantize+relu(6).
    rewriter.setInsertionPoint(req_op);
    Value new_result = rewriter.create<mlir::stablehlo::UniformDequantizeOp>(
        req_op.getLoc(), func_op.getResultTypes()[0], req_op.getOperand());

  // First, we need to convert from functional, to executor dialect.
  pm.addNestedPass<FuncOp>(
      mlir::CreateFunctionalToExecutorDialectConversionPass());

  // Do a single pass to split the graph's single island op into an island per
  // op as expected by the following passes.
  pm.addNestedPass<FuncOp>(mlir::TF::CreateSplitIntoIslandPerOpPass());

    const jit::DeviceInfoCache& device_info_cache,
    const jit::DeviceSet& devices, bool allow_mixing_unknown_and_cpu,
    bool failure_to_pick_is_error) {
#define FAILED_TO_PICK_DEVICE(failing_status) \
  do {                                        \
    if (failure_to_pick_is_error) {           \
      return failing_status;                  \
    } else {                                  \

  Type type = GetGlobalType(source);
  std::string name = GetVariableName(source);
  if (auto existing = symbol_table.lookup<ml_program::GlobalOp>(name)) {
    // This might be of a different type, but we'll do a Cast later.
    return existing;
  }

  Attribute initial_value = GetInitialValue(source);
  if (!initial_value) {
    initial_value = builder.getZeroAttr(type);
    if (!initial_value) {