/* If there is less than 16 bytes left we are done */
	CMPQ        CX, $16
	JB          finish

	/* Encode 16 bytes */
remain16:
	MOVOU       (SI), X10
	MOVOA       X1, X5
	PCLMULQDQ   $0, X0, X1
	PCLMULQDQ   $0x11, X0, X5
	PXOR        X5, X1
	PXOR        X10, X1
	SUBQ        $16, CX
	ADDQ        $16, SI
	CMPQ        CX, $16
	JGE         remain16

finish:

	"BLT",
	"BLEU",
	"BLTU",
	"BNE",
	"BVC",
	"BVS",
	"SYSCALL",
	"BRCT",
	"BRCTG",
	"CRJ",
	"CGRJ",
	"CLRJ",
	"CLGRJ",
	"CIJ",
	"CGIJ",
	"CLIJ",
	"CLGIJ",
	"CMPBEQ",
	"CMPBGE",
	"CMPBGT",
	"CMPBLE",
	"CMPBLT",
	"CMPBNE",
	"CMPUBEQ",
	"CMPUBGE",
	"CMPUBGT",
	"CMPUBLE",
	"CMPUBLT",
	"CMPUBNE",
	"MVC",
	"MVCIN",
	"CLC",
	"XC",

	SCASW:     "scas",
	STOSB:     "stos",
	STOSD:     "stos",
	STOSQ:     "stos",
	STOSW:     "stos",
	XLATB:     "xlat",
}

var cmppsOps = []string{
	"cmpeq",
	"cmplt",
	"cmple",
	"cmpunord",
	"cmpneq",
	"cmpnlt",
	"cmpnle",
	"cmpord",
}

var pclmulqOps = []string{
	"pclmullqlqdq",
	"pclmulhqlqdq",
	"pclmullqhqdq",
	"pclmulhqhqdq",
}

	//	LFADD freg ',' freg ',' freg
	//	{
	//		outcode(int($1), &$2, int($4.Reg), &$6);
	//	}
	ADDD	F1, F2, F3

	//	LFCMP freg ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	CMPEQD	F1, F2


	//
	// WORD
	//
	WORD	$1

	//
	// NOP
	//
	//	LNOP comma // asm doesn't support the trailing comma.
	//	{
	//		outcode(int($1), &nullgen, 0, &nullgen);
	//	}

	// final message block is 16 bytes long then we append the 1 bit
	// after expansion as normal.
	MOVBZ  $1, R0
	MOVD   $-16(R3), R3   // index of byte in last block to insert 1 at (could be 16)
	CMPBEQ R3, $16, 2(PC) // skip the insertion if the final block is 16 bytes long
	VLVGB  R3, R0, T_1    // insert 1 into the byte at index R3

	// Split both blocks into 26-bit limbs in the appropriate lanes.

// R5=&ret (int)
// Caller must confirm availability of vx facility before calling.
TEXT indexbody<>(SB),NOSPLIT|NOFRAME,$0
	CMPBGT	R4, R2, notfound
	ADD	R1, R2
	SUB	R4, R2 // R2=&s[len(s)-len(sep)] (last valid index)
	CMPBEQ	R4, $0, notfound
	SUB	$1, R4 // R4=len(sep)-1 for use as VLL index
	VLL	R4, (R3), V0 // contains first 16 bytes of sep
	MOVD	R1, R7
index2plus:
	CMPBNE	R4, $1, index3plus
	MOVD	$15(R7), R9
	CMPBGE	R9, R2, index2to16

#include "textflag.h"

// func block(dig *digest, p []byte)
TEXT ·block(SB),NOSPLIT,$16-32
	MOVD	dig+0(FP), R1
	MOVD	p+8(FP), R6
	MOVD	p_len+16(FP), R5
	AND	$-64, R5
	LAY	(R6)(R5*1), R7

	LMY	0(R1), R2, R5
	CMPBEQ	R6, R7, end

loop:
	STMY	R2, R5, tmp-16(SP)

	MOVWBR	0(R6), R8
	MOVWZ	R5, R9

#define ROUND1(a, b, c, d, index, const, shift) \
	XOR	c, R9; \
	ADD	$const, a; \
	ADD	R8, a; \

			opset(ASYNC, r0)
			opset(ANOOP, r0)
			opset(ATLBP, r0)
			opset(ATLBR, r0)
			opset(ATLBWI, r0)
			opset(ATLBWR, r0)

		case ACMPEQF:
			opset(ACMPGTF, r0)
			opset(ACMPGTD, r0)
			opset(ACMPGEF, r0)
			opset(ACMPGED, r0)
			opset(ACMPEQD, r0)

		case ABFPT:
			opset(ABFPF, r0)

		case AMOVWL:
			opset(AMOVWR, r0)

		case AMOVVL:
			opset(AMOVVR, r0)

	"PADDSW",
	"PADDUSB",
	"PADDUSW",
	"PADDW",
	"PALIGNR",
	"PAND",
	"PANDN",
	"PAUSE",
	"PAVGB",
	"PAVGW",
	"PBLENDVB",
	"PBLENDW",
	"PCLMULQDQ",
	"PCMPEQB",
	"PCMPEQL",
	"PCMPEQQ",
	"PCMPEQW",
	"PCMPESTRI",
	"PCMPESTRM",
	"PCMPGTB",
	"PCMPGTL",
	"PCMPGTQ",
	"PCMPGTW",
	"PCMPISTRI",
	"PCMPISTRM",
	"PDEPL",
	"PDEPQ",
	"PEXTL",
	"PEXTQ",

	CMPBNE	R1, R2, 0(PC)          // ec1200007064
	CMPBEQ	R3, R4, 0(PC)          // ec3400008064
	CMPBLT	R5, R6, 0(PC)          // ec5600004064
	CMPBLE	R7, R8, 0(PC)          // ec780000c064
	CMPBGT	R9, R1, 0(PC)          // ec9100002064
	CMPBGE	R2, R3, 0(PC)          // ec230000a064

	CMPBNE	R1, $-127, 0(PC)       // ec170000817c
	CMPBEQ	R3, $0, 0(PC)          // ec380000007c