mlir::ModuleOp::create(mlir::UnknownLoc::get(&context));
  mlir::Builder builder(*module_ref);
  (*module_ref)
      ->setAttr("tf.devices",
                builder.getDictionaryAttr(builder.getNamedAttr(
                    "bad_device", builder.getDictionaryAttr({}))));

  mlir::TF::RuntimeDevices devices;
  EXPECT_TRUE(mlir::failed(GetDevicesFromOp(*module_ref, &devices)));
}

  attrs.push_back(rewriter.getNamedAttr("output_quantization_axis",
                                        rewriter.getI64IntegerAttr(quant_dim)));

  op->setAttrs(rewriter.getDictionaryAttr(attrs));

  return success();
}

// This LogicalResult covers both the hybrid and fully quantized op cases.
LogicalResult FillAttributesForUniformQuantizedConvolutionOp(

      b.getI32ArrayAttr(llvm::ArrayRef<int32_t>(
          versions.bad_consumers().data(),
          versions.bad_consumers().data() + versions.bad_consumers().size())));
  module->setAttr("tf.versions",
                  b.getDictionaryAttr(llvm::ArrayRef<mlir::NamedAttribute>(
                      {producer, min_consumer, bad_consumers})));
}

mlir::LogicalResult ExtractTfVersions(mlir::ModuleOp module,

                            ConvertAttributeValue(func_attr.second, builder));
        attrs.push_back(builder->getNamedAttr(func_attr.first, attr));
      }
      auto func_attrs = builder->getDictionaryAttr(attrs);
      return mlir::TF::FuncAttr::get(builder->getContext(), value.func().name(),
                                     func_attrs);
    }
    default:

  // Jax wrapped the output nodes in a tuple, so it's pretty hard to us
  // to tell the output at this point, we will set the output at the export
  // phase.
  main_func->setAttr("tf.entry_function", builder.getDictionaryAttr(attrs));

  // StableHLO Quantizer is not supported for JAX input models, so
  // quantization_py_function_lib is set to nullptr.
  auto status = internal::ConvertMLIRToTFLiteFlatBuffer(

    } else {
      auto metadata = builder.getUnitAttr();
      devices.push_back(builder.getNamedAttr(name, metadata));
    }
  }

  op->setAttr(kDevicesAttr, builder.getDictionaryAttr(devices));
}

mlir::LogicalResult GetDevicesFromOp(mlir::Operation* op,
                                     mlir::TF::RuntimeDevices* devices) {
  auto devices_attr = op->getAttr(kDevicesAttr);

        kCalledIndexAttrName, builder.getI64IntegerAttr(it->second)));

    // Set the `tf.backend_config` attribute to the `new_config`.
    op->setAttr(kTfBackendConfigAttrName,
                builder.getDictionaryAttr(new_config));

    return WalkResult::advance();
  });
  if (result.wasInterrupted()) {
    return failure();
  }

  return builder.getArrayAttr(function_list);
}

            StringAttr::get(func.getContext(), it->getSecond())));
      }
    }
  }

  llvm::SmallVector<DictionaryAttr, 8> tmp;
  for (const auto& res : result_attrs) {
    tmp.push_back(builder.getDictionaryAttr(res));
  }
  func.setAllResultAttrs(tmp);
}

#define GEN_PASS_DEF_TPUDEVICEPROPAGATIONPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

struct TPUDevicePropagation

      /*shape=*/{}, /*elementType=*/builder.getType<TF::StringType>());
  const auto file_prefix_attr = builder.getStringAttr(kTfFilePrefix);
  const auto arg_attrs = builder.getDictionaryAttr({builder.getNamedAttr(
      kTfSavedModelIndexPathAttr, builder.getArrayAttr({file_prefix_attr}))});

  const int insert_idx = func_op.getNumArguments();

    SymbolTable table(root);
    (void)table.renameToUnique(func, {});

    rewriter.setInsertionPointAfter(output_mul);
    auto composite_attrs = rewriter.getDictionaryAttr(
        {rewriter.getNamedAttr("approx", rewriter.getBoolAttr(false))});
    auto composite_op = rewriter.create<stablehlo::CompositeOp>(
        output_mul.getLoc(), func.getResultTypes()[0],