func (bp *BytePoolCap) Populate() {
	for _, buf := range reedsolomon.AllocAligned(cap(bp.c), bp.wcap) {
		bp.Put(buf[:bp.w])
	}
}

// Get gets a []byte from the BytePool, or creates a new one if none are
// available in the pool.
func (bp *BytePoolCap) Get() (b []byte) {
	if bp == nil {
		return nil
	}
	select {
	case b = <-bp.c:
		// reuse existing buffer
	default:

	VPGATHERQQ (BP)(X2*2), K1, X2   // ERROR "index and destination registers should be distinct"
	VPGATHERQQ (BP)(Y15*2), K1, Y15 // ERROR "index and destination registers should be distinct"
	VPGATHERQQ (BP)(Z20*2), K1, Z20 // ERROR "index and destination registers should be distinct"
	VPGATHERDQ (BP)(X2*2), K1, X2   // ERROR "index and destination registers should be distinct"

	bp.Put(make([]byte, width))           // wrong capacity is rejected (very less)
	if len(bp.c) > 0 {
		t.Fatal("bytepool should have rejected invalid packets")
	}

	// Try putting a short slice into pool
	bp.Put(make([]byte, bp.w, bp.wcap)[:2])
	if len(bp.c) != 1 {
		t.Fatal("bytepool should have accepted short slice with sufficient capacity")
	}

	b = bp.Get()

	{"$~15", "$-16"},
	{"(((8)&0xf)*4)(SP)", "32(SP)"},
	{"(((8-14)&0xf)*4)(SP)", "40(SP)"},
	{"(6+8)(AX)", "14(AX)"},
	{"(8*4)(BP)", "32(BP)"},
	{"(AX)", "(AX)"},
	{"(AX)(CX*8)", "(AX)(CX*8)"},
	{"(BP)(CX*4)", "(BP)(CX*4)"},
	{"(BP)(DX*4)", "(BP)(DX*4)"},
	{"(BP)(R8*4)", "(BP)(R8*4)"},
	{"(BX)", "(BX)"},
	{"(DI)", "(DI)"},
	{"(DI)(BX*1)", "(DI)(BX*1)"},
	{"(DX)", "(DX)"},
	{"(R9)", "(R9)"},

	VPGATHERDQ Y0, 664(X14*8), Y6           // c4a2fd9034f598020000
	VPGATHERQQ X2, (BP)(X7*2), X1           // c4e2e9914c7d00
	VPGATHERQQ Y2, (BP)(Y7*2), Y1           // c4e2ed914c7d00
	VPGATHERQQ X12, (R13)(X14*2), X11       // c40299915c7500
	VPGATHERQQ Y12, (R13)(Y14*2), Y11       // c4029d915c7500
	VPGATHERQQ X2, (BP)(X7*2), X1           // c4e2e9914c7d00
	VPGATHERQQ Y2, (BP)(Y7*2), Y1           // c4e2ed914c7d00

			"#define KEYROUND(xmm, load, off, r1, r2, index) \\",
			"\tMOVBLZX	(BP)(DX*4),	R8 \\",
			"\tload((off+1), r2) \\",
			"\tMOVB	R8,		(off*4)(R12) \\",
			"\tPINSRW	$index, (BP)(R8*4), xmm",
			"#define LOAD(off, reg) \\",
			"\tMOVBLZX	(off*4)(R12),	reg \\",
			"\tADDB	reg,		DX",
			"KEYROUND(X0, LOAD, 8, AX, BX, 0)",
		),

·blockAMD64(SB), $264-32 MOVQ p_base+8(FP), SI MOVQ p_len+16(FP), DX SHRQ $0x06, DX SHLQ $0x06, DX LEAQ (SI)(DX*1), DI MOVQ DI, 256(SP) CMPQ SI, DI JEQ end MOVQ dig+0(FP), BP MOVL (BP), R8 MOVL 4(BP), R9 MOVL 8(BP), R10 MOVL 12(BP), R11 MOVL 16(BP), R12 MOVL 20(BP), R13 MOVL 24(BP), R14 MOVL 28(BP), R15 loop: MOVQ SP, BP MOVL (SI), AX BSWAPL AX MOVL AX, (BP) ADDL AX, R15 MOVL R12, AX ADDL $0x428a2f98, R15 MOVL R12, CX RORL $0x06, AX MOVL R12, DX RORL $0x0b, CX XORL CX, AX MOVL R12, CX RORL $0x19, DX ANDL R13, CX...

	for _, v := range s {
		if len(v) > maxInt-n {
			panic("bytes: Join output length overflow")
		}
		n += len(v)
	}

	b := bytealg.MakeNoZero(n)[:n:n]
	bp := copy(b, s[0])
	for _, v := range s[1:] {
		bp += copy(b[bp:], sep)
		bp += copy(b[bp:], v)
	}
	return b
}

// HasPrefix reports whether the byte slice s begins with prefix.
func HasPrefix(s, prefix []byte) bool {

</p>

<pre>
get_tls(CX)
MOVQ	g(CX), AX     // Move g into AX.
MOVQ	g_m(AX), BX   // Move g.m into BX.
</pre>

<p>
Register <code>BP</code> is callee-save.
The assembler automatically inserts <code>BP</code> save/restore when frame size is larger than zero.
Using <code>BP</code> as a general purpose register is allowed,
however it can interfere with sampling-based profiling.
</p>

<h3 id="arm">ARM</h3>

<p>

SHA256ROUND1(63, 0xc67178f2, 1, 2, 3, 4, 5, 6, 7, 0) MOVL dig+0(FP), BP MOVL (0*4)(BP), AX // H0 = a + H0 ADDL (0*4)(DI), AX MOVL AX, (0*4)(DI) MOVL AX, (0*4)(BP) MOVL (1*4)(BP), BX // H1 = b + H1 ADDL (1*4)(DI), BX MOVL BX, (1*4)(DI) MOVL BX, (1*4)(BP) MOVL (2*4)(BP), CX // H2 = c + H2 ADDL (2*4)(DI), CX MOVL CX, (2*4)(DI) MOVL CX, (2*4)(BP) MOVL (3*4)(BP), DX // H3 = d + H3 ADDL (3*4)(DI), DX MOVL DX, (3*4)(DI) MOVL DX, (3*4)(BP) MOVL (4*4)(BP), AX // H4 = e + H4 ADDL (4*4)(DI), AX MOVL AX, (4*4)(DI) MOVL...