SHA512ROUND0(7, X11, X12, X13, X14, X15, X16, X17, X10)
	SHA512ROUND0(8, X10, X11, X12, X13, X14, X15, X16, X17)
	SHA512ROUND0(9, X17, X10, X11, X12, X13, X14, X15, X16)
	SHA512ROUND0(10, X16, X17, X10, X11, X12, X13, X14, X15)
	SHA512ROUND0(11, X15, X16, X17, X10, X11, X12, X13, X14)
	SHA512ROUND0(12, X14, X15, X16, X17, X10, X11, X12, X13)
	SHA512ROUND0(13, X13, X14, X15, X16, X17, X10, X11, X12)

	VGF2P8AFFINEQB $82, X19, X0, K1, X16               // 62a3fd09cec352
	VGF2P8AFFINEQB $82, 17(SP)(BP*2), X0, K1, X16      // 62e3fd09ce846c1100000052
	VGF2P8AFFINEQB $82, -7(DI)(R8*4), X0, K1, X16      // 62a3fd09ce8487f9ffffff52
	VGF2P8AFFINEQB $82, X22, X28, K1, X16              // 62a39d01cec652
	VGF2P8AFFINEQB $82, X7, X28, K1, X16               // 62e39d01cec752

	BNEZ	X7, align

check32:
	// X6 contains $32
	BLT	X5, X6, compare16
compare32:
	MOV	0(X10), X15
	MOV	0(X12), X16
	MOV	8(X10), X17
	MOV	8(X12), X18
	BNE	X15, X16, cmp8a
	BNE	X17, X18, cmp8b
	MOV	16(X10), X15
	MOV	16(X12), X16
	MOV	24(X10), X17
	MOV	24(X12), X18
	BNE	X15, X16, cmp8a
	BNE	X17, X18, cmp8b
	ADD	$32, X10
	ADD	$32, X12
	SUB	$32, X5
	BGE	X5, X6, compare32
	BEQZ	X5, cmp_len

	BLT	X12, X9, f_loop16_check
	MOV	$64, X9
	BLT	X12, X9, f_loop32_check
f_loop64:
	MOV	0(X11), X14
	MOV	8(X11), X15
	MOV	16(X11), X16
	MOV	24(X11), X17
	MOV	32(X11), X18
	MOV	40(X11), X19
	MOV	48(X11), X20
	MOV	56(X11), X21
	MOV	X14, 0(X10)
	MOV	X15, 8(X10)
	MOV	X16, 16(X10)
	MOV	X17, 24(X10)
	MOV	X18, 32(X10)
	MOV	X19, 40(X10)
	MOV	X20, 48(X10)
	MOV	X21, 56(X10)
	ADD	$64, X10
	ADD	$64, X11

	VRSQRT28SS X28, X22, K7, X16                       // 62824d07cdc4
	VRSQRT28SS X8, X22, K7, X16                        // 62c24d07cdc0
	VRSQRT28SS X16, X12, K7, X16                       // 62a21d0fcdc0
	VRSQRT28SS X28, X12, K7, X16                       // 62821d0fcdc4
	VRSQRT28SS X8, X12, K7, X16                        // 62c21d0fcdc0
	VRSQRT28SS X16, X6, K7, X6                         // 62b24d0fcdf0

	VPCLMULQDQ $127, X22, X21, X16                     // 62a3550044c67f or 62a3d50044c67f
	VPCLMULQDQ $127, X7, X21, X16                      // 62e3550044c77f or 62e3d50044c77f
	VPCLMULQDQ $127, X19, X21, X16                     // 62a3550044c37f or 62a3d50044c37f
	VPCLMULQDQ $127, -17(BP)(SI*8), X21, X16           // 62e355004484f5efffffff7f or 62e3d5004484f5efffffff7f

	VPSHLDQ $94, X19, X0, K4, X16                      // 62a3fd0c71c35e
	VPSHLDQ $94, 17(SP), X0, K4, X16                   // 62e3fd0c718424110000005e
	VPSHLDQ $94, -17(BP)(SI*4), X0, K4, X16            // 62e3fd0c7184b5efffffff5e
	VPSHLDQ $94, X22, X28, K4, X16                     // 62a39d0471c65e
	VPSHLDQ $94, X7, X28, K4, X16                      // 62e39d0471c75e

// Test that inlining of math/bits.RotateLeft* treats those calls as intrinsics.

package p

import "math/bits"

var (
	x8  uint8
	x16 uint16
	x32 uint32
	x64 uint64
	x   uint
)

func f() { // ERROR "can inline f"
	x8 = bits.RotateLeft8(x8, 1)
	x16 = bits.RotateLeft16(x16, 1)
	x32 = bits.RotateLeft32(x32, 1)
	x64 = bits.RotateLeft64(x64, 1)
	x = bits.RotateLeft(x, 1)

	VAESENC X14, X16, X13                              // 62527d00dcee or 6252fd00dcee
	VAESENC X19, X16, X13                              // 62327d00dceb or 6232fd00dceb
	VAESENC X8, X16, X13                               // 62527d00dce8 or 6252fd00dce8
	VAESENC 99(R15)(R15*8), X16, X13                   // 62127d00dcacff63000000 or 6212fd00dcacff63000000

loop32:
	MOV	0(X10), X19
	MOV	0(X11), X20
	MOV	8(X10), X21
	MOV	8(X11), X22
	BNE	X19, X20, not_eq
	BNE	X21, X22, not_eq
	MOV	16(X10), X14
	MOV	16(X11), X15
	MOV	24(X10), X16
	MOV	24(X11), X17
	BNE	X14, X15, not_eq
	BNE	X16, X17, not_eq
	ADD	$32, X10
	ADD	$32, X11
	SUB	$32, X12
	BGE	X12, X9, loop32
	BEQZ	X12, eq

loop16_check:
	MOV	$16, X23
	BLT	X12, X23, loop4_check
loop16:
	MOV	0(X10), X19