// 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) {

  }
  return it->second.potentially_written;
}

// Analyze the specified region for resource mutating operations, namely
// TF::AssignVariableOp, if so, set the resource associated as "potentially
// written". Do this recursively across the chain of regions via call or
// control flow ops.
// TODO(ashwinm): Move to iterative traversal.
LogicalResult ResourceAnalyzer::AnalyzeRegion(Region& region) {
  // Avoid infinite recursion.

      Function tf_function;
      for (const std::string& fn_name :
           child_node.function().concrete_functions()) {
        // Setup input signature.
        //
        // For now, we have to do a lot of manual digging through these and
        // assume they are tensorspecs. Once TODO(b/190203981) is done, we
        // should be able to pass along the `StructuredValue`s to an API in a
        // much cleaner way.

                                  PatternRewriter& rewriter) {
      // Move the first block of `tf_then_or_else_region` into the first block
      // of `scf_then_or_else_region` and do not add any arguments to the block.
      moveBlock(&tf_then_or_else_region.front(),
                &scf_then_or_else_region.front(), TypeRange(), rewriter);

limitations under the License.
==============================================================================*/
)";

static const char *machine_generated =
    "// This file is MACHINE GENERATED! Do not edit.";

CppFileRenderer::CppFileRenderer(RendererContext context,
                                 const std::vector<OpView> &ops)
    : Renderer(context),
      guard_(context),
      name_space_(context),

using ::tensorflow::SignatureDef;
using ::tensorflow::quantization::PyFunctionLibrary;

// Note for maintainers: the definitions should ONLY mirror existing functions
// defined in different targets. Do not include any extra business logic that
// causes divergence from the semantics of mirrored functions.

absl::Status PywrapQuantizeStaticRangePtq(
    absl::string_view src_saved_model_path,

        TF::TensorFlowDialect::getDialectNamespace())
      return failure();

    // Refining types may have implications to the attached regions or symbol
    // references so do not update such ops.
    if (!op->getRegions().empty() || HasSymbolRefAttr(op)) return failure();

    IRMapping mapper;
    bool has_type_change = false;

}

TEST(PickDeviceForXla, MoreSpecificDevice) {
  CheckPickDeviceResult(kCPU0, false, {kCPU0, kCPU0Partial});
  CheckPickDeviceResult(kGPU0, false, {kGPU0, kGPU0Partial});
  // Unknown devices do not support merging of full and partial specifications.
  CheckPickDeviceHasError(false, {kXPU1, kXPU0Partial});
}

TEST(PickDeviceForXla, DeviceOrder) {
  CheckPickDeviceResult(kGPU0, false, {kGPU0, kCPU0});