MOVD.W	-8(srcPtr), H0
	VMOV	H0, T0.D[0]
	VMOV	H1, T3.D[0]
ld4:
	TBZ	$2, srcPtrLen, ld2
	MOVW.W	-4(srcPtr), H0
	VEXT	$12, T0.B16, ZERO.B16, T0.B16
	VEXT	$12, T3.B16, ZERO.B16, T3.B16
	VMOV	H0, T0.S[0]
	VMOV	H1, T3.S[0]
ld2:
	TBZ	$1, srcPtrLen, ld1
	MOVH.W	-2(srcPtr), H0
	VEXT	$14, T0.B16, ZERO.B16, T0.B16
	VEXT	$14, T3.B16, ZERO.B16, T3.B16
	VMOV	H0, T0.H[0]
	VMOV	H1, T3.H[0]
ld1:

	VMOV	V8.D[0], V12.S[1]                                // ERROR "operand mismatch"
	VMOV	V8.D[0], V12.H[1]                                // ERROR "operand mismatch"
	VMOV	V8.D[0], V12.B[1]                                // ERROR "operand mismatch"
	VMOV	V8.S[0], V12.H[1]                                // ERROR "operand mismatch"
	VMOV	V8.S[0], V12.B[1]                                // ERROR "operand mismatch"

	VMOV V18.B[10], V27                                         // 5b06155e
	VDUP V18.B[10], V27                                         // 5b06155e
	VMOV V12.B[2], V28.B[12]                                    // 9c15196e
	VMOV R30, V4.B[13]                                          // c41f1b4e
	VMOV V2.B16, V4.B16                                         // 441ca24e

	{VCMP_E_EQ_F64, []int{1, 0}, "VCMP.E", "CMPD"},
	{VLDR_EQ, []int{1}, "VLDR", "MOV"},
	{VSTR_EQ, []int{1}, "VSTR", "MOV"},
	{VMOV_EQ_F32, []int{1, 0}, "VMOV", "MOVF"},
	{VMOV_EQ_F64, []int{1, 0}, "VMOV", "MOVD"},
	{VMOV_EQ_32, []int{1, 0}, "VMOV", "MOVW"},
	{VMOV_EQ, []int{1, 0}, "VMOV", "MOVW"},
	{VCVT_EQ_F64_F32, []int{1, 0}, "VCVT", "MOVFD"},
	{VCVT_EQ_F32_F64, []int{1, 0}, "VCVT", "MOVDF"},

	rounds12to59	(m0,4,m3,m1,sha256msg1,vmov)    // 16-19
	rounds12to59	(m1,5,m0,m2,sha256msg1,vmov)    // 20-23
	rounds12to59	(m2,6,m1,m3,sha256msg1,vmov)    // 24-27
	rounds12to59	(m3,7,m2,m0,sha256msg1,vmov)    // 28-31
	rounds12to59	(m0,8,m3,m1,sha256msg1,vmov)    // 32-35
	rounds12to59	(m1,9,m0,m2,sha256msg1,vmov)    // 36-39
	rounds12to59	(m2,10,m1,m3,sha256msg1,vmov)   // 40-43

		regno := uint16(r) & 31
		return fmt.Sprintf("JMP (R%d)", regno)

	case MOV:
		rno := -1
		switch a := inst.Args[0].(type) {
		case Reg:
			rno = int(a)
		case RegSP:
			rno = int(a)
		case RegisterWithArrangementAndIndex:
			op = "VMOV"
		case RegisterWithArrangement:
			op = "VMOV"
		}
		if rno >= 0 && rno <= int(WZR) {
			op = "MOVW"

	CBZ	R10, noaes
	MOVD	$runtime·aeskeysched+0(SB), R3

	VEOR	V0.B16, V0.B16, V0.B16
	VLD1	(R3), [V2.B16]
	VLD1	(R0), V0.S[1]
	VMOV	R1, V0.S[0]

	AESE	V2.B16, V0.B16
	AESMC	V0.B16, V0.B16
	AESE	V2.B16, V0.B16
	AESMC	V0.B16, V0.B16
	AESE	V2.B16, V0.B16

	VMOV	V0.D[0], R0
	RET
noaes:
	B	runtime·memhash32Fallback<ABIInternal>(SB)

// func memhash64(p unsafe.Pointer, h uintptr) uintptr

	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
	VMOVH	W12, (R24)     // 7800c325
	VMOVH	W8, 110(R19)   // 78379a25
	VMOVH	W3, -70(R12)   // 7bdd60e5
	VMOVW	W31, (R3)      // 78001fe6
	VMOVW	W16, 64(R20)   // 7810a426

			// Mutate signature, non strict
			vMod := make([][]xlMetaV2ShallowVersion, 0, len(vers))
			for i, ver := range vers {
				newVers := make([]xlMetaV2ShallowVersion, 0, len(ver))
				for _, v := range ver {
					v.header.Signature = [4]byte{byte(i + 10), 0, 0, 0}
					newVers = append(newVers, v)
				}
				vMod = append(vMod, newVers)
			}
			merged := mergeXLV2Versions(i, false, 0, vMod...)
			if len(merged) == 0 {

	// X11 already saved (A1)
	MOV	X12, 6*8(X2)
	MOV	X13, 7*8(X2)
	MOV	X14, 8*8(X2)
	MOV	X15, 9*8(X2)
	MOV	X16, 10*8(X2)
	MOV	X17, 11*8(X2)
	MOV	X18, 12*8(X2)
	MOV	X19, 13*8(X2)
	MOV	X20, 14*8(X2)
	MOV	X21, 15*8(X2)
	MOV	X22, 16*8(X2)
	MOV	X23, 17*8(X2)
	MOV	X24, 18*8(X2)
	MOV	X25, 19*8(X2)
	MOV	X26, 20*8(X2)
	// X27 is g.
	MOV	X28, 21*8(X2)
	MOV	X29, 22*8(X2)
	MOV	X30, 23*8(X2)