"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"() : () -> ()

			break
		}
		return func(yield func(Value) bool) {
			v = v.Elem()
			for i := range v.Len() {
				if !yield(ValueOf(i)) {
					return
				}
			}
		}
	case Array, Slice:
		return func(yield func(Value) bool) {
			for i := range v.Len() {
				if !yield(ValueOf(i)) {
					return
				}
			}
		}
	case String:
		return func(yield func(Value) bool) {
			for i := range v.String() {

      tf_executor.yield
    }
    %island2 = tf_executor.island(%island1) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    %island3 = tf_executor.island(%island2) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    %island4:2 = tf_executor.island(%island3) {

  %0:2 = tf_executor.graph {
    %1:2 = tf_executor.island {
      tf_executor.yield %arg1 : tensor<i1>
    }
    %2:2 = tf_executor.island {
      tf_executor.yield %arg0 : tensor<i1>
    }
    %3:2 = tf_executor.island {
      tf_executor.yield %1#0 : tensor<i1>
    }
    %4:2 = tf_executor.island {
      tf_executor.yield %2#0 : tensor<i1>
    }

  "tfl.if"(%arg0) (
  {
    // then
    ^bb0:
     "tfl.yield"() : () -> ()
  },
  {
    // else
   ^bb0:
    "tfl.yield"() : () -> ()
  }) : (tensor<1xi1>) -> ()
  func.return
}
// CHECK-NEXT: %[[CONTROL:.*]] = tfl.control_node controls "tfl.if"
// CHECK-NEXT: "tfl.yield"() : () -> ()
// CHECK-NEXT: }, {
// CHECK-NEXT: "tfl.yield"() : () -> ()
// CHECK-NEXT: }) : (tensor<1xi1>) -> ()
// CHECK-NEXT: return

	"testing"
)

type Seq2[T1, T2 any] func(yield func(T1, T2) bool)

// ofSliceIndex returns a Seq over the elements of s. It is equivalent
// to range s, except that it splits s into two halves and iterates
// in two separate goroutines.  This is racy if yield is racy, and yield
// will be racy if it contains an early exit.
func ofSliceIndex[T any, S ~[]T](s S) Seq2[int, T] {
	return func(yield func(int, T) bool) {
		c := make(chan bool, 2)

  tf_executor.graph {
    %0 = tf_executor.island {
      tf_executor.yield
    }
    %1 = tf_executor.island(%0) {
      %3 = "tf.opA"() : () -> tensor<i1>
      tf_executor.yield
    }
    %2 = tf_executor.island(%0, %1) {
      %4 = "tf.opB"() : () -> tensor<i1>
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

	return nil
}

func iterSimple(yield func(int) bool) {
	for range 3 {
		if !yield(5) {
			return
		}
	}
}

func iterNested(yield func(int) bool) {
	next, stop := iter.Pull(iterSimple)
	for {
		v, ok := next()
		if ok {
			if !yield(v) {
				stop()
			}
		} else {
			return
		}
	}
}

func iterLock(yield func(int) bool) {
	for range 3 {

        %2 = "tf.Abs"(%asin) : (tensor<*xf32>) -> tensor<*xf32>
        "tf.Yield"(%2) : (tensor<*xf32>) -> ()
      }, {
        %2 = "tf.Neg"(%arg1) : (tensor<*xf32>) -> tensor<*xf32>
        "tf.Yield"(%2) : (tensor<*xf32>) -> ()
      }) { is_stateless = true } :  (tensor<i1>) -> tensor<*xf32>

    "tf.Yield"(%1) : (tensor<*xf32>) -> ()
    }, {
    // Outer Else

    %1 = "tf.OpA"() {is_stateless = true} : () -> tensor<i1>
    "tf.Yield"(%1) : (tensor<i1>) -> ()
  }, {
  ^bb0(%arg2: tensor<*xf32>, %arg3: tensor<*xf32>):
    %1 = "tf.OpB"(%arg2) {is_stateless = true} : (tensor<*xf32>) -> tensor<*xf32>
    %2 = "tf.OpC"(%arg3) {is_stateless = true} : (tensor<*xf32>) -> tensor<*xf32>
    "tf.Yield"(%1, %2) : (tensor<*xf32>, tensor<*xf32>) -> ()