tf_device.return
      }
      tf_executor.yield
    }
    %1 = tf_executor.island {
      tf_device.replicate {n = 2 : i32, devices = {CORE_0 = ["/CPU:0", "/GPU:1"]}} {
        "tf_device.launch"() ({
          "tf.opA"() : () -> ()
          tf_device.return
        }) {device = "/TPU:1"} : () -> ()
        tf_device.return
      }
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return

    scf.yield %applied_relu : !tfr.tensor
  } else {
    %is_relu6 = tfr.equal %act, %relu6 -> i1
    %res1 = scf.if %is_relu6 -> !tfr.tensor {
      %applied_relu6 = tfr.call @tf__relu6(%add) : (!tfr.tensor) -> !tfr.tensor
      scf.yield %applied_relu6 : !tfr.tensor
    } else {
      scf.yield %add : !tfr.tensor
    }
    scf.yield %res1 : !tfr.tensor
  }
  tfr.return %res : !tfr.tensor

// CHECK: tf_executor.island
  tf_executor.graph {
    %0 = tf_executor.island {
      tf_executor.yield
    }
    %1:2 = tf_executor.island {
      tf_executor.yield %arg0 : i32
    }
    %2 = tf_executor.island(%0) {
      %a = "tf.opA"(%1#0) : (i32) -> i32
      tf_executor.yield
    }
    tf_executor.fetch %2 : !tf_executor.control
  }
  func.return
}

// -----

// CHECK:     %{{.*}}:2 = "tfl.while"(%{{.*}}, %{{.*}}) ({
// CHECK:     ^bb0(%{{.*}}: tensor<*xi32>, %{{.*}}: tensor<*xf32>):
// CHECK:       "tfl.yield"(%{{.*}}) : (tensor<i1>) -> ()
// CHECK:     },  {
// CHECK:     ^bb0(%{{.*}}: tensor<*xi32>, %{{.*}}: tensor<*xf32>):
// CHECK:       "tfl.yield"(%{{.*}}, %{{.*}}) : (tensor<*xi32>, tensor<*xf32>) -> ()
// CHECK:     }) : (tensor<i32>, tensor<1xf32>) -> (tensor<i32>, tensor<1xf32>)

// CHECK-DAG:         "tfl.yield"(%[[VAL_1]]) : (tensor<i1>) -> ()
// CHECK-DAG:       },  {
// CHECK-DAG:       ^bb0(%[[A2_BODY:.*]]: tensor<i32>):
// CHECK-DAG:         %[[CST_4:.*]] = arith.constant dense<1> : tensor<i32>
// CHECK-DAG:         %[[VAL_2:.*]] = tfl.add %[[A2_BODY]], %[[CST_4]] {fused_activation_function = "NONE"} : tensor<i32>
// CHECK-DAG:         "tfl.yield"(%[[VAL_2]]) : (tensor<i32>) -> ()

    🎲 👆 💪 ▶️ 🆕 ⏬, ⚖️ 👆 🤚 🎡 🏃 ⚫️. 🤷

### 🔆 🔢

🥇 👜 👀, 👈 👥 ⚖ 🔁 🔢 ⏮️ `yield`. 👉 📶 🎏 🔗 ⏮️ `yield`.

```Python hl_lines="14-19"
{!../../../docs_src/events/tutorial003.py!}
```

🥇 🍕 🔢, ⏭ `yield`, 🔜 🛠️ **⏭** 🈸 ▶️.

& 🍕 ⏮️ `yield` 🔜 🛠️ **⏮️** 🈸 ✔️ 🏁.

### 🔁 🔑 👨‍💼

🚥 👆 ✅, 🔢 🎀 ⏮️ `@asynccontextmanager`.

👈 🗜 🔢 🔘 🕳 🤙 "**🔁 🔑 👨‍💼**".

            runPropertyAccessResolution(
                propertyAccess,
                onLocalValue = { yield(AssignmentResolution.ReassignLocalVal(it.localValue)) },
                onProperty = { yield(AssignmentResolution.AssignProperty(PropertyReferenceResolution(it.receiver, it.property))) },
                onExternalObject = { yield(AssignmentResolution.ReassignExternal(it)) }
            )
        }

// CHECK:   call @while_cond_10_frozen0
// CHECK:   yield
// CHECK: ^bb0([[ARGS]]):
// CHECK:   call @while_body
// CHECK:   yield
// CHECK: while_body
// CHECK: while_cond

// INLINE: tfl.while
// INLINE: ^bb0([[ARGS:.*]]):
// INLINE:   tf.Less
// INLINE:   yield
// INLINE: ^bb0([[ARGS]]):
// INLINE:   %cst_2 = arith.constant
// INLINE:   yield
// INLINE-NOT: while_body
// INLINE-NOT: while_cond

// -----

func.func @main() {
  tf_executor.graph {
    %0 = tf_executor.island {
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// CHECK: functions must be of a single Graph with single op Islands: tf_executor.island must perfectly wrap a single op

// -----

func.func @main() {

  %1 = "tf.WhileRegion"(%arg0) ({
  ^cond(%carg0: tensor<*xf32>):
    %2 = "tf.Const"() {value = dense<true> : tensor<i1>} : () -> tensor<i1>
    "tf.Yield"(%2) : (tensor<i1>) -> ()
  }, {
  ^body(%barg0: tensor<*xf32>):
    %2 = "tf.SomeOp"(%barg0) : (tensor<*xf32>) -> tensor<*xf32>
    "tf.Yield"(%2) : (tensor<*xf32>) -> ()
  }) {is_stateless = false, shape_invariant} : (tensor<4xf32>) -> (tensor<*xf32>)