inst_gen.go

package mimic

// Code generated by 'go run inst_gen.go | gofmt > inst.go' DO NOT EDIT

import "github.com/cilium/ebpf/asm"

func instALU32AddIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)+uint32(i.Constant)))
}

func instALU64AddIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst+uint64(i.Constant))
}

func instALU32AddReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)+uint32(src)))
}

func instALU64AddReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst+src)
}

func instALU32SubIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)-uint32(i.Constant)))
}

func instALU64SubIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst-uint64(i.Constant))
}

func instALU32SubReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)-uint32(src)))
}

func instALU64SubReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst-src)
}

func instALU32MulIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)*uint32(i.Constant)))
}

func instALU64MulIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst*uint64(i.Constant))
}

func instALU32MulReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)*uint32(src)))
}

func instALU64MulReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst*src)
}

func instALU32DivIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)/uint32(i.Constant)))
}

func instALU64DivIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst/uint64(i.Constant))
}

func instALU32DivReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)/uint32(src)))
}

func instALU64DivReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst/src)
}

func instALU32OrIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)|uint32(i.Constant)))
}

func instALU64OrIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst|uint64(i.Constant))
}

func instALU32OrReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)|uint32(src)))
}

func instALU64OrReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst|src)
}

func instALU32AndIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)&uint32(i.Constant)))
}

func instALU64AndIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst&uint64(i.Constant))
}

func instALU32AndReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)&uint32(src)))
}

func instALU64AndReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst&src)
}

func instALU32LShIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)<<uint32(i.Constant)))
}

func instALU64LShIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst<<uint64(i.Constant))
}

func instALU32LShReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)<<uint32(src)))
}

func instALU64LShReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst<<src)
}

func instALU32RShIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)>>uint32(i.Constant)))
}

func instALU64RShIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst>>uint64(i.Constant))
}

func instALU32RShReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)>>uint32(src)))
}

func instALU64RShReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst>>src)
}

func instALU32ModIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)%uint32(i.Constant)))
}

func instALU64ModIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst%uint64(i.Constant))
}

func instALU32ModReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)%uint32(src)))
}

func instALU64ModReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst%src)
}

func instALU32XorIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)^uint32(i.Constant)))
}

func instALU64XorIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	return process.Registers.Set(i.Dst, dst^uint64(i.Constant))
}

func instALU32XorReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, uint64(uint32(dst)^uint32(src)))
}

func instALU64XorReg(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	src := process.Registers.Get(i.Src)
	return process.Registers.Set(i.Dst, dst^src)
}

func instJump32JEqIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) == uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JEqIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst == uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JEqReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) == uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JEqReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst == src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JGTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) > uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JGTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst > uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JGTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) > uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JGTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst > src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JGEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) >= uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JGEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst >= uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JGEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) >= uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JGEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst >= src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JNEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) != uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JNEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst != uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JNEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) != uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JNEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst != src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSGTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int32(dst) > int32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSGTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int64(dst) > int64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSGTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int32(dst) > int32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSGTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int64(dst) > int64(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSGEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int32(dst) >= int32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSGEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int64(dst) >= int64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSGEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int32(dst) >= int32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSGEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int64(dst) >= int64(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JLTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) < uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JLTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst < uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JLTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) < uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JLTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst < src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JLEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) <= uint32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JLEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if dst <= uint64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JLEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if uint32(dst) <= uint32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JLEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if dst <= src {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSLTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int32(dst) < int32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSLTIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int64(dst) < int64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSLTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int32(dst) < int32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSLTReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int64(dst) < int64(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSLEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int32(dst) <= int32(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSLEIMM(i asm.Instruction, process *Process) error {
	dst := process.Registers.Get(i.Dst)
	if int64(dst) <= int64(i.Constant) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump32JSLEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int32(dst) <= int32(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func instJump64JSLEReg(i asm.Instruction, process *Process) error {
	src := process.Registers.Get(i.Src)
	dst := process.Registers.Get(i.Dst)
	if int64(dst) <= int64(src) {
		process.Registers.PC += int(i.Offset)
	}

	return nil
}

func initGen() {
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Add)] = instALU32AddIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Add)] = instALU64AddIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Add)|asm.OpCode(asm.RegSource)] = instALU32AddReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Add)|asm.OpCode(asm.RegSource)] = instALU64AddReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Sub)] = instALU32SubIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JEq)] = instJump64JEqIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JEq)] = instJump32JEqIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Sub)] = instALU64SubIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Sub)|asm.OpCode(asm.RegSource)] = instALU32SubReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JEq)|asm.OpCode(asm.RegSource)] = instJump64JEqReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JEq)|asm.OpCode(asm.RegSource)] = instJump32JEqReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Sub)|asm.OpCode(asm.RegSource)] = instALU64SubReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Mul)] = instALU32MulIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JGT)] = instJump64JGTIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JGT)] = instJump32JGTIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Mul)] = instALU64MulIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Mul)|asm.OpCode(asm.RegSource)] = instALU32MulReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JGT)|asm.OpCode(asm.RegSource)] = instJump64JGTReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JGT)|asm.OpCode(asm.RegSource)] = instJump32JGTReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Mul)|asm.OpCode(asm.RegSource)] = instALU64MulReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Div)] = instALU32DivIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JGE)] = instJump64JGEIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JGE)] = instJump32JGEIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Div)] = instALU64DivIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Div)|asm.OpCode(asm.RegSource)] = instALU32DivReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JGE)|asm.OpCode(asm.RegSource)] = instJump64JGEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JGE)|asm.OpCode(asm.RegSource)] = instJump32JGEReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Div)|asm.OpCode(asm.RegSource)] = instALU64DivReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Or)] = instALU32OrIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Or)] = instALU64OrIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Or)|asm.OpCode(asm.RegSource)] = instALU32OrReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Or)|asm.OpCode(asm.RegSource)] = instALU64OrReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.And)] = instALU32AndIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JNE)] = instJump64JNEIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JNE)] = instJump32JNEIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.And)] = instALU64AndIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.And)|asm.OpCode(asm.RegSource)] = instALU32AndReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JNE)|asm.OpCode(asm.RegSource)] = instJump64JNEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JNE)|asm.OpCode(asm.RegSource)] = instJump32JNEReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.And)|asm.OpCode(asm.RegSource)] = instALU64AndReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.LSh)] = instALU32LShIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSGT)] = instJump64JSGTIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JSGT)] = instJump32JSGTIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.LSh)] = instALU64LShIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.LSh)|asm.OpCode(asm.RegSource)] = instALU32LShReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JSGT)|asm.OpCode(asm.RegSource)] = instJump64JSGTReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSGT)|asm.OpCode(asm.RegSource)] = instJump32JSGTReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.LSh)|asm.OpCode(asm.RegSource)] = instALU64LShReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.RSh)] = instALU32RShIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSGE)] = instJump64JSGEIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JSGE)] = instJump32JSGEIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.RSh)] = instALU64RShIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.RSh)|asm.OpCode(asm.RegSource)] = instALU32RShReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JSGE)|asm.OpCode(asm.RegSource)] = instJump64JSGEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSGE)|asm.OpCode(asm.RegSource)] = instJump32JSGEReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.RSh)|asm.OpCode(asm.RegSource)] = instALU64RShReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Mod)] = instALU32ModIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Mod)] = instALU64ModIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Mod)|asm.OpCode(asm.RegSource)] = instALU32ModReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Mod)|asm.OpCode(asm.RegSource)] = instALU64ModReg
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Xor)] = instALU32XorIMM
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JLT)] = instJump64JLTIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JLT)] = instJump32JLTIMM
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Xor)] = instALU64XorIMM
	instructions[asm.OpCode(asm.ALUClass).SetALUOp(asm.Xor)|asm.OpCode(asm.RegSource)] = instALU32XorReg
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JLT)|asm.OpCode(asm.RegSource)] = instJump64JLTReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JLT)|asm.OpCode(asm.RegSource)] = instJump32JLTReg
	instructions[asm.OpCode(asm.ALU64Class).SetALUOp(asm.Xor)|asm.OpCode(asm.RegSource)] = instALU64XorReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JLE)] = instJump64JLEIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JLE)] = instJump32JLEIMM
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JLE)|asm.OpCode(asm.RegSource)] = instJump64JLEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JLE)|asm.OpCode(asm.RegSource)] = instJump32JLEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSLT)] = instJump64JSLTIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JSLT)] = instJump32JSLTIMM
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JSLT)|asm.OpCode(asm.RegSource)] = instJump64JSLTReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSLT)|asm.OpCode(asm.RegSource)] = instJump32JSLTReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSLE)] = instJump64JSLEIMM
	instructions[asm.OpCode(asm.Jump32Class).SetJumpOp(asm.JSLE)] = instJump32JSLEIMM
	instructions[asm.OpCode(asm.ALU64Class).SetJumpOp(asm.JSLE)|asm.OpCode(asm.RegSource)] = instJump64JSLEReg
	instructions[asm.OpCode(asm.JumpClass).SetJumpOp(asm.JSLE)|asm.OpCode(asm.RegSource)] = instJump32JSLEReg
}