```mlir
  %2 = "tf.A"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>
  %3 = "tf.B"(%2) {device = "tpu0"} : (tensor<?xi32>) -> tensor<?xi32>
  %4 = "tf.C"(%2, %3) {device = "tpu0"} : (tensor<?xi32>, tensor<?xi32>) -> tensor<?xi32>
  %5 = "tf.D"(%4) : (tensor<?xi32>) -> tensor<?xi32>
```

After the pass, we will have:

```mlir
  %0 = "tf.A"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>
  %1 = "tf_device.launch"() ( {

		t.Skipf("no assembly implementation of GCM")
	}

	// generate permutations
	type pair struct{ align, length int }
	lengths := []int{0, 156, 8192, 8193, 8208}
	keySizes := []int{16, 24, 32}
	alignments := []int{0, 1, 2, 3}
	if testing.Short() {
		keySizes = []int{16}
		alignments = []int{1}
	}
	perms := make([]pair, 0)
	for _, l := range lengths {
		for _, a := range alignments {

	duplicateResourceErr           = "the same resource cannot be specified multiple times"
)

var (
	// See https://golang.org/pkg/crypto/aes/#NewCipher for details on supported key sizes for AES.
	aesKeySizes = []int{16, 24, 32}

	// See https://godoc.org/golang.org/x/crypto/nacl/secretbox#Open for details on the supported key sizes for Secretbox.
	secretBoxKeySizes = []int{32}
)

  // expected-remark@above {{Sinks: {}}}
}

// -----

func.func @add(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) -> tensor<1xf32> {
  // expected-remark@above {{ID: 2}}
  %sum = "tf.Add"(%arg0, %arg1) : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
  // expected-remark@above {{ID: 0}}
  func.return %sum : tensor<1xf32>
  // expected-remark@above {{ID: 1}}
  // expected-remark@above {{Sinks: {}}}
}

		// bits after the first one bit.
		top := uint(x[i])
		top |= top >> 1
		top |= top >> 2
		top |= top >> 4
		top |= top >> 8
		top |= top >> 16
		top |= top >> 16 >> 16 // ">> 32" doesn't compile on 32-bit architectures
		return i*_W + bits.Len(top)
	}
	return 0
}

// trailingZeroBits returns the number of consecutive least significant zero
// bits of x.

DATA ·IEEEConst+1544(SB)/8,$0x0000000090db8c44

	/* x^161856 mod p(x), x^161792 mod p(x) */
DATA ·IEEEConst+1552(SB)/8,$0x0000000067a2c786
DATA ·IEEEConst+1560(SB)/8,$0x000000010010a4ce

	/* x^160832 mod p(x), x^160768 mod p(x) */
DATA ·IEEEConst+1568(SB)/8,$0x0000000048b9496c
DATA ·IEEEConst+1576(SB)/8,$0x00000001c8f4c72c

	/* x^159808 mod p(x), x^159744 mod p(x) */
DATA ·IEEEConst+1584(SB)/8,$0x000000015a422de6

  // The first Operand is assumed to be a TensorType around a variant with a
  // single subtype (e.g. tensor<!tf_type.variant<tensor<2xi32>>>). We will
  // copy this type to the first result, and copy the singular variant subtype
  // to the second result (tensor<2xi32>).
  DCOMMENT_OP(op, "Inferring shape for TensorListPopBackOp.");

  auto src_list_handle_t =

from tensorflow.compiler.mlir.tensorflow.gen_mlir_passthrough_op import mlir_passthrough_op

mlir_module = '''python
func @main(%arg0 : tensor<10xf32>, %arg1 : tensor<10xf32>) -> tensor<10x10xf32> {
   %add = "magic.op"(%arg0, %arg1) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10x10xf32>
   return %ret : tensor<10x10xf32>
}
'''

@tf.function
def foo(x, y):

		if z.Op != OpPPC64MOVHZreg {
			break
		}
		x := z.Args[0]
		if !(z.Uses == 1 && c < 16) {
			break
		}
		v.reset(OpPPC64CLRLSLWI)
		v.AuxInt = int32ToAuxInt(newPPC64ShiftAuxInt(c, 16, 31, 32))
		v.AddArg(x)
		return true
	}
	// match: (SLWconst [c] z:(ANDconst [d] x))
	// cond: z.Uses == 1 && isPPC64ValidShiftMask(d) && c<=(32-getPPC64ShiftMaskLength(d))