arm64SpecialOperand = map[string]arm64.SpecialOperand{}
		for opd := arm64.SPOP_BEGIN; opd < arm64.SPOP_END; opd++ {
			arm64SpecialOperand[opd.String()] = opd
		}

		// Handle some special cases.
		specialMapping := map[string]arm64.SpecialOperand{
			// The internal representation of CS(CC) and HS(LO) are the same.
			"CS": arm64.SPOP_HS,
			"CC": arm64.SPOP_LO,
		}
		for s, opd := range specialMapping {
			arm64SpecialOperand[s] = opd

      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>
  }
  func.return %0 : tensor<i32>
}

      %5 = "tf.opC"(%4) : (tensor<i1>) -> tensor<i1>
      tf_executor.yield %3, %5, %4 : tensor<i1>, tensor<i1>, tensor<i1>
    }
    %6:3 = tf_executor.island {
      %7 = "tf.opD"(%arg0) : (tensor<i1>) -> tensor<i1>
      %8 = "tf.opE"(%7) : (tensor<i1>) -> tensor<i1>
      tf_executor.yield %8, %7 : tensor<i1>, tensor<i1>
    }
    tf_executor.fetch %1#1, %1#0, %6#0 : tensor<i1>, tensor<i1>, tensor<i1>

  // 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