MOVUPS	X15,(DI)
	MOVUPS	X15,16(DI)
	MOVUPS	X15,32(DI)
	MOVUPS	X15,48(DI)
	LEAQ	64(DI),DI

	MOVUPS	X15,(DI)
	MOVUPS	X15,16(DI)
	MOVUPS	X15,32(DI)
	MOVUPS	X15,48(DI)
	LEAQ	64(DI),DI

	MOVUPS	X15,(DI)
	MOVUPS	X15,16(DI)
	MOVUPS	X15,32(DI)
	MOVUPS	X15,48(DI)
	LEAQ	64(DI),DI

	MOVUPS	X15,(DI)
	MOVUPS	X15,16(DI)
	MOVUPS	X15,32(DI)
	MOVUPS	X15,48(DI)
	LEAQ	64(DI),DI

	MOVUPS	X15,(DI)

	JE 2(PC)
	#endif
	VZEROUPPER
	#endif
	MOVUPS X0, 112(SP)
	MOVUPS X1, 128(SP)
	MOVUPS X2, 144(SP)
	MOVUPS X3, 160(SP)
	MOVUPS X4, 176(SP)
	MOVUPS X5, 192(SP)
	MOVUPS X6, 208(SP)
	MOVUPS X7, 224(SP)
	MOVUPS X8, 240(SP)
	MOVUPS X9, 256(SP)
	MOVUPS X10, 272(SP)
	MOVUPS X11, 288(SP)
	MOVUPS X12, 304(SP)
	MOVUPS X13, 320(SP)
	MOVUPS X14, 336(SP)
	MOVUPS X15, 352(SP)
	CALL ·asyncPreempt2(SB)

	MOVUPS 32(AX), X1
	AESENC X1, X0
	MOVUPS 48(AX), X1
	AESENC X1, X0
	MOVUPS 64(AX), X1
	AESENC X1, X0
	MOVUPS 80(AX), X1
	AESENC X1, X0
	MOVUPS 96(AX), X1
	AESENC X1, X0
	MOVUPS 112(AX), X1
	AESENC X1, X0
	MOVUPS 128(AX), X1
	AESENC X1, X0
	MOVUPS 144(AX), X1
	AESENCLAST X1, X0
	MOVUPS X0, 0(DX)
	RET

// func decryptBlockAsm(nr int, xk *uint32, dst, src *byte)
TEXT ·decryptBlockAsm(SB),NOSPLIT,$0

	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)
	MOVUPS X6, 124(SP)
	MOVUPS X7, 140(SP)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GO386_softfloat
	MOVUPS 140(SP), X7
	MOVUPS 124(SP), X6
	MOVUPS 108(SP), X5
	MOVUPS 92(SP), X4
	MOVUPS 76(SP), X3
	MOVUPS 60(SP), X2
	MOVUPS 44(SP), X1
	MOVUPS 28(SP), X0

	MOVQ	R12, (4*8)(SP)	\
	MOVQ	R13, (5*8)(SP)	\
	MOVQ	R14, (6*8)(SP)	\
	MOVQ	R15, (7*8)(SP)	\
	MOVUPS	X6, (8*8)(SP)	\
	MOVUPS	X7, (10*8)(SP)	\
	MOVUPS	X8, (12*8)(SP)	\
	MOVUPS	X9, (14*8)(SP)	\
	MOVUPS	X10, (16*8)(SP)	\
	MOVUPS	X11, (18*8)(SP)	\
	MOVUPS	X12, (20*8)(SP)	\
	MOVUPS	X13, (22*8)(SP)	\
	MOVUPS	X14, (24*8)(SP)	\
	MOVUPS	X15, (26*8)(SP)

#define POP_REGS_HOST_TO_ABI0()	\
	MOVQ	(0*0)(SP), DI	\
	MOVQ	(1*8)(SP), SI	\

//    Zeroing    //
// ------------- //

type Z1 struct {
	a, b, c int
}

func Zero1(t *Z1) { // Issue #18370
	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
	*t = Z1{}
}

type Z2 struct {
	a, b, c *int
}

func Zero2(t *Z2) {
	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
	// amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
	*t = Z2{}
}

// ------------------ //

// operations are not allowed in the note handler.

func ArrayZero() [16]byte {
	// amd64:"MOVUPS"
	// plan9/amd64/:-"MOVUPS"
	var a [16]byte
	return a
}

func ArrayCopy(a [16]byte) (b [16]byte) {
	// amd64:"MOVUPS"
	// plan9/amd64/:-"MOVUPS"
	b = a
	return
}

// ---------------- //
//  Float Min/Max   //
// ---------------- //

	// amd64:"MOVUPS\tX15"
	// ppc64x:-`.*runtime\.memclrNoHeapPointers`
	// ppc64x:-`.*runtime\.makeslice`
	// ppc64x:-`.*runtime\.panicmakeslicelen`
	return append(s, make([]int, uint64(1<<2))...)
}

func SliceExtensionConstUint(s []int) []int {
	// amd64:-`.*runtime\.memclrNoHeapPointers`
	// amd64:-`.*runtime\.makeslice`
	// amd64:-`.*runtime\.panicmakeslicelen`
	// amd64:"MOVUPS\tX15"

	b = a
	return
}

// Make sure we don't put pointers in SSE registers across safe
// points.

func safe_point(p, q *[2]*int) {
	a, b := p[0], p[1] // amd64:-`MOVUPS`
	runtime.GC()
	q[0], q[1] = a, b // amd64:-`MOVUPS`
}

// ------------- //
//    Storing    //
// ------------- //

func store_le64(b []byte, x uint64) {
	// amd64:`MOVQ\s.*\(.*\)$`,-`SHR.`
	// arm64:`MOVD`,-`MOV[WBH]`

			continue
		}
		l.add("MOVL", reg, 4)
	}

	softfloat := "GO386_softfloat"

	// Save SSE state only if supported.
	lSSE := layout{stack: l.stack, sp: "SP"}
	for i := 0; i < 8; i++ {
		lSSE.add("MOVUPS", fmt.Sprintf("X%d", i), 16)
	}

	p("ADJSP $%d", lSSE.stack)
	p("NOP SP")
	l.save()
	p("#ifndef %s", softfloat)
	lSSE.save()
	p("#endif")
	p("CALL ·asyncPreempt2(SB)")
	p("#ifndef %s", softfloat)