"ADDW",
	"DIVW",
	"DIVWU",
	"DIVD",
	"DIVDU",
	"MODW",
	"MODWU",
	"MODD",
	"MODDU",
	"MULLW",
	"MULLD",
	"MULHD",
	"MULHDU",
	"MLGR",
	"SUB",
	"SUBC",
	"SUBV",
	"SUBE",
	"SUBW",
	"NEG",
	"NEGW",
	"MOVWBR",
	"MOVB",
	"MOVBZ",
	"MOVH",
	"MOVHBR",
	"MOVHZ",
	"MOVW",
	"MOVWZ",
	"MOVD",
	"MOVDBR",
	"MOVDEQ",
	"MOVDGE",
	"MOVDGT",
	"MOVDLE",
	"MOVDLT",

	MOVB    runtime·goarmsoftfp(SB), R11
	CMP     $0, R11
	BNE     skipfpsave
	MOVD	F8, (13*4+8*1)(R13)
	MOVD	F9, (13*4+8*2)(R13)
	MOVD	F10, (13*4+8*3)(R13)
	MOVD	F11, (13*4+8*4)(R13)
	MOVD	F12, (13*4+8*5)(R13)
	MOVD	F13, (13*4+8*6)(R13)
	MOVD	F14, (13*4+8*7)(R13)
	MOVD	F15, (13*4+8*8)(R13)

skipfpsave:
	BL	runtime·load_g(SB)

posInfGeZero:	// Pow(+Inf, y) = +Inf for y > 0
	MOVD	R1, ret+16(FP)
	RET
yIsNan:			//  Pow(NaN, y) = NaN
ltZeroInt:		// Pow(x, y) = NaN for finite x < 0 and finite non-integer y
	MOVD	$NaN, R2
	MOVD	R2, ret+16(FP)
	RET
negOnePosInf:	// Pow(-1, ±Inf) = 1
negOneNegInf:
	MOVD	$PosOne, R3
	MOVD	R3, ret+16(FP)
	RET
negZeroOddInt:
	MOVD	$NegInf, R3
	MOVD	R3, ret+16(FP)
	RET

	MOVD len+56(FP), LEN

	MOVD   $0x10, R8
	MOVD   $0x20, R9
	MOVD   $0x30, R10
	LXVD2X (XIP)(R0), VXL // load Xi

	LXVD2X   (HTBL)(R8), VHL    // load pre-computed table
	MOVD     $0x40, R8
	LXVD2X   (HTBL)(R9), VH
	MOVD     $0x50, R9
	LXVD2X   (HTBL)(R10), VHH
	MOVD     $0x60, R10
	LXVD2X   (HTBL)(R0), VXC2
#ifdef GOARCH_ppc64le
	LVSL     (R0)(R0), LEMASK
	VSPLTISB $0x07, T0

					good := dir + "/execabs-test"
					if found, err := LookPath(good); err != nil || !strings.HasPrefix(found, good) {
						t.Fatalf(`LookPath(%#q) = %#q, %v, want "%s...", nil`, good, found, err, good)
					}
					if runtime.GOOS == "windows" {
						good = dir + `\execabs-test`
						if found, err := LookPath(good); err != nil || !strings.HasPrefix(found, good) {

//go:build (ppc64 || ppc64le) && !purego

#include "textflag.h"

// func xorBytes(dst, a, b *byte, n int)
TEXT ·xorBytes(SB), NOSPLIT, $0
	MOVD	dst+0(FP), R3	// R3 = dst
	MOVD	a+8(FP), R4	// R4 = a
	MOVD	b+16(FP), R5	// R5 = b
	MOVD	n+24(FP), R6	// R6 = n

	CMPU	R6, $64, CR7	// Check if n ≥ 64 bytes
	MOVD	R0, R8		// R8 = index
	CMPU	R6, $8, CR6	// Check if 8 ≤ n < 64 bytes
	BLE	CR6, small	// <= 8
	BLT	CR7, xor32	// Case for 32 ≤ n < 64 bytes

#include "textflag.h"
#include "time_windows.h"

TEXT time·now(SB),NOSPLIT,$0-24
	MOVD	$_INTERRUPT_TIME, R3
	MOVD	time_lo(R3), R0
	MOVD	$100, R1
	MUL	R1, R0
	MOVD	R0, mono+16(FP)

	MOVD	$_SYSTEM_TIME, R3
	MOVD	time_lo(R3), R0
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUB	$delta, R0
	// Convert to nSec
	MOVD	$100, R1
	MUL	R1, R0

	// Code stolen from compiler output for:
	//

	WFMSDB  V0, V6, V4, V6
	MOVD    $sinhe9<>+0(SB), R2
	WFMADB  V0, V3, V6, V0
	FMOVD   0(R2), F1
	MOVD    $sinhe7<>+0(SB), R2
	WFMDB   V0, V0, V6
	FMOVD   0(R2), F5
	MOVD    $sinhe8<>+0(SB), R2
	FMOVD   0(R2), F3
	MOVD    $sinhe6<>+0(SB), R2
	WFMADB  V6, V1, V5, V1
	FMOVD   0(R2), F5
	MOVD    $sinhe5<>+0(SB), R2
	FMOVD   0(R2), F7
	MOVD    $sinhe3<>+0(SB), R2
	WFMADB  V6, V3, V5, V3

	switch ext {
	// amd64: `CMPL\s\(.*\), \$1836345390$`
	// arm64: `MOVD\s\$1836345390`, `CMPW\sR.*, R.*$`
	case ".htm":
		return "A"
	// amd64: `CMPL\s\(.*\), \$1953457454$`
	// arm64: `MOVD\s\$1953457454`, `CMPW\sR.*, R.*$`
	case ".eot":
		return "B"
	// amd64: `CMPL\s\(.*\), \$1735815982$`
	// arm64: `MOVD\s\$1735815982`, `CMPW\sR.*, R.*$`
	case ".svg":
		return "C"

		return false
	}
	return true
}

func main() {
	good := true
	// http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
	good = good && check("2.2250738585072012e-308", 2.2250738585072012e-308, 2.2250738585072014e-308)
	// http://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
	good = good && check("2.2250738585072011e-308", 2.2250738585072011e-308, 2.225073858507201e-308)