// tf_executor.island {_parallel_execution_ids=r0:0,p0:1} wraps "tf.OpD"
// tf_executor.island {_parallel_execution_ids=r0:1} wraps "tf.OpB"
// tf_executor.island {_parallel_execution_ids=r0:1,p0:0} wraps "tf.OpC"
// tf_executor.island {_parallel_execution_ids=r0:1,p0:1} wraps "tf.OpD"
//
// "tf.OpA" will not have `_parallel_execution_ids` attr,

  "tf.TPUReplicateMetadata"() {_xla_compile_device_type = "TPU", _replication_info = "replicate", device = "/device:TPU:0", num_replicas = 1, topology = "topology"} : () -> ()
  %3 = "tf.opD"(%2) {_xla_compile_device_type = "TPU", _replication_info = "replicate", is_stateless = true} : (tensor<i1>) -> tensor<i1>
  %4 = "tf.opE"() {is_stateless = true} : () -> tensor<i1>

func.func @replicate_with_multiple_operands() {
  %0 = "tf.opA"() : () -> tensor<*xi1>
  %1 = "tf.opB"() : () -> tensor<*xi1>
  %2 = "tf.opC"() : () -> tensor<*xi1>
  %3 = "tf.opD"() : () -> tensor<*xi32>
  %4 = "tf.opE"() : () -> tensor<*xi32>
  %5 = "tf.opF"() : () -> tensor<*xi32>
  %6 = "tf.opG"() : () -> tensor<*xf32>
  %7 = "tf.opH"() : () -> tensor<*xf32>
  %8 = "tf.opI"() : () -> tensor<*xf32>

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

		}
		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 {