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

      %3 = "tf.opB"(%2, %arg0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
      tf_executor.yield %3 : tensor<i32>
    }
    %4:2 = tf_executor.island {
      %5 = "tf.opC"(%1#0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
      %6 = "tf.opD"(%5, %arg0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
      tf_executor.yield %6 : tensor<i32>
    }
    tf_executor.fetch %4#0 : tensor<i32>

      %b = "tf.opB"(%1, %2) : (tensor<?xi32>, tensor<*xi32>) -> tensor<*xf32>
      tf_device.return %b : tensor<*xf32>
    }) {device = "b"} : () -> tensor<*xf32>
    %4 = "tf_device.launch"() ({
      %c = "tf.opC"(%ri, %3) : (tensor<*xf32>, tensor<*xf32>) -> tensor<?xi1>
      tf_device.return %c : tensor<?xi1>
    }) {device = "c"} : () -> tensor<?xi1>

  // CHECK: "tf.OpA"(%[[COMPILE_LAUNCH]]#1
  // CHECK: "tf.OpC"
  // CHECK: "tf.OpB"(%[[COMPILE_LAUNCH]]#1
  // CHECK: "tf.OpD"
  "tf_device.launch"() ({
    %cst_0 = "tf.Const"() {value = dense<""> : tensor<1x!tf_type.string>} : () -> tensor<1x!tf_type.string>
    %1= "tf.OpA"(%cst_0) { mini_batch_splits = ""} : (tensor<1x!tf_type.string>) -> (tensor<2xi32>)
    %2 = "tf.OpC"(%1) {} : (tensor<2xi32>) -> (tensor<2xi32>)

    %0 = "tf.opA"() : () -> (tensor<*xi1>)
    %1 = "tf.opB"() : () -> (tensor<*xi32>)
    tf_device.return %0, %1 : tensor<*xi1>, tensor<*xi32>
  },
  {
    %2 = "tf.opC"() : () -> (tensor<*xi1>)
    tf_device.return
  }) {} : () -> (tensor<*xi1>, tensor<*xi32>, tensor<*xi32>)
  func.return
}

// -----

//  }
//  %3:2 = tf_executor.island(%0) {
//    %4 = "tf_device.parallel_execute"() ({
//      %5 = "tf.opB"() : () -> tensor<i1>
//      tf_device.return %5 : tensor<i1>
//    }, {
//      %5 = "tf.opC"(%1#0) : (tensor<i1>) -> tensor<i32>
//      tf_device.return
//    }) {} : () -> (tensor<i1>)
//    tf_executor.yield %4 : tensor<i1>
//  }
//  tf_executor.fetch %3#0 : tensor<i1>
//
// gets lowered to:
//

    ```mlir
      %island:5 = tf_executor.island {
        %a = "tf.opA"() : () -> tensor<i1>
        %launch:2 = "tf_device.launch"() ( {
          %b = "tf.opB"() : () -> tensor<i32>
          %c = "tf.opC"() : () -> tensor<f32>
          tf_device.return %c, %b : tensor<f32>, tensor<i32>
        }) {device = "CPU:0"} : () -> (tensor<f32>, tensor<i32>)
        %d = "tf.opD"() : () -> tensor<i1>

    // CHECK:   "tf.OpC"(%[[VAL_0]]) : (tensor<i64>) -> ()
    // CHECK:   "tf.OpD"() : () -> ()
    // CHECK:   tf_device.return
    // CHECK: }) : () -> ()
    %island2 = tf_executor.island {
      "tf_device.launch"() <{device = "/job:worker/replica:0/task:0/device:CPU:0"}> ({
        "tf.OpC"(%island1#0) : (tensor<i64>) -> ()
        "tf.OpD"() : () -> ()

are replicated each from the regions terminator.

For example:
```
%0 = "tf.opA"() : () -> tensor<i32>
%1 = "tf.opB"() : () -> tensor<i32>
%2 = "tf.opC"() : () -> tensor<f32>
%3 = "tf.opD"() : () -> tensor<f32>
%4 = "tf.opE"() : () -> tensor<!tf_type.resource>
%5 = "tf.opF"() : () -> tensor<!tf_type.resource>
%6 = "tf.opG"() : () -> tensor<!tf_type.string>

  // We don’t mention the control token in the return type here, it is implicit.
  %0, %ctl0 = tf_executor.opA %feed#0, %feed#1 : tensor<*xf32>
  %1, %ctl1 = tf_executor.opB : tensor<*xf32>
  %2, %ctl2 = tf_executor.opC %1, %ctl0 : tensor<*xf32>
  %3, %ctl3 = tf_executor.opD %2 : tensor<*xf32>
  tf_executor.fetch %3 : tensor<*xf32>
} // end of the “tf_executor.graph" operation/region
```

### ‘tf_executor.island’ Operation