ops::Switch switch_b(root.WithOpName("switch_b"), value, cond_b);

  Output add_a = ops::Add(root.WithOpName("add_a"), switch_a.output_true,
                          switch_b.output_true);
  Output add_b = ops::Add(root.WithOpName("add_b"), switch_a.output_true,
                          switch_b.output_true);
  Output add = ops::Add(root.WithOpName("add_c"), add_a, add_b);

  std::unique_ptr<Graph> graph(new Graph(OpRegistry::Global()));

// Other attributes should be left untouched.
// CHECK-SAME: attributes {tf.entry_function = {inputs = "add_x:0,add_y:0", outputs = "add:0"}}

// Test the newly created "main" function.
// CHECK: func.func @main(%[[ARG0:.*]]: tensor<1xf32> {tf_saved_model.index_path = ["add_x:0"]}, %[[ARG1:.*]]: tensor<1xf32> {tf_saved_model.index_path = ["add_y:0"]})
// CHECK-SAME: -> (tensor<1xf32> {tf_saved_model.index_path = ["add:0"]})

  [(IsNotInLiftedFunc $res),
   (FloatValueEquals<"0"> $cst), (IsStableHLOConstantOp $bias), (AreTheSameValue $conv_0, $conv_1), (AreTheSameValue $add_0, $add_1)], [], (addBenefit 15)>;

def LiftDotGeneralWithBiasAndReluDynamic : Pat<
  (StableHLO_MaxOp:$res
    (StableHLO_AddOp:$add_0
      (StableHLO_DotGeneralOp:$dot_general_0 $lhs, $rhs, $dot_dimension_numbers, $precision_config),
      (StableHLO_DynamicBroadcastInDimOp

namespace tensorflow {

TEST(ScopeTest, BasicNames) {
  Scope root = Scope::NewRootScope();
  EXPECT_EQ(root.GetUniqueNameForOp("add"), "add");
  EXPECT_EQ(root.GetUniqueNameForOp("add"), "add_1");
  EXPECT_EQ(root.GetUniqueNameForOp("add"), "add_2");
  EXPECT_EQ(root.GetUniqueNameForOp("mul"), "mul");
}

TEST(ScopeTest, OpAndScopeNameCollision) {
  Scope root = Scope::NewRootScope();
  EXPECT_EQ(root.GetUniqueNameForOp("foo"), "foo");

  for (mlir::Attribute a : attr.getValue()) {
    if (auto attr = mlir::dyn_cast<mlir::BoolAttr>(a)) {
      list->add_b(attr.getValue());
    } else if (auto attr = mlir::dyn_cast<mlir::IntegerAttr>(a)) {
      list->add_i(attr.getInt());
    } else if (auto attr = mlir::dyn_cast<mlir::FloatAttr>(a)) {
      list->add_f(attr.getValueAsDouble());
    } else if (auto attr = mlir::dyn_cast<mlir::StringAttr>(a)) {
      AttrValue nested_value;

  Run({{func_feed, Int32Tensor(3)}}, {{func_op, 0}, {func_op, 1}}, {5, 5});
  VerifyFDef({"add_1"}, M({{"feed1"}, {"feed2"}}), M({{"add"}, {"add_0"}}),
             {{"feed1", "add_1:0"},
              {"feed2", "add_1:1"},
              {"add_1:sum:0", "add"},
              {"add_1:sum:0", "add_0"}},
             {});
}

TEST_F(CApiFunctionTest, TwoDuplicateOutputs_OutputNames) {
  /*

      ->set_global_jit_level(OptimizerOptions::ON_2);
  std::unique_ptr<Session> session(NewSession(options));

  TF_ASSERT_OK(session->Create(graph_def));

  std::vector<std::string> output_names = {std::string("add_4:0")};

  Tensor tensor_2x2(DT_FLOAT, TensorShape({2, 2}));
  for (int i = 0; i < 4; i++) {
    tensor_2x2.matrix<float>()(i / 2, i % 2) = 5 * i;
  }

  Tensor tensor_3x3(DT_FLOAT, TensorShape({3, 3}));

          }
        }
      }
    }
    node_def {
      name: "add_1"
      op: "Add"
      input: "while_loop_counter"
      input: "add_1/y:output:0"
      attr {
        key: "T"
        value {
          type: DT_INT32
        }
      }
    }
    ret {
      key: "output"
      value: "add_1:z:0"
    }
    ret {
      key: "output_1"

    // CHECK-ROUNDTRIP:  %0 = stablehlo.composite "stablehlo.add_n" %arg0 {composite_attributes = {test_bool = false, test_int = 2 : i64, test_string = "test"}, decomposition = @add_n.impl} : (tensor<i64>) -> tensor<i64>
    %0 = stablehlo.composite "stablehlo.add_n" %arg0 { composite_attributes = { test_int = 2 : i64, test_bool = 0 : i1, test_string = "test"}, decomposition = @add_n.impl } : (tensor<i64>) -> tensor<i64>
    return %0 : tensor<i64>
  }

      }
    }
    node_def {
      name: "add_0"
      op: "AddV2"
      input: "add_const"
      input: "add/y:output:0"
      attr {
        key: "T"
        value {
          type: DT_INT32
        }
      }
      experimental_debug_info {
        original_node_names: "add"
      }
    }
    ret {
      key: "add"
      value: "add_0:z:0"
    }
    arg_attr {
      key: 0