[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
	{VMRGOW, 0xfc0007ff00000000, 0x1000068c00000000, 0x0, // Vector Merge Odd Word VX-form (vmrgow VRT,VRA,VRB)
		[6]*argField{ap_VecReg_6_10, ap_VecReg_11_15, ap_VecReg_16_20}},
	{VMULESW, 0xfc0007ff00000000, 0x1000038800000000, 0x0, // Vector Multiply Even Signed Word VX-form (vmulesw VRT,VRA,VRB)

	MOVD  8(R8), R11
	MOVD  8(R9), R16
	SUBE  R16, R11, R20
	MOVD  R20, 8(R10)

final:
	ADDZE R4
	XOR   $1, R4

done:
	MOVD  R4, c+72(FP)
	RET

// func addVW(z, x []Word, y Word) (c Word)
TEXT ·addVW(SB), NOSPLIT, $0
	MOVD z+0(FP), R10	// R10 = z[]
	MOVD x+24(FP), R8	// R8 = x[]
	MOVD y+48(FP), R4	// R4 = y = c
	MOVD z_len+8(FP), R11	// R11 = z_len

labels.suggest_word_configuration=Suggest Word
labels.suggest_word_title_details=Suggest Word
labels.suggest_word_type=Word Type
labels.suggest_word_number=Word Count
labels.suggest_word_type_all=All
labels.suggest_word_type_document=Document
labels.suggest_word_type_query=Query
labels.elevate_word_configuration=Additional Word
labels.elevate_word_title_details=Additional Word
labels.elevate_word_link_list=List

	"strings"
)

// A BitField is a bit-field in a 32-bit word.
// Bits are counted from 0 from the MSB to 31 as the LSB.
type BitField struct {
	Offs uint8 // the offset of the left-most bit.
	Bits uint8 // length in bits.
	// This instruction word holding this field.
	// It is always 0 for ISA < 3.1 instructions. It is
	// in decoding order. (0 == prefix, 1 == suffix on ISA 3.1)
	Word uint8
}

func (b BitField) String() string {

	$              at end of text (like \z not \Z) or line (flag m=true)
	\A             at beginning of text
	\b             at ASCII word boundary (\w on one side and \W, \A, or \z on the other)
	\B             not at ASCII word boundary
	\z             at end of text

Escape sequences:

	\a             bell (== \007)
	\f             form feed (== \014)
	\t             horizontal tab (== \011)

	word := uint32(v) << ((uaddr & 3) * 8) // little endian
	for {
		old := *addr32
		if Cas(addr32, old, old|word) {
			return
		}
	}
}

//go:nosplit
func And8(addr *uint8, v uint8) {
	// Align down to 4 bytes and use 32-bit CAS.
	uaddr := uintptr(unsafe.Pointer(addr))
	addr32 := (*uint32)(unsafe.Pointer(uaddr &^ 3))
	word := uint32(v) << ((uaddr & 3) * 8)    // little endian

	short = flag.Bool("short", false, "only print first 10 digits of result")
)

// A large natural number is represented by a nat, each "digit" is
// a big.Word; the value zero corresponds to the empty nat slice.
type nat []big.Word

const W = 1 << (5 + ^big.Word(0)>>63) // big.Word size in bits

// The following methods are extracted from math/big to make this a
// stand-alone program that can easily be run without dependencies

package windows

/*
#include <windows.h>

DWORD agetthread() {
	return GetCurrentThreadId();
}
*/
import "C"

func GetThread() uint32 {
	return uint32(C.agetthread())

	MOVD	$·acoshrodataL11<>+0(SB), R9
	LGDR	F0, R1
	WORD	$0xC0295FEF	//iilf	%r2,1609564159
	BYTE	$0xFF
	BYTE	$0xFF
	SRAD	$32, R1
	CMPW	R1, R2
	BGT	L2
	WORD	$0xC0293FEF	//iilf	%r2,1072693247
	BYTE	$0xFF
	BYTE	$0xFF
	CMPW	R1, R2
	BGT	L10
L3:
	WFCEDBS	V0, V0, V2
	BVS	L1
	FMOVD	112(R9), F0
L1:
	FMOVD	F0, ret+8(FP)
	RET
L2:
	WORD	$0xC0297FEF	//iilf	%r2,2146435071
	BYTE	$0xFF
	BYTE	$0xFF

	`[:punct:]`:   {+1, code13},
	`[:^punct:]`:  {-1, code13},
	`[:space:]`:   {+1, code14},
	`[:^space:]`:  {-1, code14},
	`[:upper:]`:   {+1, code15},
	`[:^upper:]`:  {-1, code15},
	`[:word:]`:    {+1, code16},
	`[:^word:]`:   {-1, code16},
	`[:xdigit:]`:  {+1, code17},
	`[:^xdigit:]`: {-1, code17},