SHA256ROUND0(6, 0x923f82a4, R10, R11, R12, R13, R14, R15, R8, R9)
	SHA256ROUND0(7, 0xab1c5ed5, R9, R10, R11, R12, R13, R14, R15, R8)
	SHA256ROUND0(8, 0xd807aa98, R8, R9, R10, R11, R12, R13, R14, R15)
	SHA256ROUND0(9, 0x12835b01, R15, R8, R9, R10, R11, R12, R13, R14)
	SHA256ROUND0(10, 0x243185be, R14, R15, R8, R9, R10, R11, R12, R13)
	SHA256ROUND0(11, 0x550c7dc3, R13, R14, R15, R8, R9, R10, R11, R12)

	MOVD	$16, R14	// index for VSX loads and stores
	MOVD	$32, R15
	MOVD	$48, R16
	ANDCC	$0x3F, R5, R5	// len%64==0?

	PCALIGN $16
loop64:
	LXVD2X	(R8+R0), V0
	LXVD2X	(R4+R0), V1
	VCMPEQUBCC V0, V1, V2	// compare, setting CR6
	BGELR_CR6
	LXVD2X	(R8+R14), V0
	LXVD2X	(R4+R14), V1
	VCMPEQUBCC	V0, V1, V2
	BGELR_CR6
	LXVD2X	(R8+R15), V0
	LXVD2X	(R4+R15), V1
	VCMPEQUBCC	V0, V1, V2
	BGELR_CR6
	LXVD2X	(R8+R16), V0

	// since its faster on POWER
repeat:
	MOVD    (R6)(R14), R15  // Copy 8 bytes at a time
	MOVD    R15, (R3)(R14)
	ADD     $8, R14
	CMP     R14, R7         // More 8 bytes left?
	BLT     repeat
	BR      done
backward:
	ADD     $-8,R7, R14
repeatback:
	MOVD    (R6)(R14), R15  // copy x into z backwards
	MOVD    R15, (R3)(R14)  // copy 8 bytes at a time
	SUB     $8, R14

	VGF2P8AFFINEINVQB $47, 99(R15)(R15*1), Z14, K2, Z28 // 62038d4acfa43f630000002f
	VGF2P8AFFINEINVQB $47, (DX), Z14, K2, Z28          // 62638d4acf222f
	VGF2P8AFFINEINVQB $47, Z3, Z28, K2, Z28            // 62639d42cfe32f
	VGF2P8AFFINEINVQB $47, Z12, Z28, K2, Z28           // 62439d42cfe42f
	VGF2P8AFFINEINVQB $47, 99(R15)(R15*1), Z28, K2, Z28 // 62039d42cfa43f630000002f

	MOVWHI	24(R2), R14
	MOVWHI	28(R2), R15
	MOVWLO	3(R2), R8
	MOVWLO	7(R2), R9
	MOVWLO	11(R2), R10
	MOVWLO	15(R2), R11
	MOVWLO	19(R2), R12
	MOVWLO	23(R2), R13
	MOVWLO	27(R2), R14
	MOVWLO	31(R2), R15
	ADDU	$32, R2
	MOVW	R8, -32(R1)
	MOVW	R9, -28(R1)
	MOVW	R10, -24(R1)
	MOVW	R11, -20(R1)
	MOVW	R12, -16(R1)
	MOVW	R13, -12(R1)
	MOVW	R14, -8(R1)
	MOVW	R15, -4(R1)
	JMP	f_large_ua

	VEXP2PS Z9, K1, Z1                                 // 62d27d49c8c9
	VEXP2PS 99(R15)(R15*4), K1, Z1                     // 62927d49c88cbf63000000
	VEXP2PS 15(DX), K1, Z1                             // 62f27d49c88a0f000000
	VEXP2PS Z20, K1, Z9                                // 62327d49c8cc
	VEXP2PS Z9, K1, Z9                                 // 62527d49c8c9
	VEXP2PS 99(R15)(R15*4), K1, Z9                     // 62127d49c88cbf63000000

	MOVD.P	8(R8), R11
	MOVD.P	8(R9), R15
	ADCS	R15, R11
	MOVD.P	R11, 8(R10)
	SUB	$1, R0
two:
	TBZ	$1, R0, loop
	LDP.P	16(R8), (R11, R12)
	LDP.P	16(R9), (R15, R16)
	ADCS	R15, R11
	ADCS	R16, R12
	STP.P	(R11, R12), 16(R10)
	SUB	$2, R0
loop:
	CBZ	R0, done	// careful not to touch the carry flag
	LDP.P	32(R8), (R11, R12)
	LDP	-16(R8), (R13, R14)
	LDP.P	32(R9), (R15, R16)
	LDP	-16(R9), (R17, R19)
	ADCS	R15, R11

	BEQ	R4, R12, samebytes // length is 0

	SRLV	$4, R14		// R14 is number of chunks
	BEQ	R0, R14, byte_loop

	// make sure both a and b are aligned.
	OR	R4, R6, R15
	AND	$7, R15
	BNE	R0, R15, byte_loop

	PCALIGN	$16
chunk16_loop:
	BEQ	R0, R14, byte_loop
	MOVV	(R4), R8
	MOVV	(R6), R9
	BNE	R8, R9, byte_loop
	MOVV	8(R4), R16
	MOVV	8(R6), R17
	ADDV	$16, R4
	ADDV	$16, R6

TEXT ·svcLoad(SB), NOSPLIT, $0
	MOVD R15, R2         // Save go stack pointer
	MOVD name+0(FP), R0  // Move SVC args into registers
	MOVD $0x80000000, R1
	MOVD $0, R15
	SVC_LOAD
	MOVW R15, R3         // Save return code from SVC
	MOVD R2, R15         // Restore go stack pointer
	CMP  R3, $0          // Check SVC return code
	BNE  error

	MOVD $-2, R3       // Reset last bit of entry point to zero
	AND  R0, R3

TEXT	asancall<>(SB), NOSPLIT, $0-0
	MOVV	R3, R23         // callee-saved
	BEQ	g, g0stack      // no g, still on a system stack
	MOVV	g_m(g), R14
	MOVV	m_g0(R14), R15
	BEQ	R15, g, g0stack

	MOVV	(g_sched+gobuf_sp)(R15), R9
	MOVV	R9, R3

g0stack:
	JAL	(FARG)
	MOVV	R23, R3