{
    std::unique_ptr<FunctionLibraryDefinition> lib_def(
        new FunctionLibraryDefinition(OpRegistry::Global(), library_expected));
    GraphDefBuilder b2(GraphDefBuilder::kFailImmediately, lib_def.get());
    Node* a = Input(b2.opts().WithName("A"));
    Node* b = Input(b2.opts().WithName("B"));

    NodeBuilder node_builder("F1", "F1", lib_def.get());
    node_builder.Input(a).Input(b);

      /*Attributes*/ {},
      // Node info
      {{{kUncompilableFunctionNodeName}, "MissingKernel", {"n_a"}}});
  flib_def_.reset(new FunctionLibraryDefinition(OpRegistry::Global(), flib));

  GraphDefBuilder builder(GraphDefBuilder::kFailImmediately, flib_def_.get());
  std::unique_ptr<Graph> graph(new Graph(flib_def_.get()));
  Node* const0 = ops::SourceOp("InputFloatOp", builder.opts());

                               FunctionLibraryDefinition* flib_def,
                               std::unique_ptr<Graph>* result) {
  auto graph = std::make_unique<Graph>(OpRegistry::Global());
  GraphOptimizationPassOptions options;
  SessionOptions session_options;
  session_options.env = Env::Default();
  options.graph = &graph;
  options.session_options = &session_options;
  options.flib_def = flib_def;
  TF_RETURN_IF_ERROR(s.ToGraph(graph.get()));

  XlaOpRegistry::RegisterCompilationKernels();
  auto flib_def = std::make_unique<FunctionLibraryDefinition>(
      OpRegistry::Global(), FunctionDefLibrary());

  XlaCompiler::Options options;
  options.device_type = DeviceType(DEVICE_GPU_XLA_JIT);
  options.client = GetLocalClient();
  options.flib_def = flib_def.get();

  std::vector<XlaCompiler::Argument> args(1);

  GraphOptimizationPassOptions CreateGraphOptimizationPassOptions(
      std::unique_ptr<Graph>* graph) {
    GraphOptimizationPassOptions options;
    options.session_options = &session_options;
    options.flib_def = &library;
    options.graph = graph;
    return options;
  }

  FunctionLibraryDefinition library;
  SessionOptions session_options;
};

// Helps set up devices for unit tests.
class DeviceSetup {

  FunctionDefLibrary flib_def;
  FunctionDef func = FunctionDefHelper::Create(
      /*function_name=*/name, /*in_def=*/{}, /*out_def=*/{"out: float"},
      /*attr_def*/
      {}, /*node_def=*/{FunctionDefHelper::Const("one", 1.0f)},
      /*ret_def=*/{{"out", "out:output:0"}});
  *flib_def.add_function() = std::move(func);
  return flib_def;
}

  }

  FixupSourceAndSinkEdges(graph.get());

  GraphOptimizationPassWrapper wrapper;
  GraphOptimizationPassOptions opt_options =
      wrapper.CreateGraphOptimizationPassOptions(&graph);
  opt_options.flib_def = &flib_def;

  BuildXlaOpsPass pass(/*enable_lazy_compilation=*/true);
  TF_RETURN_IF_ERROR(pass.Run(opt_options));
  VLOG(3) << graph->ToGraphDefDebug().DebugString();
  *result = std::move(graph);
  return absl::OkStatus();

    options.client = xla_compiler_client_->client();
    options.flib_def = flib_def_.get();
    return options;
  }

  XlaCompiler::Options DefaultPjRtOptions() {
    XlaCompiler::Options options;
    options.device_type = DeviceType(DEVICE_CPU_XLA_JIT);
    options.client = nullptr;
    options.flib_def = flib_def_.get();
    return options;
  }

  Status CreatePjRtCompilerClient() {

  TF_RETURN_IF_ERROR(DeviceFactory::AddDevices(session_options, "", &devices));

  GraphOptimizationPassOptions opt_options;
  opt_options.graph = graph;
  opt_options.session_options = &session_options;
  opt_options.flib_def = flib_def;

  if (options.enable_cluster_scoping) {
    ClusterScopingPass cluster_scoping_pass;
    TF_RETURN_IF_ERROR(cluster_scoping_pass.Run(opt_options));
  }

  MarkForCompilationPass mark_for_compilation_pass;

                           const FunctionLibraryDefinition* flib_def,
                           WritableFile* file) {
  WritableFileRawStream os(std::move(file));
  mlir::MLIRContext context;
  mlir::OwningOpRef<mlir::ModuleOp> module;
  if (flib_def) {
    flib_def = &graph.flib_def();
  }
  auto convert = [&]() -> Status {
    mlir::StatusScopedDiagnosticHandler status_handler(&context);