func (op MI16) MemDispImm(text *code.Buf, _ wa.Type, base BaseReg, disp int32, val16 int64) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byte(0x66)
	o.rexIf(regRexB(reg.R(base)))
	o.byte(byte(op >> 8))
	o.mod(mod, ModRO(op), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.int16(int16(val16))
	o.copy(text.Extend(o.len()))
}
MemDispImm ignores the type argument.
package in
import (
	"encoding/binary"
	"gate.computer/wag/internal/code"
	"gate.computer/wag/internal/gen/reg"
	"gate.computer/wag/wa"
)
var nops = [4][4]byte{
	1: {0x90},
	2: {0x66, 0x90},
	3: {0x0f, 0x1f, 0x00},
}
func typeScalarPrefix(t wa.Type) byte { return byte(t)>>2 | 0xf2 }  
func typeRMISizeCode(t wa.Type) byte  { return byte(t)>>3 | 0x0a }  
func addrDisp(currentAddr, insnSize, targetAddr int32) int32 {
	if targetAddr != 0 {
		siteAddr := currentAddr + insnSize
		return targetAddr - siteAddr
	} else {
		return -insnSize  
	}
}
type output struct {
	buf    [16]byte
	offset uint32
}
func (o output) len() int           { return int(o.offset) }
func (o output) copy(target []byte) { copy(target, o.buf[:]) }
func (o output) debugPrint()        { debugPrintInsn(o.buf[:o.offset]) }
func (o *output) byte(b byte) {
	o.buf[o.offset] = b
	o.offset++
}
func (o *output) byteIf(b byte, condition bool) {
	o.buf[o.offset] = b
	o.offset += bit(condition)
}
func (o *output) word(w uint16) {
	binary.BigEndian.PutUint16(o.buf[o.offset:], w)
	o.offset += 2
}
func (o *output) rex(wrxb rexWRXB) {
	o.buf[o.offset] = Rex | byte(wrxb)
	o.offset++
}
func (o *output) rexIf(wrxb rexWRXB) {
	o.buf[o.offset] = Rex | byte(wrxb)
	o.offset += bit(wrxb != 0)
}
func (o *output) mod(mod Mod, ro ModRO, rm ModRM) {
	o.buf[o.offset] = byte(mod) | byte(ro) | byte(rm)
	o.offset++
}
func (o *output) sib(s Scale, i Index, b Base) {
	o.buf[o.offset] = byte(s) | byte(i) | byte(b)
	o.offset++
}
func (o *output) int8(val int8) {
	o.buf[o.offset] = uint8(val)
	o.offset++
}
func (o *output) int16(val int16) {
	binary.LittleEndian.PutUint16(o.buf[o.offset:], uint16(val))
	o.offset += 2
}
func (o *output) int32(val int32) {
	binary.LittleEndian.PutUint32(o.buf[o.offset:], uint32(val))
	o.offset += 4
}
func (o *output) int64(val int64) {
	binary.LittleEndian.PutUint64(o.buf[o.offset:], uint64(val))
	o.offset += 8
}
func (o *output) int(val int32, size uint32) {
	binary.LittleEndian.PutUint32(o.buf[o.offset:], uint32(val))
	o.offset += size
}
type NP byte
func (op NP) Type(text *code.Buf, t wa.Type) {
	var o output
	o.rexIf(typeRexW(t))
	o.byte(byte(op))
	o.copy(text.Extend(o.len()))
}
func (op NP) Simple(text *code.Buf) {
	text.PutByte(byte(op))
}
type NPprefix byte
func (op NPprefix) Simple(text *code.Buf) {
	var o output
	o.byte(0xf3)
	o.byte(byte(op))
	o.copy(text.Extend(o.len()))
}
type O byte
func (op O) RegResult(text *code.Buf)  { text.PutByte(byte(op) + byte(RegResult)) }
func (op O) RegScratch(text *code.Buf) { text.PutByte(byte(op) + byte(RegScratch)) }
func (op O) RegZero(text *code.Buf)    { text.PutByte(byte(op) + byte(RegZero)) }
type M uint16  
func (op M) Reg(text *code.Buf, t wa.Type, r reg.R) {
	var o output
	o.rexIf(typeRexW(t) | regRexB(r))
	o.byte(byte(op >> 8))
	o.mod(ModReg, ModRO(op), regRM(r))
	o.copy(text.Extend(o.len()))
}
type Mex2 uint16  
func (op Mex2) OneSizeReg(text *code.Buf, r reg.R) {
	var o output
	o.rex(regRexB(r))
	o.word(uint16(op))
	o.mod(ModReg, 0, regRM(r))
	o.copy(text.Extend(o.len()))
}
type RM byte     
type RM2 uint16  
func (op RM) RegReg(text *code.Buf, t wa.Type, r, r2 reg.R) {
	var o output
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(r2))
	o.byte(byte(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RM2) RegReg(text *code.Buf, t wa.Type, r, r2 reg.R) {
	var o output
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(r2))
	o.word(uint16(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RM) RegMemDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(reg.R(base)))
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RM2) RegMemDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(reg.R(base)))
	o.word(uint16(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RM) RegMemIndexDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, index reg.R, s Scale, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t) | regRexR(r) | regRexX(index) | regRexB(reg.R(base)))
	o.byte(byte(op))
	o.mod(mod, regRO(r), ModRMSIB)
	o.sib(s, regIndex(index), regBase(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RM2) RegStack(text *code.Buf, t wa.Type, r reg.R) {
	var o output
	o.rexIf(typeRexW(t) | regRexR(r))
	o.word(uint16(op))
	o.mod(ModMem, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.copy(text.Extend(o.len()))
}
func (op RM) RegStackDisp(text *code.Buf, t wa.Type, r reg.R, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t) | regRexR(r))
	o.byte(byte(op))
	o.mod(mod, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RM2) RegStackDisp(text *code.Buf, t wa.Type, r reg.R, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t) | regRexR(r))
	o.word(uint16(op))
	o.mod(mod, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RM) RegStackDisp8(text *code.Buf, t wa.Type, r reg.R, disp int8) {
	var o output
	o.rexIf(typeRexW(t) | regRexR(r))
	o.byte(byte(op))
	o.mod(ModMemDisp8, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int8(disp)
	o.copy(text.Extend(o.len()))
}
func (op RM) RegStackStub32(text *code.Buf, t wa.Type, r reg.R) int32 {
	var o output
	o.rexIf(typeRexW(t) | regRexR(r))
	o.byte(byte(op))
	o.mod(ModMemDisp32, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int32(-0x80000000)  
	o.copy(text.Extend(o.len()))
	return text.Addr
}
type RMprefix uint16  
type RMscalar byte    
type RMpacked byte    
func (op RMprefix) RegReg(text *code.Buf, t wa.Type, r, r2 reg.R) {
	var o output
	o.byte(byte(op >> 8))
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(r2))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RMscalar) RegReg(text *code.Buf, t wa.Type, r, r2 reg.R) {
	var o output
	o.byte(typeScalarPrefix(t))
	o.rexIf(regRexR(r) | regRexB(r2))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RMpacked) RegReg(text *code.Buf, t wa.Type, r, r2 reg.R) {
	var o output
	o.byteIf(0x66, t&8 == 8)
	o.rexIf(regRexR(r) | regRexB(r2))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RMscalar) TypeRegReg(text *code.Buf, floatType, intType wa.Type, r, r2 reg.R) {
	var o output
	o.byte(typeScalarPrefix(floatType))
	o.rexIf(typeRexW(intType) | regRexR(r) | regRexB(r2))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(ModReg, regRO(r), regRM(r2))
	o.copy(text.Extend(o.len()))
}
func (op RMprefix) RegMemDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byte(byte(op >> 8))
	o.rexIf(typeRexW(t) | regRexR(r) | regRexB(reg.R(base)))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RMscalar) RegMemDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byte(typeScalarPrefix(t))
	o.rexIf(regRexR(r) | regRexB(reg.R(base)))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RMpacked) RegMemDisp(text *code.Buf, t wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byteIf(0x66, t&8 == 8)
	o.rexIf(regRexR(r) | regRexB(reg.R(base)))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
func (op RMprefix) RegStack(text *code.Buf, t wa.Type, r reg.R) {
	var o output
	o.byte(byte(op >> 8))
	o.rexIf(typeRexW(t) | regRexR(r))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(ModMem, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.copy(text.Extend(o.len()))
}
func (op RMprefix) RegStackDisp(text *code.Buf, t wa.Type, r reg.R, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byte(byte(op >> 8))
	o.rexIf(typeRexW(t) | regRexR(r))
	o.byte(0x0f)
	o.byte(byte(op))
	o.mod(mod, regRO(r), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
type RMdata8 byte  
func (op RMdata8) RegRegStackLimit(text *code.Buf) {
	var o output
	o.byte(byte(op))
	o.mod(ModReg, regRO(RegStackLimit), regRM(RegStackLimit))
	o.copy(text.Extend(o.len()))
}
func (op RMdata8) RegMemDisp(text *code.Buf, _ wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rex(regRexR(r) | regRexB(reg.R(base)))
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
type RMdata16 byte  
func (op RMdata16) RegMemDisp(text *code.Buf, _ wa.Type, r reg.R, base BaseReg, disp int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.byte(0x66)
	o.rexIf(regRexR(r) | regRexB(reg.R(base)))
	o.byte(byte(op))
	o.mod(mod, regRO(r), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.copy(text.Extend(o.len()))
}
type Ipush byte  
func (op Ipush) Imm(text *code.Buf, val int32) {
	var valSize = immSize(val)
	var o output
	o.byte(byte(op) &^ byte(valSize>>1))  
	o.int(val, valSize)
	o.copy(text.Extend(o.len()))
}
type OI byte
func (op OI) RegImm64(text *code.Buf, r reg.R, val int64) {
	var o output
	o.rex(RexW | regRexB(r))
	o.byte(byte(op) + byte(r)&7)
	o.int64(val)
	o.copy(text.Extend(o.len()))
}
type MI uint32  
func (ops MI) RegImm(text *code.Buf, t wa.Type, r reg.R, val int32) {
	var op, valSize = immOpcodeSize(uint16(ops>>8), val)
	var o output
	o.rexIf(typeRexW(t) | regRexB(r))
	o.byte(op)
	o.mod(ModReg, ModRO(ops), regRM(r))
	o.int(val, valSize)
	o.copy(text.Extend(o.len()))
}
func (op MI) RegImm8(text *code.Buf, t wa.Type, r reg.R, val int8) {
	var o output
	o.rexIf(typeRexW(t) | regRexB(r))
	o.byte(byte(op >> 8))
	o.mod(ModReg, ModRO(op), regRM(r))
	o.int8(val)
	o.copy(text.Extend(o.len()))
}
func (op MI) RegImm32(text *code.Buf, t wa.Type, r reg.R, val int32) {
	var o output
	o.rexIf(typeRexW(t) | regRexB(r))
	o.byte(byte(op >> 16))
	o.mod(ModReg, ModRO(op), regRM(r))
	o.int32(val)
	o.copy(text.Extend(o.len()))
}
func (op MI) StackImm8(text *code.Buf, t wa.Type, val int8) {
	var o output
	o.rexIf(typeRexW(t))
	o.byte(byte(op >> 8))
	o.mod(ModMem, ModRO(op), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int8(val)
	o.copy(text.Extend(o.len()))
}
func (op MI) StackDispImm32(text *code.Buf, t wa.Type, disp, val int32) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(typeRexW(t))
	o.byte(byte(op >> 16))
	o.mod(mod, ModRO(op), ModRMSIB)
	o.sib(Scale0, noIndex, baseStack)
	o.int(disp, dispSize)
	o.int32(val)
	o.copy(text.Extend(o.len()))
}
type MI8 uint16  
func (op MI8) MemDispImm(text *code.Buf, _ wa.Type, base BaseReg, disp int32, val8 int64) {
	var mod, dispSize = dispModSize(disp)
	var o output
	o.rexIf(regRexB(reg.R(base)))
	o.byte(byte(op >> 8))
	o.mod(mod, ModRO(op), regRM(reg.R(base)))
	o.int(disp, dispSize)
	o.int8(int8(val8))
	o.copy(text.Extend(o.len()))
}
type MI16 uint16  