switch kind {
	case 8:
		if arch.ptrSize == 4 {
			w1, w2 := "lo", "hi"
			if arch.bigEndian {
				w1, w2 = w2, w1
			}
			cc = append(cc, newComponent(suffix+"_"+w1, 4, "half "+s, off, 4, suffix))
			cc = append(cc, newComponent(suffix+"_"+w2, 4, "half "+s, off+4, 4, suffix))
		}

	case asmEmptyInterface:

	VMOVH	(R24), W12     // 7800c321
	VMOVH	110(R19), W8   // 78379a21
	VMOVH	-70(R12), W3   // 7bdd60e1
	VMOVW	(R3), W31      // 78001fe2
	VMOVW	64(R20), W16   // 7810a422
	VMOVW	-104(R17), W24 // 7be68e22
	VMOVD	(R3), W2       // 780018a3
	VMOVD	128(R23), W19  // 7810bce3
	VMOVD	-256(R31), W0  // 7be0f823

	VMOVB	W8, (R0)       // 78000224
	VMOVB	W0, 511(R3)    // 79ff1824
	VMOVB	W21, -512(R12) // 7a006564

	const (
		s    = 32
		mask = 1<<s - 1
	)
	u0 := u & mask
	u1 := u >> s
	v0 := v & mask
	v1 := v >> s
	w0 := u0 * v0
	t := u1*v0 + w0>>s
	w1 := t & mask
	w2 := t >> s
	w1 += u0 * v1
	return u * v, u1*v1 + w2 + w1>>s
}

// 128/64 -> 64 quotient, 64 remainder.
// adapted from hacker's delight
func divlu(u1, u0, v uint64) (q, r uint64) {
	const b = 1 << 32

	if u1 >= v {

// CHECK-DAG: %[[w1_dq:.*]] = "tfl.dequantize"(%[[w1_q]])
// Weight with adjusted scales
// CHECK-DAG: %[[w2:.*]] = arith.constant dense<{{\[\[\[\[}}-1.000000e+00, 1.000000e+00]]]
// CHECK-DAG: %[[w2_q:.*]] = "tfl.quantize"(%[[w2]]){{.*}}{0.0078740157480314959,0.19998891099675145,1.9998891454946508}
// CHECK-DAG: %[[w2_dq:.*]] = "tfl.dequantize"(%[[w2_q]])
// Bias with adjusted scales

    "tf_device.cluster"() ({
      %a = "tf.A"() {_xla_outside_compilation = "cluster1"} : () -> tensor<i32>
      %b = "tf.B"(%a) {_xla_outside_compilation = "cluster1"} : (tensor<i32>) -> tensor<f32>
      %w1, %w2 = "tf.WhileRegion"(%a, %b) ({
      ^bb0(%arg1: tensor<i32>, %arg2: tensor<f32>):
        %7 = "tf.H"(%arg1) :  (tensor<i32>) -> tensor<i1>
        "tf.Yield"(%7) : (tensor<i1>) -> ()
      }, {

				t.Fatalf("Write failed, n: %d, err: %v", n, err)
			}
		}
		checkContent(name, f)

		// Copy -> Write
		// Copy file f to file f2
		name = "Copy"
		w2, f2 := makeOffsetWriter(name)
		defer f2.Close()
		Copy(w2, f)
		checkContent(name, f2)
	})

	// Copy -> WriteTo -> Write
	// Note: strings.Reader implements the io.WriterTo interface.
	name = "Write_Of_Copy_WriteTo"

	const mask32 = 1<<32 - 1
	x0 := x & mask32
	x1 := x >> 32
	y0 := y & mask32
	y1 := y >> 32
	w0 := x0 * y0
	t := x1*y0 + w0>>32
	w1 := t & mask32
	w2 := t >> 32
	w1 += x0 * y1
	hi = x1*y1 + w2 + w1>>32
	lo = x * y
	return
}

// --- Full-width divide ---

// Div returns the quotient and remainder of (hi, lo) divided by y:

//      Let z = 1/x, then we approximation
//              f(z) = lgamma(x) - (x-0.5)(log(x)-1)
//      by
//                                  3       5             11
//              w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
//      where
//              |w - f(z)| < 2**-58.74
//
//   4. For negative x, since (G is gamma function)
//              -x*G(-x)*G(x) = pi/sin(pi*x),
//      we have

00000230  17 aa 28 56 20 ee 82 fd  de d1 55 b8 e9 27 ae 3d  |..(V .....U..'.=|
00000240  e1 44 d6 0b b9 7a 25 77  b0 f1 be 64 ae cc 0d 44  |.D...z%w...d...D|
00000250  af 57 32 9f cf bc c0 07  00 0b 19 97 08 0a d5 50  |.W2............P|
00000260  20 0e ef d5 1e 2e 68 82  ae 2d 84 47 3d 9b 5b 24  | .....h..-.G=.[$|
00000270  55 95 b2 93 e0 60 a2 cd  e5 72 69 b3 e2 de da 70  |U....`...ri....p|

	}
}

var loadSymData = [...]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}

func testLoadSymCombine(t *testing.T) {
	w2 := uint16(0x0201)
	g2 := uint16(loadSymData[0]) | uint16(loadSymData[1])<<8
	if g2 != w2 {
		t.Errorf("testLoadSymCombine failed, wanted %d got %d", w2, g2)
	}
	w4 := uint32(0x04030201)
	g4 := uint32(loadSymData[0]) | uint32(loadSymData[1])<<8 |