// CHECK: %[[COMPILE_LAUNCH:[0-9]*]]:2 = "tf_device.launch"
  // CHECK: TPUCompileMlir
  // 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>)

          %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>
        tf_executor.yield %a, %launch#0, %launch#1, %d :
                          tensor<i1>, tensor<f32>, tensor<i32>, tensor<i1>
      }
    ```

    Will be transformed into:

// CHECK-LABEL: func @variant_input_nested
func.func @variant_input_nested(%arg0 : tensor<*x!tf_type.resource>) {
  // CHECK:        "tf.EmptyTensorList"
  // CHECK-SAME:   _xla_outside_compilation
  // CHECK:        "tf.opD"
  // CHECK-NOT:    _xla_outside_compilation
  // CHECK:        "tf.Yield"
  "tf_device.cluster"() ({
    %0 = "tf.Const"() {value = dense<true> : tensor<i1>} : () -> 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"() : () -> ()
        tf_device.return
      }) : () -> ()
      tf_executor.yield

	if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) {
		switch p.arch.Family {
		case sys.ARM64:
			// arm64 special operands.
			if opd := arch.GetARM64SpecialOperand(name); opd != arm64.SPOP_END {
				a.Type = obj.TYPE_SPECIAL
				a.Offset = int64(opd)
				break
			}
			fallthrough
		default:
			// We have a symbol. Parse $sym±offset(symkind)
			p.symbolReference(a, p.qualifySymbol(name), prefix)

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>
%7 = "tf.opH"() : () -> tensor<!tf_type.string>

  %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

		}
		if isaddcon2(cf) {
			return C_AACON2
		}

		return C_LACON

	case obj.TYPE_BRANCH:
		return C_SBRA

	case obj.TYPE_SPECIAL:
		opd := SpecialOperand(a.Offset)
		if SPOP_EQ <= opd && opd <= SPOP_NV {
			return C_COND
		}
		return C_SPOP
	}
	return C_GOK
}

func (c *ctxt7) oplook(p *obj.Prog) *Optab {
	a1 := int(p.Optab)
	if a1 != 0 {

          ^bb0(%arg2, %arg3):
            %1 = "tf.ReadVariableOp"(%var)
            %2 = "tf.OpB"(%1) {is_stateless = true}
            %3 = "tf.OpC"(%arg2, %2) {is_stateless = true}
            %4 = "tf.OpD"(%arg3, %2) {is_stateless = true}
            "tf.Yield"(%3, %4)
          }) {is_stateless = true}
          return %results#0, %results#1
        }
      ```
      would be transformed to
      ```mlir

       }, {
       ^bb0(%arg2, %arg3):
  %1 = "tf.ReadVariableOp"(%var)
         %2 = "tf.OpB"(%1) {is_stateless = true}
         %3 = "tf.OpC"(%arg2, %2) {is_stateless = true}
         %4 = "tf.OpD"(%arg3, %2) {is_stateless = true}
         "tf.Yield"(%3, %4)
       }) {is_stateless = true}
       return %results#0, %results#1
     }
   ```
   would be transformed to
   ```mlir