func a1() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
func a2() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
func a3() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
func a4() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
func a5() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }
func a6() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() }

	b3 := namedComponent{b.Field("l3"), "b3"}
	b4 := namedComponent{b.Field("l4"), "b4"}

	// r0 = a0×b0 + 19×(a1×b4 + a2×b3 + a3×b2 + a4×b1)
	r0 := uint128{"r0", GP64(), GP64()}
	mul64(r0, 1, a0, b0)
	addMul64(r0, 19, a1, b4)
	addMul64(r0, 19, a2, b3)
	addMul64(r0, 19, a3, b2)
	addMul64(r0, 19, a4, b1)

	// r1 = a0×b1 + a1×b0 + 19×(a2×b4 + a3×b3 + a4×b2)
	r1 := uint128{"r1", GP64(), GP64()}

	r2 := mul64(a0, b2)
	r2 = addMul64(r2, a1, b1)
	r2 = addMul64(r2, a2, b0)
	r2 = addMul64(r2, a3_19, b4)
	r2 = addMul64(r2, a4_19, b3)

	// r3 = a0×b3 + a1×b2 + a2×b1 + a3×b0 + 19×a4×b4
	r3 := mul64(a0, b3)
	r3 = addMul64(r3, a1, b2)
	r3 = addMul64(r3, a2, b1)
	r3 = addMul64(r3, a3, b0)
	r3 = addMul64(r3, a4_19, b4)

	// r4 = a0×b4 + a1×b3 + a2×b2 + a3×b1 + a4×b0

		t.Errorf("emit percent: got:\n%+v\nwant:\n%+v\n",
			gotPercent, wantPercent)
	}

	if err := fm.EmitFuncs(&b4); err != nil {
		t.Fatalf("EmitFuncs returned %v", err)
	}
	wantFuncs := strings.TrimSpace(`
p.go:10:	f1		33.3%
q.go:20:	f2		75.0%
total		(statements)	62.5%`)
	gotFuncs := strings.TrimSpace(b4.String())
	if wantFuncs != gotFuncs {
		t.Errorf("emit funcs: got:\n%s\nwant:\n%s\n", gotFuncs, wantFuncs)
	}

    byte[] b3 = "????".getBytes(Charsets.US_ASCII);
    byte[] b4 = "ニュース".getBytes(Charsets.US_ASCII);
    byte[] b5 = "スューー".getBytes(Charsets.US_ASCII);
    // Assert they are all equal (using the transitive property)
    assertTrue(Arrays.equals(b1, b2));
    assertTrue(Arrays.equals(b2, b3));
    assertTrue(Arrays.equals(b3, b4));
    assertTrue(Arrays.equals(b4, b5));
  }

00000280  2a 05 12 52 bf 2b e2 4b  64 94 9c 89 bb 2c 65 cb  |*..R.+.Kd....,e.|
00000290  59 2a f0 1a 15 b2 e3 6e  5a cc 48 b4 44 6c 44 07  |Y*.....nZ.H.DlD.|
000002a0  80 01 93 25 86 83 f2 8f  01 e6 ef 5e 9a 36 4e 7f  |...%.......^.6N.|
000002b0  bc 27 0e 4d f0 67 3a de  29 b5 e9 6a 7f 4b b4 77  |.'.M.g:.)..j.K.w|
000002c0  9b e2 3b 73 c9 51 e5 a6  df 97 a7 02 fa f2 f7 db  |..;s.Q..........|

000002d0  9f ac ad 72 11 b2 5d ee  19 63 d0 35 12 6d 5e 3f  |...r..]..c.5.m^?|
000002e0  81 a8 18 4a d4 09 f3 80  38 4a 31 08 3e a0 4c 78  |...J....8J1.>.Lx|
000002f0  48 08 e9 90 ba e7 2a b4  73 2e 2b 2b 15 60 ce 09  |H.....*.s.++.`..|
00000300  7d df 49 31 e1 9d ff 92  1d b4 af 2e 8c f8 a6 2e  |}.I1............|
00000310  93 d7 b9 10 69 10 7f 04  0d 8d e2 37 09 a7 d0 2a  |....i......7...*|

	ADDQ AX, R13
	ADCQ DX, R12

	// r3 += a3×b0
	MOVQ 24(CX), AX
	MULQ (BX)
	ADDQ AX, R13
	ADCQ DX, R12

	// r3 += 19×a4×b4
	MOVQ   32(CX), AX
	IMUL3Q $0x13, AX, AX
	MULQ   32(BX)
	ADDQ   AX, R13
	ADCQ   DX, R12

	// r4 = a0×b4
	MOVQ (CX), AX
	MULQ 32(BX)
	MOVQ AX, R15
	MOVQ DX, R14

	// r4 += a1×b3
	MOVQ 8(CX), AX
	MULQ 24(BX)
	ADDQ AX, R15

  @Override
  public int readInt() throws IOException {
    byte b1 = readAndCheckByte();
    byte b2 = readAndCheckByte();
    byte b3 = readAndCheckByte();
    byte b4 = readAndCheckByte();

    return Ints.fromBytes(b4, b3, b2, b1);
  }

  /**
   * Reads a {@code long} as specified by {@link DataInputStream#readLong()}, except using
   * little-endian byte order.
   *

			Valu("cmp", OpLess64, c.config.Types.Bool, 0, nil, "v1", "v2"),
			If("cmp", "b2", "b3")),
		Bloc("b2",
			Valu("v3", OpConst64, c.config.Types.Int64, 3, nil),
			Goto("b4")),
		Bloc("b3",
			Valu("v4", OpConst64, c.config.Types.Int64, 4, nil),
			Goto("b4")),
		Bloc("b4",
			Valu("merge", OpPhi, c.config.Types.Int64, 0, nil, "v3", "v4"),
			Exit("mem")))
	sccp(fun.f)
	CheckFunc(fun.f)
	for _, b := range fun.blocks {