}
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)]>;

	{"CallStmt", `@go f()`},

	{"ReturnStmt", `@return`},
	{"ReturnStmt", `@return x`},
	{"ReturnStmt", `@return a, b, a + b*f(1, 2, 3)`},

	{"IfStmt", `@if cond {}`},
	{"IfStmt", `@if cond { f() } else {}`},
	{"IfStmt", `@if cond { f() } else { g(); h() }`},
	{"ForStmt", `@for {}`},
	{"ForStmt", `@for { f() }`},
	{"SwitchStmt", `@switch {}`},
	{"SwitchStmt", `@switch { default: }`},

//	}
//	LTYPE1 cond imsr ',' reg
//	{
//		outcode($1, $2, &$3, 0, &$5);
//	}
	ADD	$1, R2
	ADD	R1<<R2, R3
	ADD	R1>>R2, R3
	ADD	R1@>R2, R3
	ADD	R1->R2, R3
	ADD	R1, R2

//
// MVN
//
//	LTYPE2 cond imsr ',' reg
//	{
//		outcode($1, $2, &$3, 0, &$5);
//	}
	CLZ	R1, R2

//
// MOVW
//
//	LTYPE3 cond gen ',' gen
//	{
//		outcode($1, $2, &$3, 0, &$5);
//	}

def : Pat<(MHLO_SelectOp $cond, $t,
                                (MHLO_BroadcastInDimOp:$output
                                  $bcast_operand,
                                  $broadcast_dimensions)),
          (TF_SelectV2Op $cond, $t, $bcast_operand),
          [(IsTFStyleBroadcast $broadcast_dimensions, $output)]>;
def : Pat<(MHLO_SelectOp $cond, (MHLO_BroadcastInDimOp:$output

			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)

        ArrayRef<Value>{operand, caller->getResult(updated_index)});
  }
}

// Lifts loads/stores from while loop's body and cond functions.
LogicalResult HandleWhileLoop(TF::WhileOp while_op, func::FuncOp body,
                              func::FuncOp cond) {
  auto return_op = body.front().getTerminator();
  llvm::SmallDenseMap<int64_t, ResourceArgUseInfo> body_use_info;

// CHECK-NEXT:   %[[RESULT_0:.*]] = "tf.While"(%[[ARG_0]])
// CHECK-SAME:   body = @while_body
// CHECK-SAME:   cond = @while_cond
// CHECK-SAME:   device = "/job:localhost/replica:0/task:0/device:CPU:0"
// CHECK-NEXT:   %[[RESULT_1:.*]] = tf_device.remote_run "/job:worker/replica:0/task:1" @[[MAIN_PARTITION_0:.*]](%[[ARG_1]])

    // expected-error@+1 {{Result #0 is not tied to arg #0 of the body}}
    %1 = "tf.WhileRegion"(%0) ({
      ^bb0(%carg0:tensor<*x!tf_type.resource<tensor<f32>>>):
        %cond = "tf.SomeOp"() : () -> tensor<i1>
        "tf.Yield"(%cond) : (tensor<i1>) -> ()
      }, {
      ^bb0(%carg0:tensor<*x!tf_type.resource<tensor<f32>>>):

# CHECK: func private @[[else]](
# CHECK: func private @[[then]](


def Test():

  zero = tf.constant(0)
  one = tf.constant(1)
  x = tf.placeholder(tf.int32, shape=(), name='input')
  result = tf.cond(x > zero, lambda: tf.square(x), lambda: tf.add(x, one))

  tensor_info_result = tf.compat.v1.saved_model.utils.build_tensor_info(result)

  signature_def = tf.saved_model.signature_def_utils.build_signature_def(

	if err != nil && !apierrors.IsNotFound(err) {
		return errors.Wrapf(err, "cannot get Node %q", nodeName)
	}
	for _, cond := range node.Status.Conditions {
		if cond.Type == v1.NodeReady && cond.Status == v1.ConditionTrue {
			return errors.Errorf("a Node with name %q and status %q already exists in the cluster. "+