00000010  f9 de f8 f0 68 a2 6d f2  e6 2a df de f1 7c c4 44  |....h.m..*...|.D|
00000020  7b 22 14 03 29 2a f2 1b  6c a2 0e 20 e4 bc 0e 83  |{"..)*..l.. ....|
00000030  35 d7 c1 4c ea 8f ba 77  32 ae c9 44 b0 51 16 05  |5..L...w2..D.Q..|
00000040  06 03 6b c9 23 06 42 26  80 25 6d 67 00 04 13 03  |..k.#.B&.%mg....|
00000050  00 ff 01 00 00 91 00 0b  00 04 03 00 01 02 00 0a  |................|

	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 {

	w2, err := cacher.Watch(context.TODO(), "pods/ns", storage.ListOptions{ResourceVersion: "999", Predicate: storage.Everything})
	if err != nil {
		t.Fatalf("Failed to create watch: %v", err)
	}
	defer w2.Stop()

	shouldContinue := true
	currentRV := uint64(0)
	for shouldContinue {
		select {
		case event, ok := <-w2.ResultChan():
			if !ok {
				shouldContinue = false

>>> Flow 1 (client to server)
00000000  16 03 01 00 6d 01 00 00  69 03 03 6c 16 54 e2 20  |....m...i..l.T. |
00000010  da ff dc 37 ae f5 5d e2  77 32 fe 7b 7a cc 31 1f  |...7..].w2.{z.1.|
00000020  f5 49 6e 75 89 27 b0 aa  67 e7 99 00 00 04 00 0a  |.Inu.'..g.......|
00000030  00 ff 01 00 00 3c 00 16  00 00 00 17 00 00 00 0d  |.....<..........|
00000040  00 30 00 2e 04 03 05 03  06 03 08 07 08 08 08 09  |.0..............|

// 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>) -> ()
      }, {

	}

	// Wrap a writer and then Reset to that writer.
	w.Reset(&buf4)
	w2 := NewWriter(w)
	w2.WriteString("recur")
	w2.Flush()
	if buf4.String() != "recur" {
		t.Errorf("buf4 = %q, want %q", buf4.String(), "recur")
	}
	w.Reset(&buf5)
	w2.Reset(w)
	w2.WriteString("recur2")
	w2.Flush()
	if buf5.String() != "recur2" {
		t.Errorf("buf5 = %q, want %q", buf5.String(), "recur2")
	}

				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: