// 3. no call func inside while.
bool ReduceWhileOperands(TFL::WhileOp while_op) {
  std::vector<uint64_t> explicitly_consumed_ids;
  Block &cond = while_op.getCond().front();
  Block &body = while_op.getBody().front();

  auto n = while_op.getNumOperands();
  if (!AllOperationSafe(cond) || !AllOperationSafe(body)) return false;

  // Find all Consumed indices.
  // i is consumed element if result(i) is used outside whileOp or

					if err == nil {
						// Check if gateway has Programmed condition set to true
						for _, cond := range gwc.Status.Conditions {
							if cond.Type == string(gateway.GatewayConditionProgrammed) && string(cond.Status) == "True" {
								programmed = true
								break
							}
						}
					}
					if programmed {
						break
					}

  }];

  let arguments = (ins TFTensorType:$cond,
                       Variadic<TFTensorType>:$arguments,
                       FlatSymbolRefAttr:$body_fn,
                       I32Attr:$invariant_size);

  let results = (outs Variadic<MlrtFutureType>);

  let assemblyFormat = [{
    $body_fn `(` $cond `,` $arguments `)` attr-dict `:` `(` type($cond) `,` type($arguments) `)` `->` `(` type(results) `)`
  }];
}

// observed from a watch.
type watchCache struct {
	sync.RWMutex

	// Condition on which lists are waiting for the fresh enough
	// resource version.
	cond *sync.Cond

	// Maximum size of history window.
	capacity int

	// upper bound of capacity since event cache has a dynamic size.
	upperBoundCapacity int

func.func @testWhile2Result(tensor<*xf32>, tensor<*xf32>) -> (tensor<*xf32>, tensor<*xf32>) {
^bb0(%arg0: tensor<*xf32>, %arg1: tensor<*xf32>):
  %1:2 = "tf.While"(%arg0, %arg1) {
    cond = @testWhile2Cond, body = @testWhile2Body, is_stateless = false
  } : (tensor<*xf32>, tensor<*xf32>) -> (tensor<*xf32>, tensor<*xf32>)

// CHECK:   cf.br ^bb1(%arg0, %arg1 : tensor<*xf32>, tensor<*xf32>)

    Output cond = ops::Const(s.WithOpName("const0"), true, {2});
    Output input = ops::Const(s.WithOpName("const1"), 1, {2});
    NameAttrList true_fn;
    true_fn.set_name("true_fn");
    NameAttrList false_fn;
    false_fn.set_name("false_fn");
    auto if_op = ops::If(s.WithOpName("if"), cond,
                         std::initializer_list<Input>{cond, input}, {DT_INT32},

}

TEST(CallGraphUtilTest, GetCallees) {
  const char *const code = R"mlir(
func.func @entry_func(%arg0: tensor<i32>) -> tensor<i32> attributes {tf_saved_model.initializer_type = ""} {
  %0 = "tf.While"(%arg0) {cond = @while_cond_func, body = @while_body_func, is_stateless = true} : (tensor<i32>) -> (tensor<i32>)
  func.return %0 : tensor<i32>
}

func.func @while_cond_func(%arg0: tensor<i32>) -> tensor<i1> {

}
def LegalizeSelect : Pat<(TF_SelectOp $cond, $x, $y),
                         (TFL_SelectOp $cond, $x, $y)>;
def LegalizeSelectV2SameStaticShape : Pat<(TF_SelectV2Op:$src_op $cond, $x, $y),
    (TFL_SelectOp $cond, $x, $y),
    [(OpHasSameStaticShapes $src_op)]>;
def LegalizeSelectV2NotSameStaticShape : Pat<
  (TF_SelectV2Op:$src_op $cond, $x, $y),
  (TFL_SelectV2Op $cond, $x, $y),
  [(OpHasNotSameStaticShapes $src_op)]>;

			nif := ir.NewIfStmt(base.Pos, nil, nil, nil)
			nif.Cond = ir.NewBinaryExpr(base.Pos, ir.ONE, typecheck.Conv(typecheck.Conv(len64, types.Types[types.TINT]), lenType), len64)
			nif.Body.Append(mkcall("panicunsafeslicelen", nil, &nif.Body))
			appendWalkStmt(init, nif)
		}

		// if len < 0 { panicunsafeslicelen() }
		nif := ir.NewIfStmt(base.Pos, nil, nil, nil)

  auto cond = Const<bool>(scope_, {{false, true, true}});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
  auto y = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
  auto z = SelectV2(scope_, cond, x, y);
  RunTest({x, y}, {shape, shape}, {z}, {shape});
}

TEST_F(NaryGradTest, SelectV2_Broadcast) {
  TensorShape x_shape({2, 3});
  TensorShape y_shape({});