{"a1+8(FP)", "a1+8(FP)"},
	{"·AddInt32(SB)", `pkg.AddInt32(SB)`},
	{"runtime·divWVW(SB)", "runtime.divWVW(SB)"},
	{"$argframe+0(FP)", "$argframe(FP)"},
	{"$asmcgocall<>(SB)", "$asmcgocall<>(SB)"},
	{"EQ", "EQ"},
	{"F29", "F29"},
	{"F3", "F3"},
	{"F30", "F30"},
	{"g", "g"},
	{"LR", "R30"},
	{"(LR)", "(R30)"},
	{"R0", "R0"},
	{"R10", "R10"},
	{"R11", "R11"},
	{"R18_PLATFORM", "R18"},

TEXT	foo(SB), DUPOK|NOSPLIT, $0

	ADDF	F0, F1, F2    // 002a31ee
	ADDD.EQ	F3, F4, F5    // 035b340e
	ADDF.NE	F0, F2        // 002a321e
	ADDD	F3, F5        // 035b35ee
	SUBF	F0, F1, F2    // 402a31ee
	SUBD.EQ	F3, F4, F5    // 435b340e
	SUBF.NE	F0, F2        // 402a321e
	SUBD	F3, F5        // 435b35ee
	MULF	F0, F1, F2    // 002a21ee
	MULD.EQ	F3, F4, F5    // 035b240e
	MULF.NE	F0, F2        // 002a221e

	"U":  arm.C_UBIT,
	"S":  arm.C_SBIT,
	"W":  arm.C_WBIT,
	"P":  arm.C_PBIT,
	"PW": arm.C_WBIT | arm.C_PBIT,
	"WP": arm.C_WBIT | arm.C_PBIT,
}

var armSCOND = map[string]uint8{
	"EQ":  arm.C_SCOND_EQ,
	"NE":  arm.C_SCOND_NE,
	"CS":  arm.C_SCOND_HS,
	"HS":  arm.C_SCOND_HS,
	"CC":  arm.C_SCOND_LO,
	"LO":  arm.C_SCOND_LO,
	"MI":  arm.C_SCOND_MI,
	"PL":  arm.C_SCOND_PL,
	"VS":  arm.C_SCOND_VS,

	}
}

func BenchmarkEqual(b *testing.B) {
	b.Run("0", func(b *testing.B) {
		var buf [4]byte
		buf1 := buf[0:0]
		buf2 := buf[1:1]
		for i := 0; i < b.N; i++ {
			eq := Equal(buf1, buf2)
			if !eq {
				b.Fatal("bad equal")
			}
		}
	})

	sizes := []int{1, 6, 9, 15, 16, 20, 32, 4 << 10, 4 << 20, 64 << 20}

	b.Run("same", func(b *testing.B) {

	CSINCW HS, ZR, R27, R14                    // ee279b1a
	CSINC VC, R2, R1, R1                       // 4174819a
	CSINVW EQ, R2, R21, R17                    // 5100955a
	CSINV LO, R2, R19, R23                     // 573093da
	CINCW LO, R27, R14                         // 6e279b1a
	CINCW HS, R27, ZR                          // 7f379b1a
	CINVW EQ, R2, R17                          // 5110825a
	CINV VS, R12, R7                           // 87718cda

	BLE	jmp_label_0 // BLE 519 // f0ffffda
	B	jmp_label_0 // JMP 519 // efffffea
	B	0(PC)    // JMP 0(PC)  // feffffea
jmp_label_1:
	B	jmp_label_1 // JMP     // feffffea

// BL
	BL.EQ	14(PC) // CALL.EQ 14(PC)   // 0c00000b
	BL.NE	13(PC) // CALL.NE 13(PC)   // 0b00001b
	BL.CS	12(PC) // CALL.CS 12(PC)   // 0a00002b
	BL.CC	11(PC) // CALL.CC 11(PC)   // 0900003b
	BL.MI	10(PC) // CALL.MI 10(PC)   // 0800004b

	CSINV	CS, R1, R2, R3	// CSINV	HS, R1, R2, R3 // 232082da
	CSINV	HS, R1, R2, R3	// 232082da
	CSINVW	MI, R2, ZR, R2	// 42409f5a
	CINC	EQ, R4, R9	// 8914849a
	CINCW	PL, R2, ZR	// 5f44821a
	CINV	PL, R11, R22	// 76418bda
	CINVW	LS, R7, R13	// ed80875a
	CNEG	LS, R13, R7	// a7858dda
	CNEGW	EQ, R8, R13	// 0d15885a

// atomic ops
	LDARB	(R25), R2                            // 22ffdf08

For the hardware register, use <code>R13</code>.
</p>

<p>
Condition code syntax is to append a period and the one- or two-letter code to the instruction,
as in <code>MOVW.EQ</code>.
Multiple codes may be appended: <code>MOVM.IA.W</code>.
The order of the code modifiers is irrelevant.
</p>

<p>
Addressing modes:
</p>

<ul>

<li>
<code>R0-&gt;16</code>

pkg image, method (*YCbCr) SubImage(Rectangle) Image
pkg image, method (*YCbCr) YOffset(int, int) int
pkg image, method (Point) Add(Point) Point
pkg image, method (Point) Div(int) Point
pkg image, method (Point) Eq(Point) bool
pkg image, method (Point) In(Rectangle) bool
pkg image, method (Point) Mod(Rectangle) Point
pkg image, method (Point) Mul(int) Point
pkg image, method (Point) String() string