// final executable starts, during the C runtime initialization
// phase.
TEXT _rt0_386_windows_lib(SB),NOSPLIT,$0x1C
	MOVL	BP, 0x08(SP)
	MOVL	BX, 0x0C(SP)
	MOVL	AX, 0x10(SP)
	MOVL  CX, 0x14(SP)
	MOVL  DX, 0x18(SP)

	// Create a new thread to do the runtime initialization and return.
	MOVL	_cgo_sys_thread_create(SB), AX
	MOVL	$_rt0_386_windows_lib_go(SB), 0x00(SP)
	MOVL	$0, 0x04(SP)

	VPSHUFBITQMB 15(DX)(BX*2), X7, K6, K0              // 62f2450e8f845a0f000000
	VPSHUFBITQMB X24, X13, K6, K0                      // 6292150e8fc0
	VPSHUFBITQMB X7, X13, K6, K0                       // 62f2150e8fc7
	VPSHUFBITQMB X0, X13, K6, K0                       // 62f2150e8fc0
	VPSHUFBITQMB (R8), X13, K6, K0                     // 62d2150e8f00
	VPSHUFBITQMB 15(DX)(BX*2), X13, K6, K0             // 62f2150e8f845a0f000000

	VPERMB -7(CX)(DX*8), Y31, K7, Y22                  // 62e205278db4d1f9ffffff
	VPERMB Y5, Y5, K7, Y22                             // 62e2552f8df5
	VPERMB Y19, Y5, K7, Y22                            // 62a2552f8df3
	VPERMB Y31, Y5, K7, Y22                            // 6282552f8df7
	VPERMB 17(SP)(BP*1), Y5, K7, Y22                   // 62e2552f8db42c11000000

// callerStartLine since it is in a different package.

TEXT	·AsmFunc<ABIInternal>(SB),NOSPLIT,$8-0
	NO_LOCAL_POINTERS
	MOVQ	$0, AX // wantInlined
	MOVQ	·CallerStartLine(SB), DX
	CALL	(DX)

	bw := blockWriter{e: e}
	bw.setup()
	lzww := lzw.NewWriter(bw, lzw.LSB, litWidth)
	if dx := b.Dx(); dx == pm.Stride {
		_, e.err = lzww.Write(pm.Pix[:dx*b.Dy()])
		if e.err != nil {
			lzww.Close()
			return
		}
	} else {
		for i, y := 0, b.Min.Y; y < b.Max.Y; i, y = i+pm.Stride, y+1 {
			_, e.err = lzww.Write(pm.Pix[i : i+dx])
			if e.err != nil {
				lzww.Close()
				return
			}
		}
	}

func F(a, b, c int, d S) {
	// -2401018187971961171 is 0xdeaddeaddeaddead
	// amd64:`MOVQ\t\$-2401018187971961171, AX`, `MOVQ\t\$-2401018187971961171, BX`, `MOVQ\t\$-2401018187971961171, CX`
	// amd64:`MOVQ\t\$-2401018187971961171, DX`, `MOVQ\t\$-2401018187971961171, SI`, `MOVQ\t\$-2401018187971961171, DI`
	// amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10`

// See the comment on the declaration of makeFuncStub in makefunc.go
// for more details.
// No argsize here, gc generates argsize info at call site.
TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
	NO_LOCAL_POINTERS
	MOVL	DX, 0(SP)
	LEAL	argframe+0(FP), CX
	MOVL	CX, 4(SP)
	MOVB	$0, 16(SP)
	LEAL	16(SP), AX
	MOVL	AX, 8(SP)
	MOVL	$0, 12(SP)
	CALL	·callReflect(SB)
	RET

	MOVL crcA+0(FP), AX
	MOVL crcB+4(FP), CX
	MOVL crcC+8(FP), DX

	MOVQ a+16(FP), R8   // data pointer
	MOVQ b+40(FP), R9   // data pointer
	MOVQ c+64(FP), R10  // data pointer

	MOVL rounds+88(FP), R11

loop:
	CRC32Q (R8), AX
	CRC32Q (R9), CX
	CRC32Q (R10), DX

	CRC32Q 8(R8), AX
	CRC32Q 8(R9), CX
	CRC32Q 8(R10), DX

	CRC32Q 16(R8), AX
	CRC32Q 16(R9), CX
	CRC32Q 16(R10), DX

// func Exp(x float64) float64
TEXT ·archExp(SB),NOSPLIT,$0
	// test bits for not-finite
	MOVQ    x+0(FP), BX
	MOVQ    $~(1<<63), AX // sign bit mask
	MOVQ    BX, DX
	ANDQ    AX, DX
	MOVQ    $PosInf, AX
	CMPQ    AX, DX
	JLE     notFinite
	// check if argument will overflow
	MOVQ    BX, X0
	MOVSD   $Overflow, X1
	COMISD  X1, X0
	JA      overflow
	MOVSD   $LOG2E, X1
	MULSD   X0, X1

	PUSHFQ
	// obj doesn't understand ADD/SUB on SP, but does understand ADJSP
	ADJSP $368
	// But vet doesn't know ADJSP, so suppress vet stack checking
	NOP SP
	MOVQ AX, 0(SP)
	MOVQ CX, 8(SP)
	MOVQ DX, 16(SP)
	MOVQ BX, 24(SP)
	MOVQ SI, 32(SP)
	MOVQ DI, 40(SP)
	MOVQ R8, 48(SP)
	MOVQ R9, 56(SP)
	MOVQ R10, 64(SP)
	MOVQ R11, 72(SP)
	MOVQ R12, 80(SP)
	MOVQ R13, 88(SP)
	MOVQ R14, 96(SP)
	MOVQ R15, 104(SP)