return func(yield func(int, E) bool) {
		for i, v := range s {
			if !yield(i, v) {
				return
			}
		}
	}
}

// Backward returns an iterator over index-value pairs in the slice,
// traversing it backward. The indexes range from len(s)-1 down to 0.
func Backward[Slice ~[]E, E any](s Slice) iter.Seq2[int, E] {
	return func(yield func(int, E) bool) {
		for i := len(s) - 1; i >= 0; i-- {

    // CHECK-SAME:       _xla_compile_device_type = "TPU"
    // CHECK-SAME:       device = "/job:localhost/replica:0/task:0/device:TPU:1"
    // CHECK:            "tf.Yield"(%[[FUNC_CALL]])
    // CHECK:            "tf.Yield"(%[[ARG_5]])
    // CHECK:          "tf.Yield"(%[[HAS_VALUE]], %[[IF]])
    %1 = "tf.ReduceDataset"(%arg0, %arg1) {
      Targuments = [],
      Tstate = [i64], device = "/job:localhost/replica:0/task:0/device:TPU:1",

    %add = "tf.AddV2"(%call, %call) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
    "tf.Yield"(%call, %add) : (tensor<4xf32>, tensor<4xf32>) -> ()
  },  {
    %call_0 = func.call @test_if_else1(%arg1) : (tensor<4xf32>) -> tensor<4xf32>
    "tf.Yield"(%call_0, %call_0) : (tensor<4xf32>, tensor<4xf32>) -> ()
  }) {is_stateless = false} : (tensor<i1>) -> (tensor<*xf32>, tensor<4xf32>)

from typing_extensions import Annotated


async def dependency_a():
    dep_a = generate_dep_a()
    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a: Annotated[DepA, Depends(dependency_a)]):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)


async def dependency_c(dep_b: Annotated[DepB, Depends(dependency_b)]):

	// in the middle of walking a node. Previously, incorrect handling of the
	// boolean returned by the yield function resulted in the iterator calling
	// yield for sibling nodes even after yield had returned false. With that
	// bug, this test failed with a runtime panic.
	src := "package p\ntype T struct {\n\tF int `json:\"f\"` // a field\n}\n"

	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "", src, 0)
	if err != nil {

      // CHECK-SAME: device = "/device:test_device:0"
      %3 = "tf_device.launch_func"(%2) {device = "/device:test_device:0", func = @_func} : (tensor<?xf32>) -> tensor<?xf32>

      // CHECK: tf_executor.yield %[[CALL_OUTPUT]]
      tf_executor.yield %3 : tensor<?xf32>
    }
    tf_executor.fetch %1#0 : tensor<?xf32>
  }
  func.return %0 : tensor<?xf32>
}

func.func @_func(%arg0: tensor<?xf32>) -> tensor<?xf32> {

  ^bb0(%arg2: tensor<i32>, %arg3: tensor<i32>):
    %1 = "tf.OpA"() {is_stateless = true} : () -> tensor<i1>
    "tf.Yield"(%1) : (tensor<i1>) -> ()
  }, {
  ^bb0(%arg2: tensor<i32>, %arg3: tensor<i32>):
    %1 = "tf.GlobalIterId"() : () -> tensor<i64>
    "tf.Yield"(%arg2, %arg3) : (tensor<i32>, tensor<i32>) -> ()

  OpBuilder builder(&island.GetBody(), island.GetBody().begin());
  tf_executor::YieldOp yield = island.GetYield();
  if (yield.getNumOperands() == 0) {
    builder.create<TF::NoOp>(island.getLoc(), TypeRange{}, ValueRange{});
  } else if (yield.getNumOperands() == 1) {
    Value operand = yield.getOperand(0);
    auto identity = builder.create<TF::IdentityOp>(island.getLoc(),

// tf_executor.island, tf.Identity, and tf_executor.yield).

// CHECK-LABEL: "func.func"
// CHECK: sym_name = "island_one_op_all_locs_same"
// CHECK:    "tf_executor.graph"() ({
// CHECK-NEXT:      "tf_executor.island"() ({
// CHECK-NEXT:        "tf.Identity"(%{{.*}}) : (tensor<f32>) -> tensor<f32> loc("identity@some_function")
// CHECK-NEXT:        "tf_executor.yield"(%{{.*}}) : (tensor<f32>) -> () loc("identity@some_function")

        %5 = "tf.D"(%4) {device = "gpu0"} : (tensor<?xi32>) -> tensor<?xi32>
        // CHECK: tf_device.return %[[D_OUTPUT]]

        // CHECK: tf_executor.yield %[[GPU0_OUTPUT]]
        tf_executor.yield %5 : tensor<?xi32>
      }
      tf_executor.fetch %1#0 : tensor<?xi32>
    }
    func.return %0 : tensor<?xi32>
  }
}

// -----