MULXQ 232(CX), R8, BX
	ADCXQ DI, R8
	ADOXQ 232(AX), R8
	MOVQ  R8, 232(AX)

	// Iteration 30
	MULXQ 240(CX), R8, DI
	ADCXQ BX, R8
	ADOXQ 240(AX), R8
	MOVQ  R8, 240(AX)

	// Iteration 31
	MULXQ 248(CX), R8, BX
	ADCXQ DI, R8
	ADOXQ 248(AX), R8
	MOVQ  R8, 248(AX)

	// Add back carry flags and return
	ADCXQ SI, BX
	ADOXQ SI, BX
	MOVQ  BX, c+24(FP)

	VMOVDQA	Y3, 0x60(DI)
	ADDQ	AX, DI
	SUBQ	AX, BX
	JA	gobble_128_loop
	// Now we can store unaligned parts.
	ADDQ	AX, BX
	ADDQ	DI, BX
	VMOVDQU	Y4, (R10)
	VZEROUPPER
	MOVOU	X5, -0x80(BX)
	MOVOU	X6, -0x70(BX)
	MOVOU	X7, -0x60(BX)
	MOVOU	X8, -0x50(BX)
	MOVOU	X9, -0x40(BX)
	MOVOU	X10, -0x30(BX)
	MOVOU	X11, -0x20(BX)
	MOVOU	X12, -0x10(BX)
	RET

gobble_big_data_fwd:

	PUSHL	AX
	PUSHL	BX
	get_tls(BX)
	MOVL	g(BX), BX
	LEAL	arg+0(FP), AX
	MOVL	AX, (g_sched+gobuf_sp)(BX)
	MOVL	$runtime·systemstack_switch(SB), AX
	MOVL	AX, (g_sched+gobuf_pc)(BX)
	MOVL	$0, (g_sched+gobuf_ret)(BX)
	// Assert ctxt is zero. See func save.
	MOVL	(g_sched+gobuf_ctxt)(BX), AX
	TESTL	AX, AX
	JZ	2(PC)
	CALL	runtime·abort(SB)
	POPL	BX
	POPL	AX
	RET

	ROUND2(BX, CX, DX, BP, AX, 34)
	ROUND2(AX, BX, CX, DX, BP, 35)
	ROUND2(BP, AX, BX, CX, DX, 36)
	ROUND2(DX, BP, AX, BX, CX, 37)
	ROUND2(CX, DX, BP, AX, BX, 38)
	ROUND2(BX, CX, DX, BP, AX, 39)

	ROUND3(AX, BX, CX, DX, BP, 40)
	ROUND3(BP, AX, BX, CX, DX, 41)
	ROUND3(DX, BP, AX, BX, CX, 42)
	ROUND3(CX, DX, BP, AX, BX, 43)
	ROUND3(BX, CX, DX, BP, AX, 44)
	ROUND3(AX, BX, CX, DX, BP, 45)

	MOVL	BX, bx-4(SP)
	MOVL	BP, bp-8(SP)
	MOVL	SI, si-12(SP)
	MOVL	DI, di-16(SP)
	// We don't save mxcsr or the x87 control word because sigtrampgo doesn't
	// modify them.

	MOVL	32(SP), BX // signo
	MOVL	BX, 0(SP)
	MOVL	36(SP), BX // info
	MOVL	BX, 4(SP)
	MOVL	40(SP), BX // context
	MOVL	BX, 8(SP)
	CALL	runtime·sigtrampgo(SB)

	MOVL	di-16(SP), DI

"\\bx\\b"
-;-;-;-
-;-;-;-
"^(?:\\bx\\b)$"
-;-;-;-
-;-;-;-
"^(?:\\bx\\b)"
-;-;-;-
-;-;-;-
"(?:\\bx\\b)$"
-;-;-;-
-;-;-;-
strings
""
"áxβ"
regexps
"\\bx\\b"
-;-;-;-
-;2-3;-;2-3
"^(?:\\bx\\b)$"
-;-;-;-
-;-;-;-
"^(?:\\bx\\b)"
-;-;-;-
-;-;-;-
"(?:\\bx\\b)$"
-;-;-;-
-;-;-;-
strings
""
"axb"
regexps
"\\Bx\\B"

	RORQ	$19, AX; \
	MOVQ	CX, DX; \
	RORQ	$61, CX; \
	SHRQ	$6, DX; \
	MOVQ	((index-15)*8)(BP), BX; \
	XORQ	CX, AX; \
	MOVQ	BX, CX; \
	XORQ	DX, AX; \
	RORQ	$1, BX; \
	MOVQ	CX, DX; \
	SHRQ	$7, DX; \
	RORQ	$8, CX; \
	ADDQ	((index-7)*8)(BP), AX; \
	XORQ	CX, BX; \
	XORQ	DX, BX; \
	ADDQ	((index-16)*8)(BP), BX; \
	ADDQ	BX, AX; \
	MOVQ	AX, ((index)*8)(BP)

// Calculate T1 in AX - uses AX, CX and DX registers.

	// modify them.

	MOVL	(28+4)(SP), BX
	MOVL	BX, 0(SP)
	MOVL	(28+8)(SP), BX
	MOVL	BX, 4(SP)
	MOVL	(28+12)(SP), BX
	MOVL	BX, 8(SP)
	CALL	runtime·sigtrampgo(SB)

	MOVL	di-16(SP), DI
	MOVL	si-12(SP), SI
	MOVL	bp-8(SP),  BP
	MOVL	bx-4(SP),  BX
	RET

TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
	JMP	runtime·sigtramp(SB)

	MOVQ	_cgo_callers(SB), AX
	JMP	AX

TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
	MOVQ	DI, BX
	MOVQ	0(BX), DI		// arg 1 addr
	MOVQ	8(BX), SI		// arg 2 len
	MOVL	16(BX), DX		// arg 3 prot
	MOVL	20(BX), CX		// arg 4 flags
	MOVL	24(BX), R8		// arg 5 fid
	MOVL	28(BX), R9		// arg 6 offset
	CALL	libc_mmap(SB)
	XORL	DX, DX
	CMPQ	AX, $-1
	JNE	ok
	CALL	libc_error(SB)

	VPDPBUSD -15(BX), X16, K2, X6                      // 62f27d0250b3f1ffffff
	VPDPBUSD X15, X28, K2, X6                          // 62d21d0250f7
	VPDPBUSD X11, X28, K2, X6                          // 62d21d0250f3
	VPDPBUSD X1, X28, K2, X6                           // 62f21d0250f1
	VPDPBUSD -15(R14)(R15*1), X28, K2, X6              // 62921d0250b43ef1ffffff
	VPDPBUSD -15(BX), X28, K2, X6                      // 62f21d0250b3f1ffffff