"tf.Yield"() : () -> ()
        }, {
        "tf.Yield"() : () -> ()
       }) {is_stateless = true} : (tensor<i1>) -> ()
       "tf.Yield"(%1) : (tensor<i1>) -> ()
    }, {
    ^bb0(%arg1: tensor<i32>, %arg2: tensor<?xf32>):
      "tf.IfRegion"(%0) ({
        %2 = "tf.B"() : () -> (tensor<f32>)
        "tf.Yield"() : () -> ()
        }, {
        "tf.Yield"() : () -> ()

       // CHECK: "tf.Yield"(%[[CONST]])
       %constant = "tf.Const"() {value = dense<0.0> : tensor<4xf32>} : () -> tensor<4xf32>
       "tf.AssignVariableOp"(%0, %constant) : (tensor<*x!tf_type.resource<tensor<4xf32>>>, tensor<4xf32>) -> ()
       "tf.Yield"() : () -> ()
      }, {
       // CHECK: "tf.Yield"(%[[READ]])
       "tf.Yield"() : () -> ()

        rng.uniform(low=0.0, high=1.0, size=static_input_shape).astype(
            np.float32
        )
    )

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for _ in range(100):
        yield {
            'input_tensor': rng.uniform(
                low=0.0, high=1.0, size=static_input_shape
            ).astype(np.float32)
        }

    dataset_path = self.create_tempfile('tfrecord').full_path

  %graph = tf_executor.graph {
    %island, %ctrl = tf_executor.island {
      %pred = "tf.SomeOp"(%arg2) : (tensor<f32>) -> tensor<i32>
      tf_executor.yield %pred : tensor<i32>
    }
    tf_executor.fetch %island : tensor<i32>
  }
  func.return %graph : tensor<i32>
}

// CHECK-LABEL:   func @simple_independent_chains

For example:

```mlir
"tf.IfRegion"(%0) ( {
  %2 = "tf.A"() : () -> (tensor<f32>)
  "tf.Yield"() : () -> ()
  }, {
  "tf.Yield"() : () -> ()
 }) { is_stateless = true } : (tensor<i1>) -> ()
"tf.IfRegion"(%0) ( {
  %2 = "tf.B"() : () -> (tensor<f32>)
  "tf.Yield"() : () -> ()
  }, {
  "tf.Yield"() : () -> ()
  }) { is_stateless = true } : (tensor<i1>) -> ()
```

Would be transformed to:

  ^bb0(%barg0: tensor<f32>, %barg1: tensor<i32>):
    // CHECK: %[[PRED:.*]] = "tf._SomeOp"(%[[BARG1]])
    // CHECK: "tf.Yield"(%[[PRED]])
    %pred = "tf._SomeOp"(%barg1) : (tensor<i32>) -> tensor<i1>
    "tf.Yield" (%pred) : (tensor<i1>) -> ()
  }, {
  // CHECK: ^bb0(%[[BARG0:.*]]: tensor<f32>, %[[BARG1:.*]]: tensor<i32>):
  ^bb0(%barg0: tensor<f32>, %barg1: tensor<i32>):

module {
func.func @simpleWhile(%arg0: tensor<i32>) -> tensor<i32> {
  %0 = "tfl.while"(%arg0) ({
  ^bb0(%block: tensor<i32>):
    "tfl.yield"(%block) : (tensor<i32>) -> ()
  },{
  ^bb0(%block: tensor<i32>):
    "tfl.yield"(%block) : (tensor<i32>) -> ()
  }) {tac.device = "CPU", fused_activation_function = "RELU6", tac.inference_type = "FLOAT"} : (tensor<i32>) -> tensor<i32>
  func.return %0 : tensor<i32>
}

  regions accept the current value of the iteration variables as inputs.

  The condition region yields a tensor<i1> which, if false, will exit the loop.
  It can also, optionally and additionally, yield the iteration variables, which
  must be unchanged.

  The body region always has to yield the (possibly updated) iteration variables.

  The iteration variables are initialized to the Op input, and the results of the

		c := field.Name[0]
		if 'a' <= c && c <= 'z' || c == '_' {
			panic("reflect.StructOf: field \"" + field.Name + "\" is unexported but missing PkgPath")
		}
	}

	resolveReflectType(field.Type.common()) // install in runtime
	f := structField{
		Name:   newName(field.Name, string(field.Tag), field.IsExported(), field.Anonymous),
		Typ:    field.Type.common(),
		Offset: 0,
	}
	return f, field.PkgPath
}

  def visit_block(self, block):
    return [self.visit(item) for item in block]

  def visit_Pass(self, node):
    if self.symbol_table.in_scf_scope():
      self._emit_with_loc('\nscf.yield', node)
    else:
      self._emit_with_loc('\ntfr.return', node)

  def visit_Attribute(self, node):
    node_type = self._get_inferred_type(node, None)
    if isinstance(node.value, ast.Name):