RORL	$17, AX; \
	MOVL	CX, DX; \
	RORL	$19, CX; \
	SHRL	$10, DX; \
	MOVL	((index-15)*4)(BP), BX; \
	XORL	CX, AX; \
	MOVL	BX, CX; \
	XORL	DX, AX; \
	RORL	$7, BX; \
	MOVL	CX, DX; \
	SHRL	$3, DX; \
	RORL	$18, CX; \
	ADDL	((index-7)*4)(BP), AX; \
	XORL	CX, BX; \
	XORL	DX, BX; \
	ADDL	((index-16)*4)(BP), BX; \
	ADDL	BX, AX; \
	MOVL	AX, ((index)*4)(BP)

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

package codegen

//go:registerparams
func f1(a, b int) {
	// amd64:"MOVQ\tBX, CX", "MOVQ\tAX, BX", "MOVL\t\\$1, AX", -"MOVQ\t.*DX"
	g(1, a, b)
}

//go:registerparams
func f2(a, b int) {
	// amd64:"MOVQ\tBX, AX", "MOVQ\t[AB]X, CX", -"MOVQ\t.*, BX"
	g(b, b, b)
}

//go:noinline
//go:registerparams

#define INVOKE_SYSCALL	INT	$0x80

// func rawVforkSyscall(trap, a1, a2, a3 uintptr) (r1, err uintptr)
TEXT ·rawVforkSyscall(SB),NOSPLIT|NOFRAME,$0-24
	MOVL	trap+0(FP), AX	// syscall entry
	MOVL	a1+4(FP), BX
	MOVL	a2+8(FP), CX
	MOVL	a3+12(FP), DX
	POPL	SI // preserve return address
	INVOKE_SYSCALL
	PUSHL	SI
	CMPL	AX, $0xfffff001
	JLS	ok
	MOVL	$-1, r1+16(FP)
	NEGL	AX
	MOVL	AX, err+20(FP)
	RET
ok:

TEXT runtime·_mul64by32(SB), NOSPLIT, $0
	MOVL	lo64+0(FP), CX
	MOVL	a_lo+4(FP), AX
	MULL	b+12(FP)
	MOVL	AX, 0(CX)
	MOVL	DX, BX
	MOVL	a_hi+8(FP), AX
	MULL	b+12(FP)
	ADDL	AX, BX
	ADCL	$0, DX
	MOVL	BX, 4(CX)
	MOVL	DX, AX
	MOVL	AX, hi32+16(FP)
	RET

TEXT runtime·_div64by32(SB), NOSPLIT, $0
	MOVL	r+12(FP), CX
	MOVL	a_lo+0(FP), AX
	MOVL	a_hi+4(FP), DX
	DIVL	b+8(FP)

	ADDQ $1,DI
	CMPQ DI,DX
	JB loop2
	JMP fail
_3_or_more:
	CMPQ AX, $3
	JA   _4_or_more
	MOVW 1(R8), BX
	MOVW (R8), R8
	LEAQ -2(DI)(DX*1), DX
loop3:
	MOVW (DI), SI
	CMPW SI,R8
	JZ   partial_success3
	ADDQ $1,DI
	CMPQ DI,DX
	JB loop3
	JMP fail
partial_success3:
	MOVW 1(DI), SI
	CMPW SI,BX
	JZ success
	ADDQ $1,DI
	CMPQ DI,DX
	JB loop3
	JMP fail
_4_or_more:
	CMPQ AX, $4
	JA   _5_or_more

func (c *sigctxt) setsp(x uintptr) { c.u.sp = uint32(x) }
func (c *sigctxt) setlr(x uintptr) {}

func (c *sigctxt) savelr(x uintptr) {}

func dumpregs(u *ureg) {
	print("ax    ", hex(u.ax), "\n")
	print("bx    ", hex(u.bx), "\n")
	print("cx    ", hex(u.cx), "\n")
	print("dx    ", hex(u.dx), "\n")
	print("di    ", hex(u.di), "\n")
	print("si    ", hex(u.si), "\n")
	print("bp    ", hex(u.bp), "\n")
	print("sp    ", hex(u.sp), "\n")

	VPSHLDQ $121, (BX), Y31, K5, Y21                   // 62e38525712b79
	VPSHLDQ $121, -17(BP)(SI*1), Y31, K5, Y21          // 62e3852571ac35efffffff79
	VPSHLDQ $121, Y19, Y6, K5, Y21                     // 62a3cd2d71eb79
	VPSHLDQ $121, Y7, Y6, K5, Y21                      // 62e3cd2d71ef79
	VPSHLDQ $121, Y6, Y6, K5, Y21                      // 62e3cd2d71ee79
	VPSHLDQ $121, (BX), Y6, K5, Y21                    // 62e3cd2d712b79

	VEXTRACTI64X2 $0, Y11, K2, -7(CX)                  // 6273fd2a3999f9ffffff00
	VEXTRACTI64X2 $0, Y31, K2, 15(DX)(BX*4)            // 6263fd2a39bc9a0f00000000
	VEXTRACTI64X2 $0, Y6, K2, 15(DX)(BX*4)             // 62f3fd2a39b49a0f00000000
	VEXTRACTI64X2 $0, Y11, K2, 15(DX)(BX*4)            // 6273fd2a399c9a0f00000000
	VEXTRACTI64X2 $2, Z27, K2, X1                      // 6263fd4a39d902

#include "go_asm.h"
#include "textflag.h"

TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
	PUSHFL
	ADJSP $156
	NOP SP
	MOVL AX, 0(SP)
	MOVL CX, 4(SP)
	MOVL DX, 8(SP)
	MOVL BX, 12(SP)
	MOVL BP, 16(SP)
	MOVL SI, 20(SP)
	MOVL DI, 24(SP)
	#ifndef GO386_softfloat
	MOVUPS X0, 28(SP)
	MOVUPS X1, 44(SP)
	MOVUPS X2, 60(SP)
	MOVUPS X3, 76(SP)
	MOVUPS X4, 92(SP)
	MOVUPS X5, 108(SP)

	VAESENCLAST 15(DX)(BX*8), Y21, Y23                 // 62e25520ddbcda0f000000 or 62e2d520ddbcda0f000000
	VAESENCLAST Z25, Z6, Z22                           // 62824d48ddf1 or 6282cd48ddf1
	VAESENCLAST Z12, Z6, Z22                           // 62c24d48ddf4 or 62c2cd48ddf4
	VAESENCLAST 7(SI)(DI*1), Z6, Z22                   // 62e24d48ddb43e07000000 or 62e2cd48ddb43e07000000