diff --git a/src/arm/Registers.go b/src/arm/Registers.go
index 9e54156..884816a 100644
--- a/src/arm/Registers.go
+++ b/src/arm/Registers.go
@@ -44,20 +44,16 @@ const (
 )
 
 var (
-	GeneralRegisters       = []cpu.Register{X9, X10, X11, X12, X13, X14, X15, X16, X17, X19, X20, X21, X22, X23, X24, X25, X26}
 	InputRegisters         = []cpu.Register{X0, X1, X2, X3, X4, X5}
-	OutputRegisters        = InputRegisters
-	SyscallInputRegisters  = []cpu.Register{X8, X0, X1, X2, X3, X4, X5}
-	SyscallOutputRegisters = []cpu.Register{X0, X1}
 	WindowsInputRegisters  = []cpu.Register{X0, X1, X2, X3, X4, X5, X6, X7}
 	WindowsOutputRegisters = []cpu.Register{X0, X1}
 
 	CPU = cpu.CPU{
-		General:       GeneralRegisters,
+		General:       []cpu.Register{X9, X10, X11, X12, X13, X14, X15, X16, X17, X19, X20, X21, X22, X23, X24, X25, X26},
 		Input:         InputRegisters,
-		Output:        OutputRegisters,
-		SyscallInput:  SyscallInputRegisters,
-		SyscallOutput: SyscallOutputRegisters,
+		Output:        InputRegisters,
+		SyscallInput:  []cpu.Register{X8, X0, X1, X2, X3, X4, X5},
+		SyscallOutput: []cpu.Register{X0, X1},
 		NumRegisters:  32,
 	}
 )
diff --git a/src/arm/Registers_test.go b/src/arm/Registers_test.go
index 50cdae9..d5c9755 100644
--- a/src/arm/Registers_test.go
+++ b/src/arm/Registers_test.go
@@ -8,5 +8,5 @@ import (
 )
 
 func TestRegisters(t *testing.T) {
-	assert.NotNil(t, arm.SyscallInputRegisters)
+	assert.NotContains(t, arm.CPU.General, arm.SP)
 }
diff --git a/src/asmc/x86Compiler.go b/src/asmc/x86Compiler.go
index b721039..b09e1d2 100644
--- a/src/asmc/x86Compiler.go
+++ b/src/asmc/x86Compiler.go
@@ -241,29 +241,29 @@ func (c *x86Compiler) handleDivInstruction(instruction asm.Instruction) {
 	case asm.TypeRegisterNumber:
 		operands := c.assembler.Param.RegisterNumber[instruction.Index]
 
-		if operands.Register != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Register)
+		if operands.Register != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Register)
 		}
 
 		c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number)
-		c.code = x86.ExtendRAXToRDX(c.code)
+		c.code = x86.ExtendR0ToR2(c.code)
 		c.code = x86.DivRegister(c.code, x86.TMP)
 
-		if operands.Register != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.RAX)
+		if operands.Register != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.R0)
 		}
 	case asm.TypeRegisterRegister:
 		operands := c.assembler.Param.RegisterRegister[instruction.Index]
 
-		if operands.Destination != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Destination)
+		if operands.Destination != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Destination)
 		}
 
-		c.code = x86.ExtendRAXToRDX(c.code)
+		c.code = x86.ExtendR0ToR2(c.code)
 		c.code = x86.DivRegister(c.code, operands.Source)
 
-		if operands.Destination != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.RAX)
+		if operands.Destination != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.R0)
 		}
 	}
 }
@@ -273,29 +273,29 @@ func (c *x86Compiler) handleModuloInstruction(instruction asm.Instruction) {
 	case asm.TypeRegisterNumber:
 		operands := c.assembler.Param.RegisterNumber[instruction.Index]
 
-		if operands.Register != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Register)
+		if operands.Register != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Register)
 		}
 
 		c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number)
-		c.code = x86.ExtendRAXToRDX(c.code)
+		c.code = x86.ExtendR0ToR2(c.code)
 		c.code = x86.DivRegister(c.code, x86.TMP)
 
-		if operands.Register != x86.RDX {
-			c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.RDX)
+		if operands.Register != x86.R2 {
+			c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.R2)
 		}
 	case asm.TypeRegisterRegister:
 		operands := c.assembler.Param.RegisterRegister[instruction.Index]
 
-		if operands.Destination != x86.RAX {
-			c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Destination)
+		if operands.Destination != x86.R0 {
+			c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Destination)
 		}
 
-		c.code = x86.ExtendRAXToRDX(c.code)
+		c.code = x86.ExtendR0ToR2(c.code)
 		c.code = x86.DivRegister(c.code, operands.Source)
 
-		if operands.Destination != x86.RDX {
-			c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.RDX)
+		if operands.Destination != x86.R2 {
+			c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.R2)
 		}
 	}
 }
diff --git a/src/core/CallExtern.go b/src/core/CallExtern.go
index 241c15a..2adc153 100644
--- a/src/core/CallExtern.go
+++ b/src/core/CallExtern.go
@@ -30,15 +30,15 @@ func (f *Function) CallExtern(fn *Function, parameters []*expression.Expression)
 		return nil, err
 	}
 
-	f.Register(asm.PUSH, x86.RBP)
-	f.RegisterRegister(asm.MOVE, x86.RBP, x86.RSP)
-	f.RegisterNumber(asm.AND, x86.RSP, -16)
+	f.Register(asm.PUSH, x86.R5)
+	f.RegisterRegister(asm.MOVE, x86.R5, x86.SP)
+	f.RegisterNumber(asm.AND, x86.SP, -16)
 	f.Number(asm.PUSH, 0)
 	f.Number(asm.PUSH, 0)
-	f.RegisterNumber(asm.SUB, x86.RSP, 32)
+	f.RegisterNumber(asm.SUB, x86.SP, 32)
 	f.DLLCall(fn.UniqueName)
-	f.RegisterRegister(asm.MOVE, x86.RSP, x86.RBP)
-	f.Register(asm.POP, x86.RBP)
+	f.RegisterRegister(asm.MOVE, x86.SP, x86.R5)
+	f.Register(asm.POP, x86.R5)
 
 	for _, register := range registers {
 		f.FreeRegister(register)
diff --git a/src/core/CompileAssignDivision.go b/src/core/CompileAssignDivision.go
index 3d4ab0e..59fa074 100644
--- a/src/core/CompileAssignDivision.go
+++ b/src/core/CompileAssignDivision.go
@@ -76,9 +76,9 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
 
 	switch dividend := dividend.(type) {
 	case *eval.Number:
-		f.SaveRegister(x86.RAX)
-		f.RegisterNumber(asm.MOVE, x86.RAX, dividend.Number)
-		err = f.Execute(division.Token, x86.RAX, divisor)
+		f.SaveRegister(x86.R0)
+		f.RegisterNumber(asm.MOVE, x86.R0, dividend.Number)
+		err = f.Execute(division.Token, x86.R0, divisor)
 	case *eval.Register:
 		if dividend.Register != quotientVariable.Value.Register && dividend.IsAlive() {
 			tmp := f.NewRegister()
@@ -92,7 +92,7 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
 		panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, dividend))
 	}
 
-	f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.RAX)
-	f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.RDX)
+	f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.R0)
+	f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.R2)
 	return err
 }
diff --git a/src/core/ExecuteRegisterNumber.go b/src/core/ExecuteRegisterNumber.go
index bd79684..5294e82 100644
--- a/src/core/ExecuteRegisterNumber.go
+++ b/src/core/ExecuteRegisterNumber.go
@@ -27,14 +27,14 @@ func (f *Function) ExecuteRegisterNumber(operation token.Token, register cpu.Reg
 
 	case token.Div, token.DivAssign:
 		if config.TargetArch == config.X86 {
-			f.SaveRegister(x86.RDX)
+			f.SaveRegister(x86.R2)
 		}
 
 		f.RegisterNumber(asm.DIV, register, number)
 
 	case token.Mod, token.ModAssign:
 		if config.TargetArch == config.X86 {
-			f.SaveRegister(x86.RDX)
+			f.SaveRegister(x86.R2)
 		}
 
 		f.RegisterNumber(asm.MODULO, register, number)
diff --git a/src/core/ExecuteRegisterRegister.go b/src/core/ExecuteRegisterRegister.go
index bcb19de..166ec7f 100644
--- a/src/core/ExecuteRegisterRegister.go
+++ b/src/core/ExecuteRegisterRegister.go
@@ -27,14 +27,14 @@ func (f *Function) ExecuteRegisterRegister(operation token.Token, register cpu.R
 
 	case token.Div, token.DivAssign:
 		if config.TargetArch == config.X86 {
-			f.SaveRegister(x86.RDX)
+			f.SaveRegister(x86.R2)
 		}
 
 		f.RegisterRegister(asm.DIV, register, operand)
 
 	case token.Mod, token.ModAssign:
 		if config.TargetArch == config.X86 {
-			f.SaveRegister(x86.RDX)
+			f.SaveRegister(x86.R2)
 		}
 
 		f.RegisterRegister(asm.MODULO, register, operand)
diff --git a/src/x86/Add_test.go b/src/x86/Add_test.go
index 71097d4..2291761 100644
--- a/src/x86/Add_test.go
+++ b/src/x86/Add_test.go
@@ -14,14 +14,14 @@ func TestAddRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xC0, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xC1, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xC2, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xC3, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xC4, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xC5, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xC6, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xC7, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xC0, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xC1, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xC2, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xC3, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xC4, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xC5, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xC6, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xC7, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xC0, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xC1, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xC2, 0x01}},
@@ -31,14 +31,14 @@ func TestAddRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xC6, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xC7, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC5, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC6, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC7, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC5, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC6, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC7, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestAddRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x01, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x01, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x01, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x01, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x01, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x01, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x01, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x01, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x01, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x01, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x01, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x01, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x01, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x01, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x01, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x01, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x01, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x01, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x01, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x01, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x01, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x01, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x01, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x01, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x01, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x01, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x01, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x01, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x01, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x01, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x01, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x01, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/And_test.go b/src/x86/And_test.go
index 7fb6fd4..9474456 100644
--- a/src/x86/And_test.go
+++ b/src/x86/And_test.go
@@ -14,14 +14,14 @@ func TestAndRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xE0, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xE1, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xE2, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xE3, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xE4, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xE5, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xE6, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xE7, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xE0, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xE1, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xE2, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xE3, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xE4, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xE5, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xE6, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xE7, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xE0, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xE1, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xE2, 0x01}},
@@ -31,14 +31,14 @@ func TestAndRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xE6, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xE7, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE3, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE5, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE6, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE7, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE3, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE5, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE6, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE7, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestAndRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x21, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x21, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x21, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x21, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x21, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x21, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x21, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x21, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x21, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x21, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x21, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x21, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x21, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x21, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x21, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x21, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x21, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x21, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x21, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x21, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x21, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x21, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x21, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x21, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x21, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x21, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x21, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x21, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x21, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x21, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x21, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x21, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Call_test.go b/src/x86/Call_test.go
index 033ee64..ec8006e 100644
--- a/src/x86/Call_test.go
+++ b/src/x86/Call_test.go
@@ -13,14 +13,14 @@ func TestCallRegister(t *testing.T) {
 		Register cpu.Register
 		Code     []byte
 	}{
-		{x86.RAX, []byte{0xFF, 0xD0}},
-		{x86.RCX, []byte{0xFF, 0xD1}},
-		{x86.RDX, []byte{0xFF, 0xD2}},
-		{x86.RBX, []byte{0xFF, 0xD3}},
-		{x86.RSP, []byte{0xFF, 0xD4}},
-		{x86.RBP, []byte{0xFF, 0xD5}},
-		{x86.RSI, []byte{0xFF, 0xD6}},
-		{x86.RDI, []byte{0xFF, 0xD7}},
+		{x86.R0, []byte{0xFF, 0xD0}},
+		{x86.R1, []byte{0xFF, 0xD1}},
+		{x86.R2, []byte{0xFF, 0xD2}},
+		{x86.R3, []byte{0xFF, 0xD3}},
+		{x86.SP, []byte{0xFF, 0xD4}},
+		{x86.R5, []byte{0xFF, 0xD5}},
+		{x86.R6, []byte{0xFF, 0xD6}},
+		{x86.R7, []byte{0xFF, 0xD7}},
 		{x86.R8, []byte{0x41, 0xFF, 0xD0}},
 		{x86.R9, []byte{0x41, 0xFF, 0xD1}},
 		{x86.R10, []byte{0x41, 0xFF, 0xD2}},
@@ -44,14 +44,14 @@ func TestCallAtMemory(t *testing.T) {
 		Offset   int8
 		Code     []byte
 	}{
-		{x86.RAX, 0, []byte{0xFF, 0x10}},
-		{x86.RCX, 0, []byte{0xFF, 0x11}},
-		{x86.RDX, 0, []byte{0xFF, 0x12}},
-		{x86.RBX, 0, []byte{0xFF, 0x13}},
-		{x86.RSP, 0, []byte{0xFF, 0x14, 0x24}},
-		{x86.RBP, 0, []byte{0xFF, 0x55, 0x00}},
-		{x86.RSI, 0, []byte{0xFF, 0x16}},
-		{x86.RDI, 0, []byte{0xFF, 0x17}},
+		{x86.R0, 0, []byte{0xFF, 0x10}},
+		{x86.R1, 0, []byte{0xFF, 0x11}},
+		{x86.R2, 0, []byte{0xFF, 0x12}},
+		{x86.R3, 0, []byte{0xFF, 0x13}},
+		{x86.SP, 0, []byte{0xFF, 0x14, 0x24}},
+		{x86.R5, 0, []byte{0xFF, 0x55, 0x00}},
+		{x86.R6, 0, []byte{0xFF, 0x16}},
+		{x86.R7, 0, []byte{0xFF, 0x17}},
 		{x86.R8, 0, []byte{0x41, 0xFF, 0x10}},
 		{x86.R9, 0, []byte{0x41, 0xFF, 0x11}},
 		{x86.R10, 0, []byte{0x41, 0xFF, 0x12}},
@@ -61,14 +61,14 @@ func TestCallAtMemory(t *testing.T) {
 		{x86.R14, 0, []byte{0x41, 0xFF, 0x16}},
 		{x86.R15, 0, []byte{0x41, 0xFF, 0x17}},
 
-		{x86.RAX, 1, []byte{0xFF, 0x50, 0x01}},
-		{x86.RCX, 1, []byte{0xFF, 0x51, 0x01}},
-		{x86.RDX, 1, []byte{0xFF, 0x52, 0x01}},
-		{x86.RBX, 1, []byte{0xFF, 0x53, 0x01}},
-		{x86.RSP, 1, []byte{0xFF, 0x54, 0x24, 0x01}},
-		{x86.RBP, 1, []byte{0xFF, 0x55, 0x01}},
-		{x86.RSI, 1, []byte{0xFF, 0x56, 0x01}},
-		{x86.RDI, 1, []byte{0xFF, 0x57, 0x01}},
+		{x86.R0, 1, []byte{0xFF, 0x50, 0x01}},
+		{x86.R1, 1, []byte{0xFF, 0x51, 0x01}},
+		{x86.R2, 1, []byte{0xFF, 0x52, 0x01}},
+		{x86.R3, 1, []byte{0xFF, 0x53, 0x01}},
+		{x86.SP, 1, []byte{0xFF, 0x54, 0x24, 0x01}},
+		{x86.R5, 1, []byte{0xFF, 0x55, 0x01}},
+		{x86.R6, 1, []byte{0xFF, 0x56, 0x01}},
+		{x86.R7, 1, []byte{0xFF, 0x57, 0x01}},
 		{x86.R8, 1, []byte{0x41, 0xFF, 0x50, 0x01}},
 		{x86.R9, 1, []byte{0x41, 0xFF, 0x51, 0x01}},
 		{x86.R10, 1, []byte{0x41, 0xFF, 0x52, 0x01}},
diff --git a/src/x86/Compare_test.go b/src/x86/Compare_test.go
index 141c863..953e4a0 100644
--- a/src/x86/Compare_test.go
+++ b/src/x86/Compare_test.go
@@ -14,14 +14,14 @@ func TestCompareRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xF8, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xF9, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xFA, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xFB, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xFC, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xFD, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xFE, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xFF, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xF8, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xF9, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xFA, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xFB, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xFC, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xFD, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xFE, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xFF, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xF8, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xF9, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xFA, 0x01}},
@@ -31,14 +31,14 @@ func TestCompareRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xFE, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xFF, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFB, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFC, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFD, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFB, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFC, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFD, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestCompareRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x39, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x39, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x39, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x39, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x39, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x39, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x39, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x39, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x39, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x39, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x39, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x39, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x39, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x39, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x39, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x39, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x39, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x39, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x39, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x39, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x39, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x39, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x39, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x39, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x39, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x39, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x39, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x39, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x39, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x39, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x39, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x39, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Div_test.go b/src/x86/Div_test.go
index 5069f76..aa8ca0d 100644
--- a/src/x86/Div_test.go
+++ b/src/x86/Div_test.go
@@ -13,14 +13,14 @@ func TestDivRegister(t *testing.T) {
 		Register cpu.Register
 		Code     []byte
 	}{
-		{x86.RAX, []byte{0x48, 0xF7, 0xF8}},
-		{x86.RCX, []byte{0x48, 0xF7, 0xF9}},
-		{x86.RDX, []byte{0x48, 0xF7, 0xFA}},
-		{x86.RBX, []byte{0x48, 0xF7, 0xFB}},
-		{x86.RSP, []byte{0x48, 0xF7, 0xFC}},
-		{x86.RBP, []byte{0x48, 0xF7, 0xFD}},
-		{x86.RSI, []byte{0x48, 0xF7, 0xFE}},
-		{x86.RDI, []byte{0x48, 0xF7, 0xFF}},
+		{x86.R0, []byte{0x48, 0xF7, 0xF8}},
+		{x86.R1, []byte{0x48, 0xF7, 0xF9}},
+		{x86.R2, []byte{0x48, 0xF7, 0xFA}},
+		{x86.R3, []byte{0x48, 0xF7, 0xFB}},
+		{x86.SP, []byte{0x48, 0xF7, 0xFC}},
+		{x86.R5, []byte{0x48, 0xF7, 0xFD}},
+		{x86.R6, []byte{0x48, 0xF7, 0xFE}},
+		{x86.R7, []byte{0x48, 0xF7, 0xFF}},
 		{x86.R8, []byte{0x49, 0xF7, 0xF8}},
 		{x86.R9, []byte{0x49, 0xF7, 0xF9}},
 		{x86.R10, []byte{0x49, 0xF7, 0xFA}},
diff --git a/src/x86/ExtendRAXToRDX.go b/src/x86/ExtendRAXToRDX.go
index 7d97a86..825a084 100644
--- a/src/x86/ExtendRAXToRDX.go
+++ b/src/x86/ExtendRAXToRDX.go
@@ -1,7 +1,7 @@
 package x86
 
-// ExtendRAXToRDX doubles the size of RAX by sign-extending it to RDX.
+// ExtendR0ToR2 doubles the size of R0 (RAX) by sign-extending it to R2 (RDX).
 // This is also known as CQO.
-func ExtendRAXToRDX(code []byte) []byte {
+func ExtendR0ToR2(code []byte) []byte {
 	return append(code, 0x48, 0x99)
 }
diff --git a/src/x86/LoadAddress_test.go b/src/x86/LoadAddress_test.go
index cedf23f..a0570e3 100644
--- a/src/x86/LoadAddress_test.go
+++ b/src/x86/LoadAddress_test.go
@@ -14,14 +14,14 @@ func TestLoadAddress(t *testing.T) {
 		Offset      int
 		Code        []byte
 	}{
-		{x86.RAX, 0, []byte{0x48, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RCX, 0, []byte{0x48, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RDX, 0, []byte{0x48, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RBX, 0, []byte{0x48, 0x8D, 0x1D, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RSP, 0, []byte{0x48, 0x8D, 0x25, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RBP, 0, []byte{0x48, 0x8D, 0x2D, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RSI, 0, []byte{0x48, 0x8D, 0x35, 0x00, 0x00, 0x00, 0x00}},
-		{x86.RDI, 0, []byte{0x48, 0x8D, 0x3D, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R0, 0, []byte{0x48, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R1, 0, []byte{0x48, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R2, 0, []byte{0x48, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R3, 0, []byte{0x48, 0x8D, 0x1D, 0x00, 0x00, 0x00, 0x00}},
+		{x86.SP, 0, []byte{0x48, 0x8D, 0x25, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R5, 0, []byte{0x48, 0x8D, 0x2D, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R6, 0, []byte{0x48, 0x8D, 0x35, 0x00, 0x00, 0x00, 0x00}},
+		{x86.R7, 0, []byte{0x48, 0x8D, 0x3D, 0x00, 0x00, 0x00, 0x00}},
 		{x86.R8, 0, []byte{0x4C, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}},
 		{x86.R9, 0, []byte{0x4C, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}},
 		{x86.R10, 0, []byte{0x4C, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}},
diff --git a/src/x86/LoadDynamic_test.go b/src/x86/LoadDynamic_test.go
index 4cc3935..86cbf36 100644
--- a/src/x86/LoadDynamic_test.go
+++ b/src/x86/LoadDynamic_test.go
@@ -16,70 +16,70 @@ func TestLoadDynamicRegister(t *testing.T) {
 		OffsetRegister cpu.Register
 		Code           []byte
 	}{
-		{x86.R15, 8, x86.RAX, x86.R15, []byte{0x4E, 0x8B, 0x3C, 0x38}},
-		{x86.R15, 4, x86.RAX, x86.R15, []byte{0x46, 0x8B, 0x3C, 0x38}},
-		{x86.R15, 2, x86.RAX, x86.R15, []byte{0x66, 0x46, 0x8B, 0x3C, 0x38}},
-		{x86.R15, 1, x86.RAX, x86.R15, []byte{0x46, 0x8A, 0x3C, 0x38}},
-		{x86.R14, 8, x86.RCX, x86.R14, []byte{0x4E, 0x8B, 0x34, 0x31}},
-		{x86.R14, 4, x86.RCX, x86.R14, []byte{0x46, 0x8B, 0x34, 0x31}},
-		{x86.R14, 2, x86.RCX, x86.R14, []byte{0x66, 0x46, 0x8B, 0x34, 0x31}},
-		{x86.R14, 1, x86.RCX, x86.R14, []byte{0x46, 0x8A, 0x34, 0x31}},
-		{x86.R13, 8, x86.RDX, x86.R13, []byte{0x4E, 0x8B, 0x2C, 0x2A}},
-		{x86.R13, 4, x86.RDX, x86.R13, []byte{0x46, 0x8B, 0x2C, 0x2A}},
-		{x86.R13, 2, x86.RDX, x86.R13, []byte{0x66, 0x46, 0x8B, 0x2C, 0x2A}},
-		{x86.R13, 1, x86.RDX, x86.R13, []byte{0x46, 0x8A, 0x2C, 0x2A}},
-		{x86.R12, 8, x86.RBX, x86.R12, []byte{0x4E, 0x8B, 0x24, 0x23}},
-		{x86.R12, 4, x86.RBX, x86.R12, []byte{0x46, 0x8B, 0x24, 0x23}},
-		{x86.R12, 2, x86.RBX, x86.R12, []byte{0x66, 0x46, 0x8B, 0x24, 0x23}},
-		{x86.R12, 1, x86.RBX, x86.R12, []byte{0x46, 0x8A, 0x24, 0x23}},
-		{x86.R11, 8, x86.RSP, x86.R11, []byte{0x4E, 0x8B, 0x1C, 0x1C}},
-		{x86.R11, 4, x86.RSP, x86.R11, []byte{0x46, 0x8B, 0x1C, 0x1C}},
-		{x86.R11, 2, x86.RSP, x86.R11, []byte{0x66, 0x46, 0x8B, 0x1C, 0x1C}},
-		{x86.R11, 1, x86.RSP, x86.R11, []byte{0x46, 0x8A, 0x1C, 0x1C}},
-		{x86.R10, 8, x86.RBP, x86.R10, []byte{0x4E, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.R10, 4, x86.RBP, x86.R10, []byte{0x46, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.R10, 2, x86.RBP, x86.R10, []byte{0x66, 0x46, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.R10, 1, x86.RBP, x86.R10, []byte{0x46, 0x8A, 0x54, 0x15, 0x00}},
-		{x86.R9, 8, x86.RSI, x86.R9, []byte{0x4E, 0x8B, 0x0C, 0x0E}},
-		{x86.R9, 4, x86.RSI, x86.R9, []byte{0x46, 0x8B, 0x0C, 0x0E}},
-		{x86.R9, 2, x86.RSI, x86.R9, []byte{0x66, 0x46, 0x8B, 0x0C, 0x0E}},
-		{x86.R9, 1, x86.RSI, x86.R9, []byte{0x46, 0x8A, 0x0C, 0x0E}},
-		{x86.R8, 8, x86.RDI, x86.R8, []byte{0x4E, 0x8B, 0x04, 0x07}},
-		{x86.R8, 4, x86.RDI, x86.R8, []byte{0x46, 0x8B, 0x04, 0x07}},
-		{x86.R8, 2, x86.RDI, x86.R8, []byte{0x66, 0x46, 0x8B, 0x04, 0x07}},
-		{x86.R8, 1, x86.RDI, x86.R8, []byte{0x46, 0x8A, 0x04, 0x07}},
-		{x86.RDI, 8, x86.R8, x86.RDI, []byte{0x49, 0x8B, 0x3C, 0x38}},
-		{x86.RDI, 4, x86.R8, x86.RDI, []byte{0x41, 0x8B, 0x3C, 0x38}},
-		{x86.RDI, 2, x86.R8, x86.RDI, []byte{0x66, 0x41, 0x8B, 0x3C, 0x38}},
-		{x86.RDI, 1, x86.R8, x86.RDI, []byte{0x41, 0x8A, 0x3C, 0x38}},
-		{x86.RSI, 8, x86.R9, x86.RSI, []byte{0x49, 0x8B, 0x34, 0x31}},
-		{x86.RSI, 4, x86.R9, x86.RSI, []byte{0x41, 0x8B, 0x34, 0x31}},
-		{x86.RSI, 2, x86.R9, x86.RSI, []byte{0x66, 0x41, 0x8B, 0x34, 0x31}},
-		{x86.RSI, 1, x86.R9, x86.RSI, []byte{0x41, 0x8A, 0x34, 0x31}},
-		{x86.RBP, 8, x86.R10, x86.RBP, []byte{0x49, 0x8B, 0x2C, 0x2A}},
-		{x86.RBP, 4, x86.R10, x86.RBP, []byte{0x41, 0x8B, 0x2C, 0x2A}},
-		{x86.RBP, 2, x86.R10, x86.RBP, []byte{0x66, 0x41, 0x8B, 0x2C, 0x2A}},
-		{x86.RBP, 1, x86.R10, x86.RBP, []byte{0x41, 0x8A, 0x2C, 0x2A}},
-		{x86.RSP, 8, x86.R11, x86.RSP, []byte{0x4A, 0x8B, 0x24, 0x1C}},
-		{x86.RSP, 4, x86.R11, x86.RSP, []byte{0x42, 0x8B, 0x24, 0x1C}},
-		{x86.RSP, 2, x86.R11, x86.RSP, []byte{0x66, 0x42, 0x8B, 0x24, 0x1C}},
-		{x86.RSP, 1, x86.R11, x86.RSP, []byte{0x42, 0x8A, 0x24, 0x1C}},
-		{x86.RBX, 8, x86.R12, x86.RBX, []byte{0x49, 0x8B, 0x1C, 0x1C}},
-		{x86.RBX, 4, x86.R12, x86.RBX, []byte{0x41, 0x8B, 0x1C, 0x1C}},
-		{x86.RBX, 2, x86.R12, x86.RBX, []byte{0x66, 0x41, 0x8B, 0x1C, 0x1C}},
-		{x86.RBX, 1, x86.R12, x86.RBX, []byte{0x41, 0x8A, 0x1C, 0x1C}},
-		{x86.RDX, 8, x86.R13, x86.RDX, []byte{0x49, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.RDX, 4, x86.R13, x86.RDX, []byte{0x41, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.RDX, 2, x86.R13, x86.RDX, []byte{0x66, 0x41, 0x8B, 0x54, 0x15, 0x00}},
-		{x86.RDX, 1, x86.R13, x86.RDX, []byte{0x41, 0x8A, 0x54, 0x15, 0x00}},
-		{x86.RCX, 8, x86.R14, x86.RCX, []byte{0x49, 0x8B, 0x0C, 0x0E}},
-		{x86.RCX, 4, x86.R14, x86.RCX, []byte{0x41, 0x8B, 0x0C, 0x0E}},
-		{x86.RCX, 2, x86.R14, x86.RCX, []byte{0x66, 0x41, 0x8B, 0x0C, 0x0E}},
-		{x86.RCX, 1, x86.R14, x86.RCX, []byte{0x41, 0x8A, 0x0C, 0x0E}},
-		{x86.RAX, 8, x86.R15, x86.RAX, []byte{0x49, 0x8B, 0x04, 0x07}},
-		{x86.RAX, 4, x86.R15, x86.RAX, []byte{0x41, 0x8B, 0x04, 0x07}},
-		{x86.RAX, 2, x86.R15, x86.RAX, []byte{0x66, 0x41, 0x8B, 0x04, 0x07}},
-		{x86.RAX, 1, x86.R15, x86.RAX, []byte{0x41, 0x8A, 0x04, 0x07}},
+		{x86.R15, 8, x86.R0, x86.R15, []byte{0x4E, 0x8B, 0x3C, 0x38}},
+		{x86.R15, 4, x86.R0, x86.R15, []byte{0x46, 0x8B, 0x3C, 0x38}},
+		{x86.R15, 2, x86.R0, x86.R15, []byte{0x66, 0x46, 0x8B, 0x3C, 0x38}},
+		{x86.R15, 1, x86.R0, x86.R15, []byte{0x46, 0x8A, 0x3C, 0x38}},
+		{x86.R14, 8, x86.R1, x86.R14, []byte{0x4E, 0x8B, 0x34, 0x31}},
+		{x86.R14, 4, x86.R1, x86.R14, []byte{0x46, 0x8B, 0x34, 0x31}},
+		{x86.R14, 2, x86.R1, x86.R14, []byte{0x66, 0x46, 0x8B, 0x34, 0x31}},
+		{x86.R14, 1, x86.R1, x86.R14, []byte{0x46, 0x8A, 0x34, 0x31}},
+		{x86.R13, 8, x86.R2, x86.R13, []byte{0x4E, 0x8B, 0x2C, 0x2A}},
+		{x86.R13, 4, x86.R2, x86.R13, []byte{0x46, 0x8B, 0x2C, 0x2A}},
+		{x86.R13, 2, x86.R2, x86.R13, []byte{0x66, 0x46, 0x8B, 0x2C, 0x2A}},
+		{x86.R13, 1, x86.R2, x86.R13, []byte{0x46, 0x8A, 0x2C, 0x2A}},
+		{x86.R12, 8, x86.R3, x86.R12, []byte{0x4E, 0x8B, 0x24, 0x23}},
+		{x86.R12, 4, x86.R3, x86.R12, []byte{0x46, 0x8B, 0x24, 0x23}},
+		{x86.R12, 2, x86.R3, x86.R12, []byte{0x66, 0x46, 0x8B, 0x24, 0x23}},
+		{x86.R12, 1, x86.R3, x86.R12, []byte{0x46, 0x8A, 0x24, 0x23}},
+		{x86.R11, 8, x86.SP, x86.R11, []byte{0x4E, 0x8B, 0x1C, 0x1C}},
+		{x86.R11, 4, x86.SP, x86.R11, []byte{0x46, 0x8B, 0x1C, 0x1C}},
+		{x86.R11, 2, x86.SP, x86.R11, []byte{0x66, 0x46, 0x8B, 0x1C, 0x1C}},
+		{x86.R11, 1, x86.SP, x86.R11, []byte{0x46, 0x8A, 0x1C, 0x1C}},
+		{x86.R10, 8, x86.R5, x86.R10, []byte{0x4E, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R10, 4, x86.R5, x86.R10, []byte{0x46, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R10, 2, x86.R5, x86.R10, []byte{0x66, 0x46, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R10, 1, x86.R5, x86.R10, []byte{0x46, 0x8A, 0x54, 0x15, 0x00}},
+		{x86.R9, 8, x86.R6, x86.R9, []byte{0x4E, 0x8B, 0x0C, 0x0E}},
+		{x86.R9, 4, x86.R6, x86.R9, []byte{0x46, 0x8B, 0x0C, 0x0E}},
+		{x86.R9, 2, x86.R6, x86.R9, []byte{0x66, 0x46, 0x8B, 0x0C, 0x0E}},
+		{x86.R9, 1, x86.R6, x86.R9, []byte{0x46, 0x8A, 0x0C, 0x0E}},
+		{x86.R8, 8, x86.R7, x86.R8, []byte{0x4E, 0x8B, 0x04, 0x07}},
+		{x86.R8, 4, x86.R7, x86.R8, []byte{0x46, 0x8B, 0x04, 0x07}},
+		{x86.R8, 2, x86.R7, x86.R8, []byte{0x66, 0x46, 0x8B, 0x04, 0x07}},
+		{x86.R8, 1, x86.R7, x86.R8, []byte{0x46, 0x8A, 0x04, 0x07}},
+		{x86.R7, 8, x86.R8, x86.R7, []byte{0x49, 0x8B, 0x3C, 0x38}},
+		{x86.R7, 4, x86.R8, x86.R7, []byte{0x41, 0x8B, 0x3C, 0x38}},
+		{x86.R7, 2, x86.R8, x86.R7, []byte{0x66, 0x41, 0x8B, 0x3C, 0x38}},
+		{x86.R7, 1, x86.R8, x86.R7, []byte{0x41, 0x8A, 0x3C, 0x38}},
+		{x86.R6, 8, x86.R9, x86.R6, []byte{0x49, 0x8B, 0x34, 0x31}},
+		{x86.R6, 4, x86.R9, x86.R6, []byte{0x41, 0x8B, 0x34, 0x31}},
+		{x86.R6, 2, x86.R9, x86.R6, []byte{0x66, 0x41, 0x8B, 0x34, 0x31}},
+		{x86.R6, 1, x86.R9, x86.R6, []byte{0x41, 0x8A, 0x34, 0x31}},
+		{x86.R5, 8, x86.R10, x86.R5, []byte{0x49, 0x8B, 0x2C, 0x2A}},
+		{x86.R5, 4, x86.R10, x86.R5, []byte{0x41, 0x8B, 0x2C, 0x2A}},
+		{x86.R5, 2, x86.R10, x86.R5, []byte{0x66, 0x41, 0x8B, 0x2C, 0x2A}},
+		{x86.R5, 1, x86.R10, x86.R5, []byte{0x41, 0x8A, 0x2C, 0x2A}},
+		{x86.SP, 8, x86.R11, x86.SP, []byte{0x4A, 0x8B, 0x24, 0x1C}},
+		{x86.SP, 4, x86.R11, x86.SP, []byte{0x42, 0x8B, 0x24, 0x1C}},
+		{x86.SP, 2, x86.R11, x86.SP, []byte{0x66, 0x42, 0x8B, 0x24, 0x1C}},
+		{x86.SP, 1, x86.R11, x86.SP, []byte{0x42, 0x8A, 0x24, 0x1C}},
+		{x86.R3, 8, x86.R12, x86.R3, []byte{0x49, 0x8B, 0x1C, 0x1C}},
+		{x86.R3, 4, x86.R12, x86.R3, []byte{0x41, 0x8B, 0x1C, 0x1C}},
+		{x86.R3, 2, x86.R12, x86.R3, []byte{0x66, 0x41, 0x8B, 0x1C, 0x1C}},
+		{x86.R3, 1, x86.R12, x86.R3, []byte{0x41, 0x8A, 0x1C, 0x1C}},
+		{x86.R2, 8, x86.R13, x86.R2, []byte{0x49, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R2, 4, x86.R13, x86.R2, []byte{0x41, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R2, 2, x86.R13, x86.R2, []byte{0x66, 0x41, 0x8B, 0x54, 0x15, 0x00}},
+		{x86.R2, 1, x86.R13, x86.R2, []byte{0x41, 0x8A, 0x54, 0x15, 0x00}},
+		{x86.R1, 8, x86.R14, x86.R1, []byte{0x49, 0x8B, 0x0C, 0x0E}},
+		{x86.R1, 4, x86.R14, x86.R1, []byte{0x41, 0x8B, 0x0C, 0x0E}},
+		{x86.R1, 2, x86.R14, x86.R1, []byte{0x66, 0x41, 0x8B, 0x0C, 0x0E}},
+		{x86.R1, 1, x86.R14, x86.R1, []byte{0x41, 0x8A, 0x0C, 0x0E}},
+		{x86.R0, 8, x86.R15, x86.R0, []byte{0x49, 0x8B, 0x04, 0x07}},
+		{x86.R0, 4, x86.R15, x86.R0, []byte{0x41, 0x8B, 0x04, 0x07}},
+		{x86.R0, 2, x86.R15, x86.R0, []byte{0x66, 0x41, 0x8B, 0x04, 0x07}},
+		{x86.R0, 1, x86.R15, x86.R0, []byte{0x41, 0x8A, 0x04, 0x07}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Load_test.go b/src/x86/Load_test.go
index 3d5240b..006abad 100644
--- a/src/x86/Load_test.go
+++ b/src/x86/Load_test.go
@@ -17,136 +17,136 @@ func TestLoadRegister(t *testing.T) {
 		Code        []byte
 	}{
 		// No offset
-		{x86.RAX, x86.R15, 0, 8, []byte{0x49, 0x8B, 0x07}},
-		{x86.RAX, x86.R15, 0, 4, []byte{0x41, 0x8B, 0x07}},
-		{x86.RAX, x86.R15, 0, 2, []byte{0x66, 0x41, 0x8B, 0x07}},
-		{x86.RAX, x86.R15, 0, 1, []byte{0x41, 0x8A, 0x07}},
-		{x86.RCX, x86.R14, 0, 8, []byte{0x49, 0x8B, 0x0E}},
-		{x86.RCX, x86.R14, 0, 4, []byte{0x41, 0x8B, 0x0E}},
-		{x86.RCX, x86.R14, 0, 2, []byte{0x66, 0x41, 0x8B, 0x0E}},
-		{x86.RCX, x86.R14, 0, 1, []byte{0x41, 0x8A, 0x0E}},
-		{x86.RDX, x86.R13, 0, 8, []byte{0x49, 0x8B, 0x55, 0x00}},
-		{x86.RDX, x86.R13, 0, 4, []byte{0x41, 0x8B, 0x55, 0x00}},
-		{x86.RDX, x86.R13, 0, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x00}},
-		{x86.RDX, x86.R13, 0, 1, []byte{0x41, 0x8A, 0x55, 0x00}},
-		{x86.RBX, x86.R12, 0, 8, []byte{0x49, 0x8B, 0x1C, 0x24}},
-		{x86.RBX, x86.R12, 0, 4, []byte{0x41, 0x8B, 0x1C, 0x24}},
-		{x86.RBX, x86.R12, 0, 2, []byte{0x66, 0x41, 0x8B, 0x1C, 0x24}},
-		{x86.RBX, x86.R12, 0, 1, []byte{0x41, 0x8A, 0x1C, 0x24}},
-		{x86.RSP, x86.R11, 0, 8, []byte{0x49, 0x8B, 0x23}},
-		{x86.RSP, x86.R11, 0, 4, []byte{0x41, 0x8B, 0x23}},
-		{x86.RSP, x86.R11, 0, 2, []byte{0x66, 0x41, 0x8B, 0x23}},
-		{x86.RSP, x86.R11, 0, 1, []byte{0x41, 0x8A, 0x23}},
-		{x86.RBP, x86.R10, 0, 8, []byte{0x49, 0x8B, 0x2A}},
-		{x86.RBP, x86.R10, 0, 4, []byte{0x41, 0x8B, 0x2A}},
-		{x86.RBP, x86.R10, 0, 2, []byte{0x66, 0x41, 0x8B, 0x2A}},
-		{x86.RBP, x86.R10, 0, 1, []byte{0x41, 0x8A, 0x2A}},
-		{x86.RSI, x86.R9, 0, 8, []byte{0x49, 0x8B, 0x31}},
-		{x86.RSI, x86.R9, 0, 4, []byte{0x41, 0x8B, 0x31}},
-		{x86.RSI, x86.R9, 0, 2, []byte{0x66, 0x41, 0x8B, 0x31}},
-		{x86.RSI, x86.R9, 0, 1, []byte{0x41, 0x8A, 0x31}},
-		{x86.RDI, x86.R8, 0, 8, []byte{0x49, 0x8B, 0x38}},
-		{x86.RDI, x86.R8, 0, 4, []byte{0x41, 0x8B, 0x38}},
-		{x86.RDI, x86.R8, 0, 2, []byte{0x66, 0x41, 0x8B, 0x38}},
-		{x86.RDI, x86.R8, 0, 1, []byte{0x41, 0x8A, 0x38}},
-		{x86.R8, x86.RDI, 0, 8, []byte{0x4C, 0x8B, 0x07}},
-		{x86.R8, x86.RDI, 0, 4, []byte{0x44, 0x8B, 0x07}},
-		{x86.R8, x86.RDI, 0, 2, []byte{0x66, 0x44, 0x8B, 0x07}},
-		{x86.R8, x86.RDI, 0, 1, []byte{0x44, 0x8A, 0x07}},
-		{x86.R9, x86.RSI, 0, 8, []byte{0x4C, 0x8B, 0x0E}},
-		{x86.R9, x86.RSI, 0, 4, []byte{0x44, 0x8B, 0x0E}},
-		{x86.R9, x86.RSI, 0, 2, []byte{0x66, 0x44, 0x8B, 0x0E}},
-		{x86.R9, x86.RSI, 0, 1, []byte{0x44, 0x8A, 0x0E}},
-		{x86.R10, x86.RBP, 0, 8, []byte{0x4C, 0x8B, 0x55, 0x00}},
-		{x86.R10, x86.RBP, 0, 4, []byte{0x44, 0x8B, 0x55, 0x00}},
-		{x86.R10, x86.RBP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x00}},
-		{x86.R10, x86.RBP, 0, 1, []byte{0x44, 0x8A, 0x55, 0x00}},
-		{x86.R11, x86.RSP, 0, 8, []byte{0x4C, 0x8B, 0x1C, 0x24}},
-		{x86.R11, x86.RSP, 0, 4, []byte{0x44, 0x8B, 0x1C, 0x24}},
-		{x86.R11, x86.RSP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x1C, 0x24}},
-		{x86.R11, x86.RSP, 0, 1, []byte{0x44, 0x8A, 0x1C, 0x24}},
-		{x86.R12, x86.RBX, 0, 8, []byte{0x4C, 0x8B, 0x23}},
-		{x86.R12, x86.RBX, 0, 4, []byte{0x44, 0x8B, 0x23}},
-		{x86.R12, x86.RBX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x23}},
-		{x86.R12, x86.RBX, 0, 1, []byte{0x44, 0x8A, 0x23}},
-		{x86.R13, x86.RDX, 0, 8, []byte{0x4C, 0x8B, 0x2A}},
-		{x86.R13, x86.RDX, 0, 4, []byte{0x44, 0x8B, 0x2A}},
-		{x86.R13, x86.RDX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x2A}},
-		{x86.R13, x86.RDX, 0, 1, []byte{0x44, 0x8A, 0x2A}},
-		{x86.R14, x86.RCX, 0, 8, []byte{0x4C, 0x8B, 0x31}},
-		{x86.R14, x86.RCX, 0, 4, []byte{0x44, 0x8B, 0x31}},
-		{x86.R14, x86.RCX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x31}},
-		{x86.R14, x86.RCX, 0, 1, []byte{0x44, 0x8A, 0x31}},
-		{x86.R15, x86.RAX, 0, 8, []byte{0x4C, 0x8B, 0x38}},
-		{x86.R15, x86.RAX, 0, 4, []byte{0x44, 0x8B, 0x38}},
-		{x86.R15, x86.RAX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x38}},
-		{x86.R15, x86.RAX, 0, 1, []byte{0x44, 0x8A, 0x38}},
+		{x86.R0, x86.R15, 0, 8, []byte{0x49, 0x8B, 0x07}},
+		{x86.R0, x86.R15, 0, 4, []byte{0x41, 0x8B, 0x07}},
+		{x86.R0, x86.R15, 0, 2, []byte{0x66, 0x41, 0x8B, 0x07}},
+		{x86.R0, x86.R15, 0, 1, []byte{0x41, 0x8A, 0x07}},
+		{x86.R1, x86.R14, 0, 8, []byte{0x49, 0x8B, 0x0E}},
+		{x86.R1, x86.R14, 0, 4, []byte{0x41, 0x8B, 0x0E}},
+		{x86.R1, x86.R14, 0, 2, []byte{0x66, 0x41, 0x8B, 0x0E}},
+		{x86.R1, x86.R14, 0, 1, []byte{0x41, 0x8A, 0x0E}},
+		{x86.R2, x86.R13, 0, 8, []byte{0x49, 0x8B, 0x55, 0x00}},
+		{x86.R2, x86.R13, 0, 4, []byte{0x41, 0x8B, 0x55, 0x00}},
+		{x86.R2, x86.R13, 0, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x00}},
+		{x86.R2, x86.R13, 0, 1, []byte{0x41, 0x8A, 0x55, 0x00}},
+		{x86.R3, x86.R12, 0, 8, []byte{0x49, 0x8B, 0x1C, 0x24}},
+		{x86.R3, x86.R12, 0, 4, []byte{0x41, 0x8B, 0x1C, 0x24}},
+		{x86.R3, x86.R12, 0, 2, []byte{0x66, 0x41, 0x8B, 0x1C, 0x24}},
+		{x86.R3, x86.R12, 0, 1, []byte{0x41, 0x8A, 0x1C, 0x24}},
+		{x86.SP, x86.R11, 0, 8, []byte{0x49, 0x8B, 0x23}},
+		{x86.SP, x86.R11, 0, 4, []byte{0x41, 0x8B, 0x23}},
+		{x86.SP, x86.R11, 0, 2, []byte{0x66, 0x41, 0x8B, 0x23}},
+		{x86.SP, x86.R11, 0, 1, []byte{0x41, 0x8A, 0x23}},
+		{x86.R5, x86.R10, 0, 8, []byte{0x49, 0x8B, 0x2A}},
+		{x86.R5, x86.R10, 0, 4, []byte{0x41, 0x8B, 0x2A}},
+		{x86.R5, x86.R10, 0, 2, []byte{0x66, 0x41, 0x8B, 0x2A}},
+		{x86.R5, x86.R10, 0, 1, []byte{0x41, 0x8A, 0x2A}},
+		{x86.R6, x86.R9, 0, 8, []byte{0x49, 0x8B, 0x31}},
+		{x86.R6, x86.R9, 0, 4, []byte{0x41, 0x8B, 0x31}},
+		{x86.R6, x86.R9, 0, 2, []byte{0x66, 0x41, 0x8B, 0x31}},
+		{x86.R6, x86.R9, 0, 1, []byte{0x41, 0x8A, 0x31}},
+		{x86.R7, x86.R8, 0, 8, []byte{0x49, 0x8B, 0x38}},
+		{x86.R7, x86.R8, 0, 4, []byte{0x41, 0x8B, 0x38}},
+		{x86.R7, x86.R8, 0, 2, []byte{0x66, 0x41, 0x8B, 0x38}},
+		{x86.R7, x86.R8, 0, 1, []byte{0x41, 0x8A, 0x38}},
+		{x86.R8, x86.R7, 0, 8, []byte{0x4C, 0x8B, 0x07}},
+		{x86.R8, x86.R7, 0, 4, []byte{0x44, 0x8B, 0x07}},
+		{x86.R8, x86.R7, 0, 2, []byte{0x66, 0x44, 0x8B, 0x07}},
+		{x86.R8, x86.R7, 0, 1, []byte{0x44, 0x8A, 0x07}},
+		{x86.R9, x86.R6, 0, 8, []byte{0x4C, 0x8B, 0x0E}},
+		{x86.R9, x86.R6, 0, 4, []byte{0x44, 0x8B, 0x0E}},
+		{x86.R9, x86.R6, 0, 2, []byte{0x66, 0x44, 0x8B, 0x0E}},
+		{x86.R9, x86.R6, 0, 1, []byte{0x44, 0x8A, 0x0E}},
+		{x86.R10, x86.R5, 0, 8, []byte{0x4C, 0x8B, 0x55, 0x00}},
+		{x86.R10, x86.R5, 0, 4, []byte{0x44, 0x8B, 0x55, 0x00}},
+		{x86.R10, x86.R5, 0, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x00}},
+		{x86.R10, x86.R5, 0, 1, []byte{0x44, 0x8A, 0x55, 0x00}},
+		{x86.R11, x86.SP, 0, 8, []byte{0x4C, 0x8B, 0x1C, 0x24}},
+		{x86.R11, x86.SP, 0, 4, []byte{0x44, 0x8B, 0x1C, 0x24}},
+		{x86.R11, x86.SP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x1C, 0x24}},
+		{x86.R11, x86.SP, 0, 1, []byte{0x44, 0x8A, 0x1C, 0x24}},
+		{x86.R12, x86.R3, 0, 8, []byte{0x4C, 0x8B, 0x23}},
+		{x86.R12, x86.R3, 0, 4, []byte{0x44, 0x8B, 0x23}},
+		{x86.R12, x86.R3, 0, 2, []byte{0x66, 0x44, 0x8B, 0x23}},
+		{x86.R12, x86.R3, 0, 1, []byte{0x44, 0x8A, 0x23}},
+		{x86.R13, x86.R2, 0, 8, []byte{0x4C, 0x8B, 0x2A}},
+		{x86.R13, x86.R2, 0, 4, []byte{0x44, 0x8B, 0x2A}},
+		{x86.R13, x86.R2, 0, 2, []byte{0x66, 0x44, 0x8B, 0x2A}},
+		{x86.R13, x86.R2, 0, 1, []byte{0x44, 0x8A, 0x2A}},
+		{x86.R14, x86.R1, 0, 8, []byte{0x4C, 0x8B, 0x31}},
+		{x86.R14, x86.R1, 0, 4, []byte{0x44, 0x8B, 0x31}},
+		{x86.R14, x86.R1, 0, 2, []byte{0x66, 0x44, 0x8B, 0x31}},
+		{x86.R14, x86.R1, 0, 1, []byte{0x44, 0x8A, 0x31}},
+		{x86.R15, x86.R0, 0, 8, []byte{0x4C, 0x8B, 0x38}},
+		{x86.R15, x86.R0, 0, 4, []byte{0x44, 0x8B, 0x38}},
+		{x86.R15, x86.R0, 0, 2, []byte{0x66, 0x44, 0x8B, 0x38}},
+		{x86.R15, x86.R0, 0, 1, []byte{0x44, 0x8A, 0x38}},
 
 		// Offset of 1
-		{x86.RAX, x86.R15, 1, 8, []byte{0x49, 0x8B, 0x47, 0x01}},
-		{x86.RAX, x86.R15, 1, 4, []byte{0x41, 0x8B, 0x47, 0x01}},
-		{x86.RAX, x86.R15, 1, 2, []byte{0x66, 0x41, 0x8B, 0x47, 0x01}},
-		{x86.RAX, x86.R15, 1, 1, []byte{0x41, 0x8A, 0x47, 0x01}},
-		{x86.RCX, x86.R14, 1, 8, []byte{0x49, 0x8B, 0x4E, 0x01}},
-		{x86.RCX, x86.R14, 1, 4, []byte{0x41, 0x8B, 0x4E, 0x01}},
-		{x86.RCX, x86.R14, 1, 2, []byte{0x66, 0x41, 0x8B, 0x4E, 0x01}},
-		{x86.RCX, x86.R14, 1, 1, []byte{0x41, 0x8A, 0x4E, 0x01}},
-		{x86.RDX, x86.R13, 1, 8, []byte{0x49, 0x8B, 0x55, 0x01}},
-		{x86.RDX, x86.R13, 1, 4, []byte{0x41, 0x8B, 0x55, 0x01}},
-		{x86.RDX, x86.R13, 1, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x01}},
-		{x86.RDX, x86.R13, 1, 1, []byte{0x41, 0x8A, 0x55, 0x01}},
-		{x86.RBX, x86.R12, 1, 8, []byte{0x49, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.RBX, x86.R12, 1, 4, []byte{0x41, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.RBX, x86.R12, 1, 2, []byte{0x66, 0x41, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.RBX, x86.R12, 1, 1, []byte{0x41, 0x8A, 0x5C, 0x24, 0x01}},
-		{x86.RSP, x86.R11, 1, 8, []byte{0x49, 0x8B, 0x63, 0x01}},
-		{x86.RSP, x86.R11, 1, 4, []byte{0x41, 0x8B, 0x63, 0x01}},
-		{x86.RSP, x86.R11, 1, 2, []byte{0x66, 0x41, 0x8B, 0x63, 0x01}},
-		{x86.RSP, x86.R11, 1, 1, []byte{0x41, 0x8A, 0x63, 0x01}},
-		{x86.RBP, x86.R10, 1, 8, []byte{0x49, 0x8B, 0x6A, 0x01}},
-		{x86.RBP, x86.R10, 1, 4, []byte{0x41, 0x8B, 0x6A, 0x01}},
-		{x86.RBP, x86.R10, 1, 2, []byte{0x66, 0x41, 0x8B, 0x6A, 0x01}},
-		{x86.RBP, x86.R10, 1, 1, []byte{0x41, 0x8A, 0x6A, 0x01}},
-		{x86.RSI, x86.R9, 1, 8, []byte{0x49, 0x8B, 0x71, 0x01}},
-		{x86.RSI, x86.R9, 1, 4, []byte{0x41, 0x8B, 0x71, 0x01}},
-		{x86.RSI, x86.R9, 1, 2, []byte{0x66, 0x41, 0x8B, 0x71, 0x01}},
-		{x86.RSI, x86.R9, 1, 1, []byte{0x41, 0x8A, 0x71, 0x01}},
-		{x86.RDI, x86.R8, 1, 8, []byte{0x49, 0x8B, 0x78, 0x01}},
-		{x86.RDI, x86.R8, 1, 4, []byte{0x41, 0x8B, 0x78, 0x01}},
-		{x86.RDI, x86.R8, 1, 2, []byte{0x66, 0x41, 0x8B, 0x78, 0x01}},
-		{x86.RDI, x86.R8, 1, 1, []byte{0x41, 0x8A, 0x78, 0x01}},
-		{x86.R8, x86.RDI, 1, 8, []byte{0x4C, 0x8B, 0x47, 0x01}},
-		{x86.R8, x86.RDI, 1, 4, []byte{0x44, 0x8B, 0x47, 0x01}},
-		{x86.R8, x86.RDI, 1, 2, []byte{0x66, 0x44, 0x8B, 0x47, 0x01}},
-		{x86.R8, x86.RDI, 1, 1, []byte{0x44, 0x8A, 0x47, 0x01}},
-		{x86.R9, x86.RSI, 1, 8, []byte{0x4C, 0x8B, 0x4E, 0x01}},
-		{x86.R9, x86.RSI, 1, 4, []byte{0x44, 0x8B, 0x4E, 0x01}},
-		{x86.R9, x86.RSI, 1, 2, []byte{0x66, 0x44, 0x8B, 0x4E, 0x01}},
-		{x86.R9, x86.RSI, 1, 1, []byte{0x44, 0x8A, 0x4E, 0x01}},
-		{x86.R10, x86.RBP, 1, 8, []byte{0x4C, 0x8B, 0x55, 0x01}},
-		{x86.R10, x86.RBP, 1, 4, []byte{0x44, 0x8B, 0x55, 0x01}},
-		{x86.R10, x86.RBP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x01}},
-		{x86.R10, x86.RBP, 1, 1, []byte{0x44, 0x8A, 0x55, 0x01}},
-		{x86.R11, x86.RSP, 1, 8, []byte{0x4C, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.R11, x86.RSP, 1, 4, []byte{0x44, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.R11, x86.RSP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x5C, 0x24, 0x01}},
-		{x86.R11, x86.RSP, 1, 1, []byte{0x44, 0x8A, 0x5C, 0x24, 0x01}},
-		{x86.R12, x86.RBX, 1, 8, []byte{0x4C, 0x8B, 0x63, 0x01}},
-		{x86.R12, x86.RBX, 1, 4, []byte{0x44, 0x8B, 0x63, 0x01}},
-		{x86.R12, x86.RBX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x63, 0x01}},
-		{x86.R12, x86.RBX, 1, 1, []byte{0x44, 0x8A, 0x63, 0x01}},
-		{x86.R13, x86.RDX, 1, 8, []byte{0x4C, 0x8B, 0x6A, 0x01}},
-		{x86.R13, x86.RDX, 1, 4, []byte{0x44, 0x8B, 0x6A, 0x01}},
-		{x86.R13, x86.RDX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x6A, 0x01}},
-		{x86.R13, x86.RDX, 1, 1, []byte{0x44, 0x8A, 0x6A, 0x01}},
-		{x86.R14, x86.RCX, 1, 8, []byte{0x4C, 0x8B, 0x71, 0x01}},
-		{x86.R14, x86.RCX, 1, 4, []byte{0x44, 0x8B, 0x71, 0x01}},
-		{x86.R14, x86.RCX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x71, 0x01}},
-		{x86.R14, x86.RCX, 1, 1, []byte{0x44, 0x8A, 0x71, 0x01}},
-		{x86.R15, x86.RAX, 1, 8, []byte{0x4C, 0x8B, 0x78, 0x01}},
-		{x86.R15, x86.RAX, 1, 4, []byte{0x44, 0x8B, 0x78, 0x01}},
-		{x86.R15, x86.RAX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x78, 0x01}},
-		{x86.R15, x86.RAX, 1, 1, []byte{0x44, 0x8A, 0x78, 0x01}},
+		{x86.R0, x86.R15, 1, 8, []byte{0x49, 0x8B, 0x47, 0x01}},
+		{x86.R0, x86.R15, 1, 4, []byte{0x41, 0x8B, 0x47, 0x01}},
+		{x86.R0, x86.R15, 1, 2, []byte{0x66, 0x41, 0x8B, 0x47, 0x01}},
+		{x86.R0, x86.R15, 1, 1, []byte{0x41, 0x8A, 0x47, 0x01}},
+		{x86.R1, x86.R14, 1, 8, []byte{0x49, 0x8B, 0x4E, 0x01}},
+		{x86.R1, x86.R14, 1, 4, []byte{0x41, 0x8B, 0x4E, 0x01}},
+		{x86.R1, x86.R14, 1, 2, []byte{0x66, 0x41, 0x8B, 0x4E, 0x01}},
+		{x86.R1, x86.R14, 1, 1, []byte{0x41, 0x8A, 0x4E, 0x01}},
+		{x86.R2, x86.R13, 1, 8, []byte{0x49, 0x8B, 0x55, 0x01}},
+		{x86.R2, x86.R13, 1, 4, []byte{0x41, 0x8B, 0x55, 0x01}},
+		{x86.R2, x86.R13, 1, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x01}},
+		{x86.R2, x86.R13, 1, 1, []byte{0x41, 0x8A, 0x55, 0x01}},
+		{x86.R3, x86.R12, 1, 8, []byte{0x49, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R3, x86.R12, 1, 4, []byte{0x41, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R3, x86.R12, 1, 2, []byte{0x66, 0x41, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R3, x86.R12, 1, 1, []byte{0x41, 0x8A, 0x5C, 0x24, 0x01}},
+		{x86.SP, x86.R11, 1, 8, []byte{0x49, 0x8B, 0x63, 0x01}},
+		{x86.SP, x86.R11, 1, 4, []byte{0x41, 0x8B, 0x63, 0x01}},
+		{x86.SP, x86.R11, 1, 2, []byte{0x66, 0x41, 0x8B, 0x63, 0x01}},
+		{x86.SP, x86.R11, 1, 1, []byte{0x41, 0x8A, 0x63, 0x01}},
+		{x86.R5, x86.R10, 1, 8, []byte{0x49, 0x8B, 0x6A, 0x01}},
+		{x86.R5, x86.R10, 1, 4, []byte{0x41, 0x8B, 0x6A, 0x01}},
+		{x86.R5, x86.R10, 1, 2, []byte{0x66, 0x41, 0x8B, 0x6A, 0x01}},
+		{x86.R5, x86.R10, 1, 1, []byte{0x41, 0x8A, 0x6A, 0x01}},
+		{x86.R6, x86.R9, 1, 8, []byte{0x49, 0x8B, 0x71, 0x01}},
+		{x86.R6, x86.R9, 1, 4, []byte{0x41, 0x8B, 0x71, 0x01}},
+		{x86.R6, x86.R9, 1, 2, []byte{0x66, 0x41, 0x8B, 0x71, 0x01}},
+		{x86.R6, x86.R9, 1, 1, []byte{0x41, 0x8A, 0x71, 0x01}},
+		{x86.R7, x86.R8, 1, 8, []byte{0x49, 0x8B, 0x78, 0x01}},
+		{x86.R7, x86.R8, 1, 4, []byte{0x41, 0x8B, 0x78, 0x01}},
+		{x86.R7, x86.R8, 1, 2, []byte{0x66, 0x41, 0x8B, 0x78, 0x01}},
+		{x86.R7, x86.R8, 1, 1, []byte{0x41, 0x8A, 0x78, 0x01}},
+		{x86.R8, x86.R7, 1, 8, []byte{0x4C, 0x8B, 0x47, 0x01}},
+		{x86.R8, x86.R7, 1, 4, []byte{0x44, 0x8B, 0x47, 0x01}},
+		{x86.R8, x86.R7, 1, 2, []byte{0x66, 0x44, 0x8B, 0x47, 0x01}},
+		{x86.R8, x86.R7, 1, 1, []byte{0x44, 0x8A, 0x47, 0x01}},
+		{x86.R9, x86.R6, 1, 8, []byte{0x4C, 0x8B, 0x4E, 0x01}},
+		{x86.R9, x86.R6, 1, 4, []byte{0x44, 0x8B, 0x4E, 0x01}},
+		{x86.R9, x86.R6, 1, 2, []byte{0x66, 0x44, 0x8B, 0x4E, 0x01}},
+		{x86.R9, x86.R6, 1, 1, []byte{0x44, 0x8A, 0x4E, 0x01}},
+		{x86.R10, x86.R5, 1, 8, []byte{0x4C, 0x8B, 0x55, 0x01}},
+		{x86.R10, x86.R5, 1, 4, []byte{0x44, 0x8B, 0x55, 0x01}},
+		{x86.R10, x86.R5, 1, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x01}},
+		{x86.R10, x86.R5, 1, 1, []byte{0x44, 0x8A, 0x55, 0x01}},
+		{x86.R11, x86.SP, 1, 8, []byte{0x4C, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R11, x86.SP, 1, 4, []byte{0x44, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R11, x86.SP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x5C, 0x24, 0x01}},
+		{x86.R11, x86.SP, 1, 1, []byte{0x44, 0x8A, 0x5C, 0x24, 0x01}},
+		{x86.R12, x86.R3, 1, 8, []byte{0x4C, 0x8B, 0x63, 0x01}},
+		{x86.R12, x86.R3, 1, 4, []byte{0x44, 0x8B, 0x63, 0x01}},
+		{x86.R12, x86.R3, 1, 2, []byte{0x66, 0x44, 0x8B, 0x63, 0x01}},
+		{x86.R12, x86.R3, 1, 1, []byte{0x44, 0x8A, 0x63, 0x01}},
+		{x86.R13, x86.R2, 1, 8, []byte{0x4C, 0x8B, 0x6A, 0x01}},
+		{x86.R13, x86.R2, 1, 4, []byte{0x44, 0x8B, 0x6A, 0x01}},
+		{x86.R13, x86.R2, 1, 2, []byte{0x66, 0x44, 0x8B, 0x6A, 0x01}},
+		{x86.R13, x86.R2, 1, 1, []byte{0x44, 0x8A, 0x6A, 0x01}},
+		{x86.R14, x86.R1, 1, 8, []byte{0x4C, 0x8B, 0x71, 0x01}},
+		{x86.R14, x86.R1, 1, 4, []byte{0x44, 0x8B, 0x71, 0x01}},
+		{x86.R14, x86.R1, 1, 2, []byte{0x66, 0x44, 0x8B, 0x71, 0x01}},
+		{x86.R14, x86.R1, 1, 1, []byte{0x44, 0x8A, 0x71, 0x01}},
+		{x86.R15, x86.R0, 1, 8, []byte{0x4C, 0x8B, 0x78, 0x01}},
+		{x86.R15, x86.R0, 1, 4, []byte{0x44, 0x8B, 0x78, 0x01}},
+		{x86.R15, x86.R0, 1, 2, []byte{0x66, 0x44, 0x8B, 0x78, 0x01}},
+		{x86.R15, x86.R0, 1, 1, []byte{0x44, 0x8A, 0x78, 0x01}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Move_test.go b/src/x86/Move_test.go
index 9ac8318..803a418 100644
--- a/src/x86/Move_test.go
+++ b/src/x86/Move_test.go
@@ -15,14 +15,14 @@ func TestMoveRegisterNumber(t *testing.T) {
 		Code     []byte
 	}{
 		// 32 bits
-		{x86.RAX, 0x7FFFFFFF, []byte{0xB8, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0xB9, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0xBA, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0xBB, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0xBC, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0xBD, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0xBE, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0xB8, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0xB9, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0xBA, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0xBB, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0xBC, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0xBD, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0xBE, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x41, 0xB8, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x41, 0xB9, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x41, 0xBA, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -33,14 +33,14 @@ func TestMoveRegisterNumber(t *testing.T) {
 		{x86.R15, 0x7FFFFFFF, []byte{0x41, 0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
 
 		// 64 bits
-		{x86.RAX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -51,14 +51,14 @@ func TestMoveRegisterNumber(t *testing.T) {
 		{x86.R15, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 
 		// Negative numbers
-		{x86.RAX, -1, []byte{0x48, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RCX, -1, []byte{0x48, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RDX, -1, []byte{0x48, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RBX, -1, []byte{0x48, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RSP, -1, []byte{0x48, 0xC7, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RBP, -1, []byte{0x48, 0xC7, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RSI, -1, []byte{0x48, 0xC7, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF}},
-		{x86.RDI, -1, []byte{0x48, 0xC7, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R0, -1, []byte{0x48, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R1, -1, []byte{0x48, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R2, -1, []byte{0x48, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R3, -1, []byte{0x48, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.SP, -1, []byte{0x48, 0xC7, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R5, -1, []byte{0x48, 0xC7, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R6, -1, []byte{0x48, 0xC7, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF}},
+		{x86.R7, -1, []byte{0x48, 0xC7, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF}},
 		{x86.R8, -1, []byte{0x49, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}},
 		{x86.R9, -1, []byte{0x49, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}},
 		{x86.R10, -1, []byte{0x49, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}},
@@ -82,22 +82,22 @@ func TestMoveRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x89, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x89, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x89, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x89, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x89, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x89, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x89, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x89, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x89, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x89, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x89, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x89, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x89, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x89, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x89, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x89, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x89, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x89, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x89, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x89, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x89, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x89, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x89, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x89, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x89, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x89, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x89, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x89, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x89, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x89, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x89, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x89, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Mul_test.go b/src/x86/Mul_test.go
index cfde232..5584ede 100644
--- a/src/x86/Mul_test.go
+++ b/src/x86/Mul_test.go
@@ -14,14 +14,14 @@ func TestMulRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x6B, 0xC0, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x6B, 0xC9, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x6B, 0xD2, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x6B, 0xDB, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x6B, 0xE4, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x6B, 0xED, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x6B, 0xF6, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x6B, 0xFF, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x6B, 0xC0, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x6B, 0xC9, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x6B, 0xD2, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x6B, 0xDB, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x6B, 0xE4, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x6B, 0xED, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x6B, 0xF6, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x6B, 0xFF, 0x01}},
 		{x86.R8, 1, []byte{0x4D, 0x6B, 0xC0, 0x01}},
 		{x86.R9, 1, []byte{0x4D, 0x6B, 0xC9, 0x01}},
 		{x86.R10, 1, []byte{0x4D, 0x6B, 0xD2, 0x01}},
@@ -31,14 +31,14 @@ func TestMulRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x4D, 0x6B, 0xF6, 0x01}},
 		{x86.R15, 1, []byte{0x4D, 0x6B, 0xFF, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xDB, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x69, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x69, 0xDB, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x69, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x69, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestMulRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x49, 0x0F, 0xAF, 0xC7}},
-		{x86.RCX, x86.R14, []byte{0x49, 0x0F, 0xAF, 0xCE}},
-		{x86.RDX, x86.R13, []byte{0x49, 0x0F, 0xAF, 0xD5}},
-		{x86.RBX, x86.R12, []byte{0x49, 0x0F, 0xAF, 0xDC}},
-		{x86.RSP, x86.R11, []byte{0x49, 0x0F, 0xAF, 0xE3}},
-		{x86.RBP, x86.R10, []byte{0x49, 0x0F, 0xAF, 0xEA}},
-		{x86.RSI, x86.R9, []byte{0x49, 0x0F, 0xAF, 0xF1}},
-		{x86.RDI, x86.R8, []byte{0x49, 0x0F, 0xAF, 0xF8}},
-		{x86.R8, x86.RDI, []byte{0x4C, 0x0F, 0xAF, 0xC7}},
-		{x86.R9, x86.RSI, []byte{0x4C, 0x0F, 0xAF, 0xCE}},
-		{x86.R10, x86.RBP, []byte{0x4C, 0x0F, 0xAF, 0xD5}},
-		{x86.R11, x86.RSP, []byte{0x4C, 0x0F, 0xAF, 0xDC}},
-		{x86.R12, x86.RBX, []byte{0x4C, 0x0F, 0xAF, 0xE3}},
-		{x86.R13, x86.RDX, []byte{0x4C, 0x0F, 0xAF, 0xEA}},
-		{x86.R14, x86.RCX, []byte{0x4C, 0x0F, 0xAF, 0xF1}},
-		{x86.R15, x86.RAX, []byte{0x4C, 0x0F, 0xAF, 0xF8}},
+		{x86.R0, x86.R15, []byte{0x49, 0x0F, 0xAF, 0xC7}},
+		{x86.R1, x86.R14, []byte{0x49, 0x0F, 0xAF, 0xCE}},
+		{x86.R2, x86.R13, []byte{0x49, 0x0F, 0xAF, 0xD5}},
+		{x86.R3, x86.R12, []byte{0x49, 0x0F, 0xAF, 0xDC}},
+		{x86.SP, x86.R11, []byte{0x49, 0x0F, 0xAF, 0xE3}},
+		{x86.R5, x86.R10, []byte{0x49, 0x0F, 0xAF, 0xEA}},
+		{x86.R6, x86.R9, []byte{0x49, 0x0F, 0xAF, 0xF1}},
+		{x86.R7, x86.R8, []byte{0x49, 0x0F, 0xAF, 0xF8}},
+		{x86.R8, x86.R7, []byte{0x4C, 0x0F, 0xAF, 0xC7}},
+		{x86.R9, x86.R6, []byte{0x4C, 0x0F, 0xAF, 0xCE}},
+		{x86.R10, x86.R5, []byte{0x4C, 0x0F, 0xAF, 0xD5}},
+		{x86.R11, x86.SP, []byte{0x4C, 0x0F, 0xAF, 0xDC}},
+		{x86.R12, x86.R3, []byte{0x4C, 0x0F, 0xAF, 0xE3}},
+		{x86.R13, x86.R2, []byte{0x4C, 0x0F, 0xAF, 0xEA}},
+		{x86.R14, x86.R1, []byte{0x4C, 0x0F, 0xAF, 0xF1}},
+		{x86.R15, x86.R0, []byte{0x4C, 0x0F, 0xAF, 0xF8}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Negate_test.go b/src/x86/Negate_test.go
index df02835..b982850 100644
--- a/src/x86/Negate_test.go
+++ b/src/x86/Negate_test.go
@@ -13,14 +13,14 @@ func TestNegateRegister(t *testing.T) {
 		Register cpu.Register
 		Code     []byte
 	}{
-		{x86.RAX, []byte{0x48, 0xF7, 0xD8}},
-		{x86.RCX, []byte{0x48, 0xF7, 0xD9}},
-		{x86.RDX, []byte{0x48, 0xF7, 0xDA}},
-		{x86.RBX, []byte{0x48, 0xF7, 0xDB}},
-		{x86.RSP, []byte{0x48, 0xF7, 0xDC}},
-		{x86.RBP, []byte{0x48, 0xF7, 0xDD}},
-		{x86.RSI, []byte{0x48, 0xF7, 0xDE}},
-		{x86.RDI, []byte{0x48, 0xF7, 0xDF}},
+		{x86.R0, []byte{0x48, 0xF7, 0xD8}},
+		{x86.R1, []byte{0x48, 0xF7, 0xD9}},
+		{x86.R2, []byte{0x48, 0xF7, 0xDA}},
+		{x86.R3, []byte{0x48, 0xF7, 0xDB}},
+		{x86.SP, []byte{0x48, 0xF7, 0xDC}},
+		{x86.R5, []byte{0x48, 0xF7, 0xDD}},
+		{x86.R6, []byte{0x48, 0xF7, 0xDE}},
+		{x86.R7, []byte{0x48, 0xF7, 0xDF}},
 		{x86.R8, []byte{0x49, 0xF7, 0xD8}},
 		{x86.R9, []byte{0x49, 0xF7, 0xD9}},
 		{x86.R10, []byte{0x49, 0xF7, 0xDA}},
diff --git a/src/x86/Or_test.go b/src/x86/Or_test.go
index bac71e4..0c4431e 100644
--- a/src/x86/Or_test.go
+++ b/src/x86/Or_test.go
@@ -14,14 +14,14 @@ func TestOrRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xC8, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xC9, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xCA, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xCB, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xCC, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xCD, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xCE, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xCF, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xC8, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xC9, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xCA, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xCB, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xCC, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xCD, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xCE, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xCF, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xC8, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xC9, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xCA, 0x01}},
@@ -31,14 +31,14 @@ func TestOrRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xCE, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xCF, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCB, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCC, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCD, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCE, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCB, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCC, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCD, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCE, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestOrRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x09, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x09, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x09, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x09, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x09, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x09, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x09, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x09, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x09, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x09, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x09, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x09, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x09, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x09, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x09, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x09, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x09, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x09, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x09, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x09, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x09, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x09, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x09, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x09, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x09, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x09, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x09, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x09, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x09, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x09, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x09, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x09, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Pop_test.go b/src/x86/Pop_test.go
index 65cb1aa..c01a1ee 100644
--- a/src/x86/Pop_test.go
+++ b/src/x86/Pop_test.go
@@ -13,14 +13,14 @@ func TestPopRegister(t *testing.T) {
 		Register cpu.Register
 		Code     []byte
 	}{
-		{x86.RAX, []byte{0x58}},
-		{x86.RCX, []byte{0x59}},
-		{x86.RDX, []byte{0x5A}},
-		{x86.RBX, []byte{0x5B}},
-		{x86.RSP, []byte{0x5C}},
-		{x86.RBP, []byte{0x5D}},
-		{x86.RSI, []byte{0x5E}},
-		{x86.RDI, []byte{0x5F}},
+		{x86.R0, []byte{0x58}},
+		{x86.R1, []byte{0x59}},
+		{x86.R2, []byte{0x5A}},
+		{x86.R3, []byte{0x5B}},
+		{x86.SP, []byte{0x5C}},
+		{x86.R5, []byte{0x5D}},
+		{x86.R6, []byte{0x5E}},
+		{x86.R7, []byte{0x5F}},
 		{x86.R8, []byte{0x41, 0x58}},
 		{x86.R9, []byte{0x41, 0x59}},
 		{x86.R10, []byte{0x41, 0x5A}},
diff --git a/src/x86/Push_test.go b/src/x86/Push_test.go
index 138478d..c7f79dc 100644
--- a/src/x86/Push_test.go
+++ b/src/x86/Push_test.go
@@ -35,14 +35,14 @@ func TestPushRegister(t *testing.T) {
 		Register cpu.Register
 		Code     []byte
 	}{
-		{x86.RAX, []byte{0x50}},
-		{x86.RCX, []byte{0x51}},
-		{x86.RDX, []byte{0x52}},
-		{x86.RBX, []byte{0x53}},
-		{x86.RSP, []byte{0x54}},
-		{x86.RBP, []byte{0x55}},
-		{x86.RSI, []byte{0x56}},
-		{x86.RDI, []byte{0x57}},
+		{x86.R0, []byte{0x50}},
+		{x86.R1, []byte{0x51}},
+		{x86.R2, []byte{0x52}},
+		{x86.R3, []byte{0x53}},
+		{x86.SP, []byte{0x54}},
+		{x86.R5, []byte{0x55}},
+		{x86.R6, []byte{0x56}},
+		{x86.R7, []byte{0x57}},
 		{x86.R8, []byte{0x41, 0x50}},
 		{x86.R9, []byte{0x41, 0x51}},
 		{x86.R10, []byte{0x41, 0x52}},
diff --git a/src/x86/Registers.go b/src/x86/Registers.go
index ab31583..3e2958d 100644
--- a/src/x86/Registers.go
+++ b/src/x86/Registers.go
@@ -3,14 +3,14 @@ package x86
 import "git.urbach.dev/cli/q/src/cpu"
 
 const (
-	RAX cpu.Register = iota
-	RCX
-	RDX
-	RBX
-	RSP
-	RBP
-	RSI
-	RDI
+	R0 cpu.Register = iota // RAX
+	R1                     // RCX
+	R2                     // RDX
+	R3                     // RBX
+	SP                     // Stack pointer
+	R5                     // RBP
+	R6                     // RSI
+	R7                     // RDI
 	R8
 	R9
 	R10
@@ -19,25 +19,21 @@ const (
 	R13
 	R14
 	R15
-	TMP = RCX
+	TMP = R1
 )
 
 var (
-	SyscallInputRegisters    = []cpu.Register{RAX, RDI, RSI, RDX, R10, R8, R9}
-	SyscallOutputRegisters   = []cpu.Register{RAX, RCX, R11}
-	GeneralRegisters         = []cpu.Register{RBX, R12, R13, R14, R15, R11}
-	InputRegisters           = SyscallInputRegisters
-	OutputRegisters          = SyscallInputRegisters
-	WindowsInputRegisters    = []cpu.Register{RCX, RDX, R8, R9}
-	WindowsOutputRegisters   = []cpu.Register{RAX}
-	WindowsVolatileRegisters = []cpu.Register{RCX, RDX, R8, R9, R10, R11}
+	SyscallInputRegisters    = []cpu.Register{R0, R7, R6, R2, R10, R8, R9}
+	WindowsInputRegisters    = []cpu.Register{R1, R2, R8, R9}
+	WindowsOutputRegisters   = []cpu.Register{R0}
+	WindowsVolatileRegisters = []cpu.Register{R1, R2, R8, R9, R10, R11}
 
 	CPU = cpu.CPU{
-		General:       GeneralRegisters,
-		Input:         InputRegisters,
-		Output:        OutputRegisters,
+		General:       []cpu.Register{R3, R12, R13, R14, R15, R11},
+		Input:         SyscallInputRegisters,
+		Output:        SyscallInputRegisters,
 		SyscallInput:  SyscallInputRegisters,
-		SyscallOutput: SyscallOutputRegisters,
+		SyscallOutput: []cpu.Register{R0, R1, R11},
 		NumRegisters:  16,
 	}
 )
diff --git a/src/x86/Registers_test.go b/src/x86/Registers_test.go
index d1aadad..91eb96d 100644
--- a/src/x86/Registers_test.go
+++ b/src/x86/Registers_test.go
@@ -8,5 +8,5 @@ import (
 )
 
 func TestRegisters(t *testing.T) {
-	assert.NotContains(t, x86.GeneralRegisters, x86.RSP)
+	assert.NotContains(t, x86.CPU.General, x86.SP)
 }
diff --git a/src/x86/Shift_test.go b/src/x86/Shift_test.go
index 19fa94a..a65fb7b 100644
--- a/src/x86/Shift_test.go
+++ b/src/x86/Shift_test.go
@@ -14,14 +14,14 @@ func TestShiftLeftNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0xC1, 0xE0, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0xC1, 0xE1, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0xC1, 0xE2, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0xC1, 0xE3, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0xC1, 0xE4, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0xC1, 0xE5, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0xC1, 0xE6, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0xC1, 0xE7, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0xC1, 0xE0, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0xC1, 0xE1, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0xC1, 0xE2, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0xC1, 0xE3, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0xC1, 0xE4, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0xC1, 0xE5, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0xC1, 0xE6, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0xC1, 0xE7, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0xC1, 0xE0, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0xC1, 0xE1, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0xC1, 0xE2, 0x01}},
@@ -45,14 +45,14 @@ func TestShiftRightSignedNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0xC1, 0xF8, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0xC1, 0xF9, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0xC1, 0xFA, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0xC1, 0xFB, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0xC1, 0xFC, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0xC1, 0xFD, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0xC1, 0xFE, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0xC1, 0xFF, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0xC1, 0xF8, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0xC1, 0xF9, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0xC1, 0xFA, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0xC1, 0xFB, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0xC1, 0xFC, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0xC1, 0xFD, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0xC1, 0xFE, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0xC1, 0xFF, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0xC1, 0xF8, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0xC1, 0xF9, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0xC1, 0xFA, 0x01}},
diff --git a/src/x86/StoreDynamic_test.go b/src/x86/StoreDynamic_test.go
index 2e55105..cc0756e 100644
--- a/src/x86/StoreDynamic_test.go
+++ b/src/x86/StoreDynamic_test.go
@@ -16,70 +16,70 @@ func TestStoreDynamicNumber(t *testing.T) {
 		Number     int
 		Code       []byte
 	}{
-		{x86.RAX, x86.R15, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, x86.R15, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, x86.R15, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
-		{x86.RAX, x86.R15, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x38, 0x7F}},
-		{x86.RCX, x86.R14, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, x86.R14, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, x86.R14, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
-		{x86.RCX, x86.R14, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x31, 0x7F}},
-		{x86.RDX, x86.R13, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, x86.R13, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, x86.R13, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
-		{x86.RDX, x86.R13, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x2A, 0x7F}},
-		{x86.RBX, x86.R12, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, x86.R12, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, x86.R12, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00}},
-		{x86.RBX, x86.R12, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x23, 0x7F}},
-		{x86.RSP, x86.R11, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, x86.R11, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, x86.R11, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
-		{x86.RSP, x86.R11, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
-		{x86.RBP, x86.R10, 8, 0x7F, []byte{0x4A, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, x86.R10, 4, 0x7F, []byte{0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, x86.R10, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
-		{x86.RBP, x86.R10, 1, 0x7F, []byte{0x42, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
-		{x86.RSI, x86.R9, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, x86.R9, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, x86.R9, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
-		{x86.RSI, x86.R9, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x0E, 0x7F}},
-		{x86.RDI, x86.R8, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, x86.R8, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, x86.R8, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
-		{x86.RDI, x86.R8, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x07, 0x7F}},
-		{x86.R8, x86.RDI, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R8, x86.RDI, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R8, x86.RDI, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
-		{x86.R8, x86.RDI, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x38, 0x7F}},
-		{x86.R9, x86.RSI, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R9, x86.RSI, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R9, x86.RSI, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
-		{x86.R9, x86.RSI, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x31, 0x7F}},
-		{x86.R10, x86.RBP, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R10, x86.RBP, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R10, x86.RBP, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
-		{x86.R10, x86.RBP, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x2A, 0x7F}},
-		{x86.R11, x86.RSP, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R11, x86.RSP, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R11, x86.RSP, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
-		{x86.R11, x86.RSP, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
-		{x86.R12, x86.RBX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R12, x86.RBX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R12, x86.RBX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
-		{x86.R12, x86.RBX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x1C, 0x7F}},
-		{x86.R13, x86.RDX, 8, 0x7F, []byte{0x49, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R13, x86.RDX, 4, 0x7F, []byte{0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R13, x86.RDX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
-		{x86.R13, x86.RDX, 1, 0x7F, []byte{0x41, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
-		{x86.R14, x86.RCX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R14, x86.RCX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R14, x86.RCX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
-		{x86.R14, x86.RCX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x0E, 0x7F}},
-		{x86.R15, x86.RAX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R15, x86.RAX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.R15, x86.RAX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
-		{x86.R15, x86.RAX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x07, 0x7F}},
+		{x86.R0, x86.R15, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, x86.R15, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, x86.R15, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
+		{x86.R0, x86.R15, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x38, 0x7F}},
+		{x86.R1, x86.R14, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, x86.R14, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, x86.R14, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
+		{x86.R1, x86.R14, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x31, 0x7F}},
+		{x86.R2, x86.R13, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, x86.R13, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, x86.R13, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
+		{x86.R2, x86.R13, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x2A, 0x7F}},
+		{x86.R3, x86.R12, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, x86.R12, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, x86.R12, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00}},
+		{x86.R3, x86.R12, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x23, 0x7F}},
+		{x86.SP, x86.R11, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, x86.R11, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, x86.R11, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
+		{x86.SP, x86.R11, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
+		{x86.R5, x86.R10, 8, 0x7F, []byte{0x4A, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, x86.R10, 4, 0x7F, []byte{0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, x86.R10, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
+		{x86.R5, x86.R10, 1, 0x7F, []byte{0x42, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
+		{x86.R6, x86.R9, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, x86.R9, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, x86.R9, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
+		{x86.R6, x86.R9, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x0E, 0x7F}},
+		{x86.R7, x86.R8, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, x86.R8, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, x86.R8, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
+		{x86.R7, x86.R8, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x07, 0x7F}},
+		{x86.R8, x86.R7, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R8, x86.R7, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R8, x86.R7, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
+		{x86.R8, x86.R7, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x38, 0x7F}},
+		{x86.R9, x86.R6, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R9, x86.R6, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R9, x86.R6, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
+		{x86.R9, x86.R6, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x31, 0x7F}},
+		{x86.R10, x86.R5, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R10, x86.R5, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R10, x86.R5, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
+		{x86.R10, x86.R5, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x2A, 0x7F}},
+		{x86.R11, x86.SP, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R11, x86.SP, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R11, x86.SP, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
+		{x86.R11, x86.SP, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
+		{x86.R12, x86.R3, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R12, x86.R3, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R12, x86.R3, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
+		{x86.R12, x86.R3, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x1C, 0x7F}},
+		{x86.R13, x86.R2, 8, 0x7F, []byte{0x49, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R13, x86.R2, 4, 0x7F, []byte{0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R13, x86.R2, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
+		{x86.R13, x86.R2, 1, 0x7F, []byte{0x41, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
+		{x86.R14, x86.R1, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R14, x86.R1, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R14, x86.R1, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
+		{x86.R14, x86.R1, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x0E, 0x7F}},
+		{x86.R15, x86.R0, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R15, x86.R0, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R15, x86.R0, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
+		{x86.R15, x86.R0, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x07, 0x7F}},
 	}
 
 	for _, pattern := range usagePatterns {
@@ -97,70 +97,70 @@ func TestStoreDynamicRegister(t *testing.T) {
 		RegisterFrom cpu.Register
 		Code         []byte
 	}{
-		{x86.RAX, x86.R15, 8, x86.R15, []byte{0x4E, 0x89, 0x3C, 0x38}},
-		{x86.RAX, x86.R15, 4, x86.R15, []byte{0x46, 0x89, 0x3C, 0x38}},
-		{x86.RAX, x86.R15, 2, x86.R15, []byte{0x66, 0x46, 0x89, 0x3C, 0x38}},
-		{x86.RAX, x86.R15, 1, x86.R15, []byte{0x46, 0x88, 0x3C, 0x38}},
-		{x86.RCX, x86.R14, 8, x86.R14, []byte{0x4E, 0x89, 0x34, 0x31}},
-		{x86.RCX, x86.R14, 4, x86.R14, []byte{0x46, 0x89, 0x34, 0x31}},
-		{x86.RCX, x86.R14, 2, x86.R14, []byte{0x66, 0x46, 0x89, 0x34, 0x31}},
-		{x86.RCX, x86.R14, 1, x86.R14, []byte{0x46, 0x88, 0x34, 0x31}},
-		{x86.RDX, x86.R13, 8, x86.R13, []byte{0x4E, 0x89, 0x2C, 0x2A}},
-		{x86.RDX, x86.R13, 4, x86.R13, []byte{0x46, 0x89, 0x2C, 0x2A}},
-		{x86.RDX, x86.R13, 2, x86.R13, []byte{0x66, 0x46, 0x89, 0x2C, 0x2A}},
-		{x86.RDX, x86.R13, 1, x86.R13, []byte{0x46, 0x88, 0x2C, 0x2A}},
-		{x86.RBX, x86.R12, 8, x86.R12, []byte{0x4E, 0x89, 0x24, 0x23}},
-		{x86.RBX, x86.R12, 4, x86.R12, []byte{0x46, 0x89, 0x24, 0x23}},
-		{x86.RBX, x86.R12, 2, x86.R12, []byte{0x66, 0x46, 0x89, 0x24, 0x23}},
-		{x86.RBX, x86.R12, 1, x86.R12, []byte{0x46, 0x88, 0x24, 0x23}},
-		{x86.RSP, x86.R11, 8, x86.R11, []byte{0x4E, 0x89, 0x1C, 0x1C}},
-		{x86.RSP, x86.R11, 4, x86.R11, []byte{0x46, 0x89, 0x1C, 0x1C}},
-		{x86.RSP, x86.R11, 2, x86.R11, []byte{0x66, 0x46, 0x89, 0x1C, 0x1C}},
-		{x86.RSP, x86.R11, 1, x86.R11, []byte{0x46, 0x88, 0x1C, 0x1C}},
-		{x86.RBP, x86.R10, 8, x86.R10, []byte{0x4E, 0x89, 0x54, 0x15, 0x00}},
-		{x86.RBP, x86.R10, 4, x86.R10, []byte{0x46, 0x89, 0x54, 0x15, 0x00}},
-		{x86.RBP, x86.R10, 2, x86.R10, []byte{0x66, 0x46, 0x89, 0x54, 0x15, 0x00}},
-		{x86.RBP, x86.R10, 1, x86.R10, []byte{0x46, 0x88, 0x54, 0x15, 0x00}},
-		{x86.RSI, x86.R9, 8, x86.R9, []byte{0x4E, 0x89, 0x0C, 0x0E}},
-		{x86.RSI, x86.R9, 4, x86.R9, []byte{0x46, 0x89, 0x0C, 0x0E}},
-		{x86.RSI, x86.R9, 2, x86.R9, []byte{0x66, 0x46, 0x89, 0x0C, 0x0E}},
-		{x86.RSI, x86.R9, 1, x86.R9, []byte{0x46, 0x88, 0x0C, 0x0E}},
-		{x86.RDI, x86.R8, 8, x86.R8, []byte{0x4E, 0x89, 0x04, 0x07}},
-		{x86.RDI, x86.R8, 4, x86.R8, []byte{0x46, 0x89, 0x04, 0x07}},
-		{x86.RDI, x86.R8, 2, x86.R8, []byte{0x66, 0x46, 0x89, 0x04, 0x07}},
-		{x86.RDI, x86.R8, 1, x86.R8, []byte{0x46, 0x88, 0x04, 0x07}},
-		{x86.R8, x86.RDI, 8, x86.RDI, []byte{0x49, 0x89, 0x3C, 0x38}},
-		{x86.R8, x86.RDI, 4, x86.RDI, []byte{0x41, 0x89, 0x3C, 0x38}},
-		{x86.R8, x86.RDI, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x3C, 0x38}},
-		{x86.R8, x86.RDI, 1, x86.RDI, []byte{0x41, 0x88, 0x3C, 0x38}},
-		{x86.R9, x86.RSI, 8, x86.RSI, []byte{0x49, 0x89, 0x34, 0x31}},
-		{x86.R9, x86.RSI, 4, x86.RSI, []byte{0x41, 0x89, 0x34, 0x31}},
-		{x86.R9, x86.RSI, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x34, 0x31}},
-		{x86.R9, x86.RSI, 1, x86.RSI, []byte{0x41, 0x88, 0x34, 0x31}},
-		{x86.R10, x86.RBP, 8, x86.RBP, []byte{0x49, 0x89, 0x2C, 0x2A}},
-		{x86.R10, x86.RBP, 4, x86.RBP, []byte{0x41, 0x89, 0x2C, 0x2A}},
-		{x86.R10, x86.RBP, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x2C, 0x2A}},
-		{x86.R10, x86.RBP, 1, x86.RBP, []byte{0x41, 0x88, 0x2C, 0x2A}},
-		{x86.R11, x86.RSP, 8, x86.RSP, []byte{0x4A, 0x89, 0x24, 0x1C}},
-		{x86.R11, x86.RSP, 4, x86.RSP, []byte{0x42, 0x89, 0x24, 0x1C}},
-		{x86.R11, x86.RSP, 2, x86.RSP, []byte{0x66, 0x42, 0x89, 0x24, 0x1C}},
-		{x86.R11, x86.RSP, 1, x86.RSP, []byte{0x42, 0x88, 0x24, 0x1C}},
-		{x86.R12, x86.RBX, 8, x86.RBX, []byte{0x49, 0x89, 0x1C, 0x1C}},
-		{x86.R12, x86.RBX, 4, x86.RBX, []byte{0x41, 0x89, 0x1C, 0x1C}},
-		{x86.R12, x86.RBX, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x1C, 0x1C}},
-		{x86.R12, x86.RBX, 1, x86.RBX, []byte{0x41, 0x88, 0x1C, 0x1C}},
-		{x86.R13, x86.RDX, 8, x86.RDX, []byte{0x49, 0x89, 0x54, 0x15, 0x00}},
-		{x86.R13, x86.RDX, 4, x86.RDX, []byte{0x41, 0x89, 0x54, 0x15, 0x00}},
-		{x86.R13, x86.RDX, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x54, 0x15, 0x00}},
-		{x86.R13, x86.RDX, 1, x86.RDX, []byte{0x41, 0x88, 0x54, 0x15, 0x00}},
-		{x86.R14, x86.RCX, 8, x86.RCX, []byte{0x49, 0x89, 0x0C, 0x0E}},
-		{x86.R14, x86.RCX, 4, x86.RCX, []byte{0x41, 0x89, 0x0C, 0x0E}},
-		{x86.R14, x86.RCX, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x0C, 0x0E}},
-		{x86.R14, x86.RCX, 1, x86.RCX, []byte{0x41, 0x88, 0x0C, 0x0E}},
-		{x86.R15, x86.RAX, 8, x86.RAX, []byte{0x49, 0x89, 0x04, 0x07}},
-		{x86.R15, x86.RAX, 4, x86.RAX, []byte{0x41, 0x89, 0x04, 0x07}},
-		{x86.R15, x86.RAX, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x04, 0x07}},
-		{x86.R15, x86.RAX, 1, x86.RAX, []byte{0x41, 0x88, 0x04, 0x07}},
+		{x86.R0, x86.R15, 8, x86.R15, []byte{0x4E, 0x89, 0x3C, 0x38}},
+		{x86.R0, x86.R15, 4, x86.R15, []byte{0x46, 0x89, 0x3C, 0x38}},
+		{x86.R0, x86.R15, 2, x86.R15, []byte{0x66, 0x46, 0x89, 0x3C, 0x38}},
+		{x86.R0, x86.R15, 1, x86.R15, []byte{0x46, 0x88, 0x3C, 0x38}},
+		{x86.R1, x86.R14, 8, x86.R14, []byte{0x4E, 0x89, 0x34, 0x31}},
+		{x86.R1, x86.R14, 4, x86.R14, []byte{0x46, 0x89, 0x34, 0x31}},
+		{x86.R1, x86.R14, 2, x86.R14, []byte{0x66, 0x46, 0x89, 0x34, 0x31}},
+		{x86.R1, x86.R14, 1, x86.R14, []byte{0x46, 0x88, 0x34, 0x31}},
+		{x86.R2, x86.R13, 8, x86.R13, []byte{0x4E, 0x89, 0x2C, 0x2A}},
+		{x86.R2, x86.R13, 4, x86.R13, []byte{0x46, 0x89, 0x2C, 0x2A}},
+		{x86.R2, x86.R13, 2, x86.R13, []byte{0x66, 0x46, 0x89, 0x2C, 0x2A}},
+		{x86.R2, x86.R13, 1, x86.R13, []byte{0x46, 0x88, 0x2C, 0x2A}},
+		{x86.R3, x86.R12, 8, x86.R12, []byte{0x4E, 0x89, 0x24, 0x23}},
+		{x86.R3, x86.R12, 4, x86.R12, []byte{0x46, 0x89, 0x24, 0x23}},
+		{x86.R3, x86.R12, 2, x86.R12, []byte{0x66, 0x46, 0x89, 0x24, 0x23}},
+		{x86.R3, x86.R12, 1, x86.R12, []byte{0x46, 0x88, 0x24, 0x23}},
+		{x86.SP, x86.R11, 8, x86.R11, []byte{0x4E, 0x89, 0x1C, 0x1C}},
+		{x86.SP, x86.R11, 4, x86.R11, []byte{0x46, 0x89, 0x1C, 0x1C}},
+		{x86.SP, x86.R11, 2, x86.R11, []byte{0x66, 0x46, 0x89, 0x1C, 0x1C}},
+		{x86.SP, x86.R11, 1, x86.R11, []byte{0x46, 0x88, 0x1C, 0x1C}},
+		{x86.R5, x86.R10, 8, x86.R10, []byte{0x4E, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R5, x86.R10, 4, x86.R10, []byte{0x46, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R5, x86.R10, 2, x86.R10, []byte{0x66, 0x46, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R5, x86.R10, 1, x86.R10, []byte{0x46, 0x88, 0x54, 0x15, 0x00}},
+		{x86.R6, x86.R9, 8, x86.R9, []byte{0x4E, 0x89, 0x0C, 0x0E}},
+		{x86.R6, x86.R9, 4, x86.R9, []byte{0x46, 0x89, 0x0C, 0x0E}},
+		{x86.R6, x86.R9, 2, x86.R9, []byte{0x66, 0x46, 0x89, 0x0C, 0x0E}},
+		{x86.R6, x86.R9, 1, x86.R9, []byte{0x46, 0x88, 0x0C, 0x0E}},
+		{x86.R7, x86.R8, 8, x86.R8, []byte{0x4E, 0x89, 0x04, 0x07}},
+		{x86.R7, x86.R8, 4, x86.R8, []byte{0x46, 0x89, 0x04, 0x07}},
+		{x86.R7, x86.R8, 2, x86.R8, []byte{0x66, 0x46, 0x89, 0x04, 0x07}},
+		{x86.R7, x86.R8, 1, x86.R8, []byte{0x46, 0x88, 0x04, 0x07}},
+		{x86.R8, x86.R7, 8, x86.R7, []byte{0x49, 0x89, 0x3C, 0x38}},
+		{x86.R8, x86.R7, 4, x86.R7, []byte{0x41, 0x89, 0x3C, 0x38}},
+		{x86.R8, x86.R7, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x3C, 0x38}},
+		{x86.R8, x86.R7, 1, x86.R7, []byte{0x41, 0x88, 0x3C, 0x38}},
+		{x86.R9, x86.R6, 8, x86.R6, []byte{0x49, 0x89, 0x34, 0x31}},
+		{x86.R9, x86.R6, 4, x86.R6, []byte{0x41, 0x89, 0x34, 0x31}},
+		{x86.R9, x86.R6, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x34, 0x31}},
+		{x86.R9, x86.R6, 1, x86.R6, []byte{0x41, 0x88, 0x34, 0x31}},
+		{x86.R10, x86.R5, 8, x86.R5, []byte{0x49, 0x89, 0x2C, 0x2A}},
+		{x86.R10, x86.R5, 4, x86.R5, []byte{0x41, 0x89, 0x2C, 0x2A}},
+		{x86.R10, x86.R5, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x2C, 0x2A}},
+		{x86.R10, x86.R5, 1, x86.R5, []byte{0x41, 0x88, 0x2C, 0x2A}},
+		{x86.R11, x86.SP, 8, x86.SP, []byte{0x4A, 0x89, 0x24, 0x1C}},
+		{x86.R11, x86.SP, 4, x86.SP, []byte{0x42, 0x89, 0x24, 0x1C}},
+		{x86.R11, x86.SP, 2, x86.SP, []byte{0x66, 0x42, 0x89, 0x24, 0x1C}},
+		{x86.R11, x86.SP, 1, x86.SP, []byte{0x42, 0x88, 0x24, 0x1C}},
+		{x86.R12, x86.R3, 8, x86.R3, []byte{0x49, 0x89, 0x1C, 0x1C}},
+		{x86.R12, x86.R3, 4, x86.R3, []byte{0x41, 0x89, 0x1C, 0x1C}},
+		{x86.R12, x86.R3, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x1C, 0x1C}},
+		{x86.R12, x86.R3, 1, x86.R3, []byte{0x41, 0x88, 0x1C, 0x1C}},
+		{x86.R13, x86.R2, 8, x86.R2, []byte{0x49, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R13, x86.R2, 4, x86.R2, []byte{0x41, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R13, x86.R2, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x54, 0x15, 0x00}},
+		{x86.R13, x86.R2, 1, x86.R2, []byte{0x41, 0x88, 0x54, 0x15, 0x00}},
+		{x86.R14, x86.R1, 8, x86.R1, []byte{0x49, 0x89, 0x0C, 0x0E}},
+		{x86.R14, x86.R1, 4, x86.R1, []byte{0x41, 0x89, 0x0C, 0x0E}},
+		{x86.R14, x86.R1, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x0C, 0x0E}},
+		{x86.R14, x86.R1, 1, x86.R1, []byte{0x41, 0x88, 0x0C, 0x0E}},
+		{x86.R15, x86.R0, 8, x86.R0, []byte{0x49, 0x89, 0x04, 0x07}},
+		{x86.R15, x86.R0, 4, x86.R0, []byte{0x41, 0x89, 0x04, 0x07}},
+		{x86.R15, x86.R0, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x04, 0x07}},
+		{x86.R15, x86.R0, 1, x86.R0, []byte{0x41, 0x88, 0x04, 0x07}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Store_test.go b/src/x86/Store_test.go
index 1e912c5..457209a 100644
--- a/src/x86/Store_test.go
+++ b/src/x86/Store_test.go
@@ -17,38 +17,38 @@ func TestStoreNumber(t *testing.T) {
 		Code     []byte
 	}{
 		// No offset
-		{x86.RAX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, 0, 4, 0x7F, []byte{0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x00, 0x7F, 0x00}},
-		{x86.RAX, 0, 1, 0x7F, []byte{0xC6, 0x00, 0x7F}},
-		{x86.RCX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, 0, 4, 0x7F, []byte{0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x01, 0x7F, 0x00}},
-		{x86.RCX, 0, 1, 0x7F, []byte{0xC6, 0x01, 0x7F}},
-		{x86.RDX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, 0, 4, 0x7F, []byte{0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x02, 0x7F, 0x00}},
-		{x86.RDX, 0, 1, 0x7F, []byte{0xC6, 0x02, 0x7F}},
-		{x86.RBX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, 0, 4, 0x7F, []byte{0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x03, 0x7F, 0x00}},
-		{x86.RBX, 0, 1, 0x7F, []byte{0xC6, 0x03, 0x7F}},
-		{x86.RSP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, 0, 4, 0x7F, []byte{0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x04, 0x24, 0x7F, 0x00}},
-		{x86.RSP, 0, 1, 0x7F, []byte{0xC6, 0x04, 0x24, 0x7F}},
-		{x86.RBP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, 0, 4, 0x7F, []byte{0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x00, 0x7F, 0x00}},
-		{x86.RBP, 0, 1, 0x7F, []byte{0xC6, 0x45, 0x00, 0x7F}},
-		{x86.RSI, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, 0, 4, 0x7F, []byte{0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x06, 0x7F, 0x00}},
-		{x86.RSI, 0, 1, 0x7F, []byte{0xC6, 0x06, 0x7F}},
-		{x86.RDI, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, 0, 4, 0x7F, []byte{0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x07, 0x7F, 0x00}},
-		{x86.RDI, 0, 1, 0x7F, []byte{0xC6, 0x07, 0x7F}},
+		{x86.R0, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, 0, 4, 0x7F, []byte{0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x00, 0x7F, 0x00}},
+		{x86.R0, 0, 1, 0x7F, []byte{0xC6, 0x00, 0x7F}},
+		{x86.R1, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, 0, 4, 0x7F, []byte{0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x01, 0x7F, 0x00}},
+		{x86.R1, 0, 1, 0x7F, []byte{0xC6, 0x01, 0x7F}},
+		{x86.R2, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, 0, 4, 0x7F, []byte{0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x02, 0x7F, 0x00}},
+		{x86.R2, 0, 1, 0x7F, []byte{0xC6, 0x02, 0x7F}},
+		{x86.R3, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, 0, 4, 0x7F, []byte{0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x03, 0x7F, 0x00}},
+		{x86.R3, 0, 1, 0x7F, []byte{0xC6, 0x03, 0x7F}},
+		{x86.SP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, 0, 4, 0x7F, []byte{0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x04, 0x24, 0x7F, 0x00}},
+		{x86.SP, 0, 1, 0x7F, []byte{0xC6, 0x04, 0x24, 0x7F}},
+		{x86.R5, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, 0, 4, 0x7F, []byte{0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x00, 0x7F, 0x00}},
+		{x86.R5, 0, 1, 0x7F, []byte{0xC6, 0x45, 0x00, 0x7F}},
+		{x86.R6, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, 0, 4, 0x7F, []byte{0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x06, 0x7F, 0x00}},
+		{x86.R6, 0, 1, 0x7F, []byte{0xC6, 0x06, 0x7F}},
+		{x86.R7, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, 0, 4, 0x7F, []byte{0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x07, 0x7F, 0x00}},
+		{x86.R7, 0, 1, 0x7F, []byte{0xC6, 0x07, 0x7F}},
 		{x86.R8, 0, 8, 0x7F, []byte{0x49, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
 		{x86.R8, 0, 4, 0x7F, []byte{0x41, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
 		{x86.R8, 0, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x00, 0x7F, 0x00}},
@@ -83,38 +83,38 @@ func TestStoreNumber(t *testing.T) {
 		{x86.R15, 0, 1, 0x7F, []byte{0x41, 0xC6, 0x07, 0x7F}},
 
 		// Offset of 1
-		{x86.RAX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, 1, 4, 0x7F, []byte{0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RAX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x40, 0x01, 0x7F, 0x00}},
-		{x86.RAX, 1, 1, 0x7F, []byte{0xC6, 0x40, 0x01, 0x7F}},
-		{x86.RCX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, 1, 4, 0x7F, []byte{0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RCX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x41, 0x01, 0x7F, 0x00}},
-		{x86.RCX, 1, 1, 0x7F, []byte{0xC6, 0x41, 0x01, 0x7F}},
-		{x86.RDX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, 1, 4, 0x7F, []byte{0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x42, 0x01, 0x7F, 0x00}},
-		{x86.RDX, 1, 1, 0x7F, []byte{0xC6, 0x42, 0x01, 0x7F}},
-		{x86.RBX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, 1, 4, 0x7F, []byte{0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x43, 0x01, 0x7F, 0x00}},
-		{x86.RBX, 1, 1, 0x7F, []byte{0xC6, 0x43, 0x01, 0x7F}},
-		{x86.RSP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, 1, 4, 0x7F, []byte{0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00}},
-		{x86.RSP, 1, 1, 0x7F, []byte{0xC6, 0x44, 0x24, 0x01, 0x7F}},
-		{x86.RBP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, 1, 4, 0x7F, []byte{0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RBP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x01, 0x7F, 0x00}},
-		{x86.RBP, 1, 1, 0x7F, []byte{0xC6, 0x45, 0x01, 0x7F}},
-		{x86.RSI, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, 1, 4, 0x7F, []byte{0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RSI, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x46, 0x01, 0x7F, 0x00}},
-		{x86.RSI, 1, 1, 0x7F, []byte{0xC6, 0x46, 0x01, 0x7F}},
-		{x86.RDI, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, 1, 4, 0x7F, []byte{0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
-		{x86.RDI, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x47, 0x01, 0x7F, 0x00}},
-		{x86.RDI, 1, 1, 0x7F, []byte{0xC6, 0x47, 0x01, 0x7F}},
+		{x86.R0, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, 1, 4, 0x7F, []byte{0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R0, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x40, 0x01, 0x7F, 0x00}},
+		{x86.R0, 1, 1, 0x7F, []byte{0xC6, 0x40, 0x01, 0x7F}},
+		{x86.R1, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, 1, 4, 0x7F, []byte{0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R1, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x41, 0x01, 0x7F, 0x00}},
+		{x86.R1, 1, 1, 0x7F, []byte{0xC6, 0x41, 0x01, 0x7F}},
+		{x86.R2, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, 1, 4, 0x7F, []byte{0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R2, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x42, 0x01, 0x7F, 0x00}},
+		{x86.R2, 1, 1, 0x7F, []byte{0xC6, 0x42, 0x01, 0x7F}},
+		{x86.R3, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, 1, 4, 0x7F, []byte{0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R3, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x43, 0x01, 0x7F, 0x00}},
+		{x86.R3, 1, 1, 0x7F, []byte{0xC6, 0x43, 0x01, 0x7F}},
+		{x86.SP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, 1, 4, 0x7F, []byte{0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.SP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00}},
+		{x86.SP, 1, 1, 0x7F, []byte{0xC6, 0x44, 0x24, 0x01, 0x7F}},
+		{x86.R5, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, 1, 4, 0x7F, []byte{0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R5, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x01, 0x7F, 0x00}},
+		{x86.R5, 1, 1, 0x7F, []byte{0xC6, 0x45, 0x01, 0x7F}},
+		{x86.R6, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, 1, 4, 0x7F, []byte{0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R6, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x46, 0x01, 0x7F, 0x00}},
+		{x86.R6, 1, 1, 0x7F, []byte{0xC6, 0x46, 0x01, 0x7F}},
+		{x86.R7, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, 1, 4, 0x7F, []byte{0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
+		{x86.R7, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x47, 0x01, 0x7F, 0x00}},
+		{x86.R7, 1, 1, 0x7F, []byte{0xC6, 0x47, 0x01, 0x7F}},
 		{x86.R8, 1, 8, 0x7F, []byte{0x49, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
 		{x86.R8, 1, 4, 0x7F, []byte{0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
 		{x86.R8, 1, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00}},
@@ -165,136 +165,136 @@ func TestStoreRegister(t *testing.T) {
 		Code         []byte
 	}{
 		// No offset
-		{x86.RAX, 0, 8, x86.R15, []byte{0x4C, 0x89, 0x38}},
-		{x86.RAX, 0, 4, x86.R15, []byte{0x44, 0x89, 0x38}},
-		{x86.RAX, 0, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x38}},
-		{x86.RAX, 0, 1, x86.R15, []byte{0x44, 0x88, 0x38}},
-		{x86.RCX, 0, 8, x86.R14, []byte{0x4C, 0x89, 0x31}},
-		{x86.RCX, 0, 4, x86.R14, []byte{0x44, 0x89, 0x31}},
-		{x86.RCX, 0, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x31}},
-		{x86.RCX, 0, 1, x86.R14, []byte{0x44, 0x88, 0x31}},
-		{x86.RDX, 0, 8, x86.R13, []byte{0x4C, 0x89, 0x2A}},
-		{x86.RDX, 0, 4, x86.R13, []byte{0x44, 0x89, 0x2A}},
-		{x86.RDX, 0, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x2A}},
-		{x86.RDX, 0, 1, x86.R13, []byte{0x44, 0x88, 0x2A}},
-		{x86.RBX, 0, 8, x86.R12, []byte{0x4C, 0x89, 0x23}},
-		{x86.RBX, 0, 4, x86.R12, []byte{0x44, 0x89, 0x23}},
-		{x86.RBX, 0, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x23}},
-		{x86.RBX, 0, 1, x86.R12, []byte{0x44, 0x88, 0x23}},
-		{x86.RSP, 0, 8, x86.R11, []byte{0x4C, 0x89, 0x1C, 0x24}},
-		{x86.RSP, 0, 4, x86.R11, []byte{0x44, 0x89, 0x1C, 0x24}},
-		{x86.RSP, 0, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x1C, 0x24}},
-		{x86.RSP, 0, 1, x86.R11, []byte{0x44, 0x88, 0x1C, 0x24}},
-		{x86.RBP, 0, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x00}},
-		{x86.RBP, 0, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x00}},
-		{x86.RBP, 0, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x00}},
-		{x86.RBP, 0, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x00}},
-		{x86.RSI, 0, 8, x86.R9, []byte{0x4C, 0x89, 0x0E}},
-		{x86.RSI, 0, 4, x86.R9, []byte{0x44, 0x89, 0x0E}},
-		{x86.RSI, 0, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x0E}},
-		{x86.RSI, 0, 1, x86.R9, []byte{0x44, 0x88, 0x0E}},
-		{x86.RDI, 0, 8, x86.R8, []byte{0x4C, 0x89, 0x07}},
-		{x86.RDI, 0, 4, x86.R8, []byte{0x44, 0x89, 0x07}},
-		{x86.RDI, 0, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x07}},
-		{x86.RDI, 0, 1, x86.R8, []byte{0x44, 0x88, 0x07}},
-		{x86.R8, 0, 8, x86.RDI, []byte{0x49, 0x89, 0x38}},
-		{x86.R8, 0, 4, x86.RDI, []byte{0x41, 0x89, 0x38}},
-		{x86.R8, 0, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x38}},
-		{x86.R8, 0, 1, x86.RDI, []byte{0x41, 0x88, 0x38}},
-		{x86.R9, 0, 8, x86.RSI, []byte{0x49, 0x89, 0x31}},
-		{x86.R9, 0, 4, x86.RSI, []byte{0x41, 0x89, 0x31}},
-		{x86.R9, 0, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x31}},
-		{x86.R9, 0, 1, x86.RSI, []byte{0x41, 0x88, 0x31}},
-		{x86.R10, 0, 8, x86.RBP, []byte{0x49, 0x89, 0x2A}},
-		{x86.R10, 0, 4, x86.RBP, []byte{0x41, 0x89, 0x2A}},
-		{x86.R10, 0, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x2A}},
-		{x86.R10, 0, 1, x86.RBP, []byte{0x41, 0x88, 0x2A}},
-		{x86.R11, 0, 8, x86.RSP, []byte{0x49, 0x89, 0x23}},
-		{x86.R11, 0, 4, x86.RSP, []byte{0x41, 0x89, 0x23}},
-		{x86.R11, 0, 2, x86.RSP, []byte{0x66, 0x41, 0x89, 0x23}},
-		{x86.R11, 0, 1, x86.RSP, []byte{0x41, 0x88, 0x23}},
-		{x86.R12, 0, 8, x86.RBX, []byte{0x49, 0x89, 0x1C, 0x24}},
-		{x86.R12, 0, 4, x86.RBX, []byte{0x41, 0x89, 0x1C, 0x24}},
-		{x86.R12, 0, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x1C, 0x24}},
-		{x86.R12, 0, 1, x86.RBX, []byte{0x41, 0x88, 0x1C, 0x24}},
-		{x86.R13, 0, 8, x86.RDX, []byte{0x49, 0x89, 0x55, 0x00}},
-		{x86.R13, 0, 4, x86.RDX, []byte{0x41, 0x89, 0x55, 0x00}},
-		{x86.R13, 0, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x55, 0x00}},
-		{x86.R13, 0, 1, x86.RDX, []byte{0x41, 0x88, 0x55, 0x00}},
-		{x86.R14, 0, 8, x86.RCX, []byte{0x49, 0x89, 0x0E}},
-		{x86.R14, 0, 4, x86.RCX, []byte{0x41, 0x89, 0x0E}},
-		{x86.R14, 0, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x0E}},
-		{x86.R14, 0, 1, x86.RCX, []byte{0x41, 0x88, 0x0E}},
-		{x86.R15, 0, 8, x86.RAX, []byte{0x49, 0x89, 0x07}},
-		{x86.R15, 0, 4, x86.RAX, []byte{0x41, 0x89, 0x07}},
-		{x86.R15, 0, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x07}},
-		{x86.R15, 0, 1, x86.RAX, []byte{0x41, 0x88, 0x07}},
+		{x86.R0, 0, 8, x86.R15, []byte{0x4C, 0x89, 0x38}},
+		{x86.R0, 0, 4, x86.R15, []byte{0x44, 0x89, 0x38}},
+		{x86.R0, 0, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x38}},
+		{x86.R0, 0, 1, x86.R15, []byte{0x44, 0x88, 0x38}},
+		{x86.R1, 0, 8, x86.R14, []byte{0x4C, 0x89, 0x31}},
+		{x86.R1, 0, 4, x86.R14, []byte{0x44, 0x89, 0x31}},
+		{x86.R1, 0, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x31}},
+		{x86.R1, 0, 1, x86.R14, []byte{0x44, 0x88, 0x31}},
+		{x86.R2, 0, 8, x86.R13, []byte{0x4C, 0x89, 0x2A}},
+		{x86.R2, 0, 4, x86.R13, []byte{0x44, 0x89, 0x2A}},
+		{x86.R2, 0, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x2A}},
+		{x86.R2, 0, 1, x86.R13, []byte{0x44, 0x88, 0x2A}},
+		{x86.R3, 0, 8, x86.R12, []byte{0x4C, 0x89, 0x23}},
+		{x86.R3, 0, 4, x86.R12, []byte{0x44, 0x89, 0x23}},
+		{x86.R3, 0, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x23}},
+		{x86.R3, 0, 1, x86.R12, []byte{0x44, 0x88, 0x23}},
+		{x86.SP, 0, 8, x86.R11, []byte{0x4C, 0x89, 0x1C, 0x24}},
+		{x86.SP, 0, 4, x86.R11, []byte{0x44, 0x89, 0x1C, 0x24}},
+		{x86.SP, 0, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x1C, 0x24}},
+		{x86.SP, 0, 1, x86.R11, []byte{0x44, 0x88, 0x1C, 0x24}},
+		{x86.R5, 0, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x00}},
+		{x86.R5, 0, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x00}},
+		{x86.R5, 0, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x00}},
+		{x86.R5, 0, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x00}},
+		{x86.R6, 0, 8, x86.R9, []byte{0x4C, 0x89, 0x0E}},
+		{x86.R6, 0, 4, x86.R9, []byte{0x44, 0x89, 0x0E}},
+		{x86.R6, 0, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x0E}},
+		{x86.R6, 0, 1, x86.R9, []byte{0x44, 0x88, 0x0E}},
+		{x86.R7, 0, 8, x86.R8, []byte{0x4C, 0x89, 0x07}},
+		{x86.R7, 0, 4, x86.R8, []byte{0x44, 0x89, 0x07}},
+		{x86.R7, 0, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x07}},
+		{x86.R7, 0, 1, x86.R8, []byte{0x44, 0x88, 0x07}},
+		{x86.R8, 0, 8, x86.R7, []byte{0x49, 0x89, 0x38}},
+		{x86.R8, 0, 4, x86.R7, []byte{0x41, 0x89, 0x38}},
+		{x86.R8, 0, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x38}},
+		{x86.R8, 0, 1, x86.R7, []byte{0x41, 0x88, 0x38}},
+		{x86.R9, 0, 8, x86.R6, []byte{0x49, 0x89, 0x31}},
+		{x86.R9, 0, 4, x86.R6, []byte{0x41, 0x89, 0x31}},
+		{x86.R9, 0, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x31}},
+		{x86.R9, 0, 1, x86.R6, []byte{0x41, 0x88, 0x31}},
+		{x86.R10, 0, 8, x86.R5, []byte{0x49, 0x89, 0x2A}},
+		{x86.R10, 0, 4, x86.R5, []byte{0x41, 0x89, 0x2A}},
+		{x86.R10, 0, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x2A}},
+		{x86.R10, 0, 1, x86.R5, []byte{0x41, 0x88, 0x2A}},
+		{x86.R11, 0, 8, x86.SP, []byte{0x49, 0x89, 0x23}},
+		{x86.R11, 0, 4, x86.SP, []byte{0x41, 0x89, 0x23}},
+		{x86.R11, 0, 2, x86.SP, []byte{0x66, 0x41, 0x89, 0x23}},
+		{x86.R11, 0, 1, x86.SP, []byte{0x41, 0x88, 0x23}},
+		{x86.R12, 0, 8, x86.R3, []byte{0x49, 0x89, 0x1C, 0x24}},
+		{x86.R12, 0, 4, x86.R3, []byte{0x41, 0x89, 0x1C, 0x24}},
+		{x86.R12, 0, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x1C, 0x24}},
+		{x86.R12, 0, 1, x86.R3, []byte{0x41, 0x88, 0x1C, 0x24}},
+		{x86.R13, 0, 8, x86.R2, []byte{0x49, 0x89, 0x55, 0x00}},
+		{x86.R13, 0, 4, x86.R2, []byte{0x41, 0x89, 0x55, 0x00}},
+		{x86.R13, 0, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x55, 0x00}},
+		{x86.R13, 0, 1, x86.R2, []byte{0x41, 0x88, 0x55, 0x00}},
+		{x86.R14, 0, 8, x86.R1, []byte{0x49, 0x89, 0x0E}},
+		{x86.R14, 0, 4, x86.R1, []byte{0x41, 0x89, 0x0E}},
+		{x86.R14, 0, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x0E}},
+		{x86.R14, 0, 1, x86.R1, []byte{0x41, 0x88, 0x0E}},
+		{x86.R15, 0, 8, x86.R0, []byte{0x49, 0x89, 0x07}},
+		{x86.R15, 0, 4, x86.R0, []byte{0x41, 0x89, 0x07}},
+		{x86.R15, 0, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x07}},
+		{x86.R15, 0, 1, x86.R0, []byte{0x41, 0x88, 0x07}},
 
 		// Offset of 1
-		{x86.RAX, 1, 8, x86.R15, []byte{0x4C, 0x89, 0x78, 0x01}},
-		{x86.RAX, 1, 4, x86.R15, []byte{0x44, 0x89, 0x78, 0x01}},
-		{x86.RAX, 1, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x78, 0x01}},
-		{x86.RAX, 1, 1, x86.R15, []byte{0x44, 0x88, 0x78, 0x01}},
-		{x86.RCX, 1, 8, x86.R14, []byte{0x4C, 0x89, 0x71, 0x01}},
-		{x86.RCX, 1, 4, x86.R14, []byte{0x44, 0x89, 0x71, 0x01}},
-		{x86.RCX, 1, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x71, 0x01}},
-		{x86.RCX, 1, 1, x86.R14, []byte{0x44, 0x88, 0x71, 0x01}},
-		{x86.RDX, 1, 8, x86.R13, []byte{0x4C, 0x89, 0x6A, 0x01}},
-		{x86.RDX, 1, 4, x86.R13, []byte{0x44, 0x89, 0x6A, 0x01}},
-		{x86.RDX, 1, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x6A, 0x01}},
-		{x86.RDX, 1, 1, x86.R13, []byte{0x44, 0x88, 0x6A, 0x01}},
-		{x86.RBX, 1, 8, x86.R12, []byte{0x4C, 0x89, 0x63, 0x01}},
-		{x86.RBX, 1, 4, x86.R12, []byte{0x44, 0x89, 0x63, 0x01}},
-		{x86.RBX, 1, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x63, 0x01}},
-		{x86.RBX, 1, 1, x86.R12, []byte{0x44, 0x88, 0x63, 0x01}},
-		{x86.RSP, 1, 8, x86.R11, []byte{0x4C, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.RSP, 1, 4, x86.R11, []byte{0x44, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.RSP, 1, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.RSP, 1, 1, x86.R11, []byte{0x44, 0x88, 0x5C, 0x24, 0x01}},
-		{x86.RBP, 1, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x01}},
-		{x86.RBP, 1, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x01}},
-		{x86.RBP, 1, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x01}},
-		{x86.RBP, 1, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x01}},
-		{x86.RSI, 1, 8, x86.R9, []byte{0x4C, 0x89, 0x4E, 0x01}},
-		{x86.RSI, 1, 4, x86.R9, []byte{0x44, 0x89, 0x4E, 0x01}},
-		{x86.RSI, 1, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x4E, 0x01}},
-		{x86.RSI, 1, 1, x86.R9, []byte{0x44, 0x88, 0x4E, 0x01}},
-		{x86.RDI, 1, 8, x86.R8, []byte{0x4C, 0x89, 0x47, 0x01}},
-		{x86.RDI, 1, 4, x86.R8, []byte{0x44, 0x89, 0x47, 0x01}},
-		{x86.RDI, 1, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x47, 0x01}},
-		{x86.RDI, 1, 1, x86.R8, []byte{0x44, 0x88, 0x47, 0x01}},
-		{x86.R8, 1, 8, x86.RDI, []byte{0x49, 0x89, 0x78, 0x01}},
-		{x86.R8, 1, 4, x86.RDI, []byte{0x41, 0x89, 0x78, 0x01}},
-		{x86.R8, 1, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x78, 0x01}},
-		{x86.R8, 1, 1, x86.RDI, []byte{0x41, 0x88, 0x78, 0x01}},
-		{x86.R9, 1, 8, x86.RSI, []byte{0x49, 0x89, 0x71, 0x01}},
-		{x86.R9, 1, 4, x86.RSI, []byte{0x41, 0x89, 0x71, 0x01}},
-		{x86.R9, 1, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x71, 0x01}},
-		{x86.R9, 1, 1, x86.RSI, []byte{0x41, 0x88, 0x71, 0x01}},
-		{x86.R10, 1, 8, x86.RBP, []byte{0x49, 0x89, 0x6A, 0x01}},
-		{x86.R10, 1, 4, x86.RBP, []byte{0x41, 0x89, 0x6A, 0x01}},
-		{x86.R10, 1, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x6A, 0x01}},
-		{x86.R10, 1, 1, x86.RBP, []byte{0x41, 0x88, 0x6A, 0x01}},
-		{x86.R11, 1, 8, x86.RSP, []byte{0x49, 0x89, 0x63, 0x01}},
-		{x86.R11, 1, 4, x86.RSP, []byte{0x41, 0x89, 0x63, 0x01}},
-		{x86.R11, 1, 2, x86.RSP, []byte{0x66, 0x41, 0x89, 0x63, 0x01}},
-		{x86.R11, 1, 1, x86.RSP, []byte{0x41, 0x88, 0x63, 0x01}},
-		{x86.R12, 1, 8, x86.RBX, []byte{0x49, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.R12, 1, 4, x86.RBX, []byte{0x41, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.R12, 1, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x5C, 0x24, 0x01}},
-		{x86.R12, 1, 1, x86.RBX, []byte{0x41, 0x88, 0x5C, 0x24, 01}},
-		{x86.R13, 1, 8, x86.RDX, []byte{0x49, 0x89, 0x55, 0x01}},
-		{x86.R13, 1, 4, x86.RDX, []byte{0x41, 0x89, 0x55, 0x01}},
-		{x86.R13, 1, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x55, 0x01}},
-		{x86.R13, 1, 1, x86.RDX, []byte{0x41, 0x88, 0x55, 0x01}},
-		{x86.R14, 1, 8, x86.RCX, []byte{0x49, 0x89, 0x4E, 0x01}},
-		{x86.R14, 1, 4, x86.RCX, []byte{0x41, 0x89, 0x4E, 0x01}},
-		{x86.R14, 1, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x4E, 0x01}},
-		{x86.R14, 1, 1, x86.RCX, []byte{0x41, 0x88, 0x4E, 0x01}},
-		{x86.R15, 1, 8, x86.RAX, []byte{0x49, 0x89, 0x47, 0x01}},
-		{x86.R15, 1, 4, x86.RAX, []byte{0x41, 0x89, 0x47, 0x01}},
-		{x86.R15, 1, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x47, 0x01}},
-		{x86.R15, 1, 1, x86.RAX, []byte{0x41, 0x88, 0x47, 0x01}},
+		{x86.R0, 1, 8, x86.R15, []byte{0x4C, 0x89, 0x78, 0x01}},
+		{x86.R0, 1, 4, x86.R15, []byte{0x44, 0x89, 0x78, 0x01}},
+		{x86.R0, 1, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x78, 0x01}},
+		{x86.R0, 1, 1, x86.R15, []byte{0x44, 0x88, 0x78, 0x01}},
+		{x86.R1, 1, 8, x86.R14, []byte{0x4C, 0x89, 0x71, 0x01}},
+		{x86.R1, 1, 4, x86.R14, []byte{0x44, 0x89, 0x71, 0x01}},
+		{x86.R1, 1, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x71, 0x01}},
+		{x86.R1, 1, 1, x86.R14, []byte{0x44, 0x88, 0x71, 0x01}},
+		{x86.R2, 1, 8, x86.R13, []byte{0x4C, 0x89, 0x6A, 0x01}},
+		{x86.R2, 1, 4, x86.R13, []byte{0x44, 0x89, 0x6A, 0x01}},
+		{x86.R2, 1, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x6A, 0x01}},
+		{x86.R2, 1, 1, x86.R13, []byte{0x44, 0x88, 0x6A, 0x01}},
+		{x86.R3, 1, 8, x86.R12, []byte{0x4C, 0x89, 0x63, 0x01}},
+		{x86.R3, 1, 4, x86.R12, []byte{0x44, 0x89, 0x63, 0x01}},
+		{x86.R3, 1, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x63, 0x01}},
+		{x86.R3, 1, 1, x86.R12, []byte{0x44, 0x88, 0x63, 0x01}},
+		{x86.SP, 1, 8, x86.R11, []byte{0x4C, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.SP, 1, 4, x86.R11, []byte{0x44, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.SP, 1, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.SP, 1, 1, x86.R11, []byte{0x44, 0x88, 0x5C, 0x24, 0x01}},
+		{x86.R5, 1, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x01}},
+		{x86.R5, 1, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x01}},
+		{x86.R5, 1, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x01}},
+		{x86.R5, 1, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x01}},
+		{x86.R6, 1, 8, x86.R9, []byte{0x4C, 0x89, 0x4E, 0x01}},
+		{x86.R6, 1, 4, x86.R9, []byte{0x44, 0x89, 0x4E, 0x01}},
+		{x86.R6, 1, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x4E, 0x01}},
+		{x86.R6, 1, 1, x86.R9, []byte{0x44, 0x88, 0x4E, 0x01}},
+		{x86.R7, 1, 8, x86.R8, []byte{0x4C, 0x89, 0x47, 0x01}},
+		{x86.R7, 1, 4, x86.R8, []byte{0x44, 0x89, 0x47, 0x01}},
+		{x86.R7, 1, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x47, 0x01}},
+		{x86.R7, 1, 1, x86.R8, []byte{0x44, 0x88, 0x47, 0x01}},
+		{x86.R8, 1, 8, x86.R7, []byte{0x49, 0x89, 0x78, 0x01}},
+		{x86.R8, 1, 4, x86.R7, []byte{0x41, 0x89, 0x78, 0x01}},
+		{x86.R8, 1, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x78, 0x01}},
+		{x86.R8, 1, 1, x86.R7, []byte{0x41, 0x88, 0x78, 0x01}},
+		{x86.R9, 1, 8, x86.R6, []byte{0x49, 0x89, 0x71, 0x01}},
+		{x86.R9, 1, 4, x86.R6, []byte{0x41, 0x89, 0x71, 0x01}},
+		{x86.R9, 1, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x71, 0x01}},
+		{x86.R9, 1, 1, x86.R6, []byte{0x41, 0x88, 0x71, 0x01}},
+		{x86.R10, 1, 8, x86.R5, []byte{0x49, 0x89, 0x6A, 0x01}},
+		{x86.R10, 1, 4, x86.R5, []byte{0x41, 0x89, 0x6A, 0x01}},
+		{x86.R10, 1, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x6A, 0x01}},
+		{x86.R10, 1, 1, x86.R5, []byte{0x41, 0x88, 0x6A, 0x01}},
+		{x86.R11, 1, 8, x86.SP, []byte{0x49, 0x89, 0x63, 0x01}},
+		{x86.R11, 1, 4, x86.SP, []byte{0x41, 0x89, 0x63, 0x01}},
+		{x86.R11, 1, 2, x86.SP, []byte{0x66, 0x41, 0x89, 0x63, 0x01}},
+		{x86.R11, 1, 1, x86.SP, []byte{0x41, 0x88, 0x63, 0x01}},
+		{x86.R12, 1, 8, x86.R3, []byte{0x49, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.R12, 1, 4, x86.R3, []byte{0x41, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.R12, 1, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x5C, 0x24, 0x01}},
+		{x86.R12, 1, 1, x86.R3, []byte{0x41, 0x88, 0x5C, 0x24, 01}},
+		{x86.R13, 1, 8, x86.R2, []byte{0x49, 0x89, 0x55, 0x01}},
+		{x86.R13, 1, 4, x86.R2, []byte{0x41, 0x89, 0x55, 0x01}},
+		{x86.R13, 1, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x55, 0x01}},
+		{x86.R13, 1, 1, x86.R2, []byte{0x41, 0x88, 0x55, 0x01}},
+		{x86.R14, 1, 8, x86.R1, []byte{0x49, 0x89, 0x4E, 0x01}},
+		{x86.R14, 1, 4, x86.R1, []byte{0x41, 0x89, 0x4E, 0x01}},
+		{x86.R14, 1, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x4E, 0x01}},
+		{x86.R14, 1, 1, x86.R1, []byte{0x41, 0x88, 0x4E, 0x01}},
+		{x86.R15, 1, 8, x86.R0, []byte{0x49, 0x89, 0x47, 0x01}},
+		{x86.R15, 1, 4, x86.R0, []byte{0x41, 0x89, 0x47, 0x01}},
+		{x86.R15, 1, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x47, 0x01}},
+		{x86.R15, 1, 1, x86.R0, []byte{0x41, 0x88, 0x47, 0x01}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Sub_test.go b/src/x86/Sub_test.go
index 5502edc..bd58796 100644
--- a/src/x86/Sub_test.go
+++ b/src/x86/Sub_test.go
@@ -14,14 +14,14 @@ func TestSubRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xE8, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xE9, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xEA, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xEB, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xEC, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xED, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xEE, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xEF, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xE8, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xE9, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xEA, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xEB, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xEC, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xED, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xEE, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xEF, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xE8, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xE9, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xEA, 0x01}},
@@ -31,14 +31,14 @@ func TestSubRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xEE, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xEF, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEB, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEC, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEE, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEF, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEB, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEC, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEE, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEF, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestSubRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x29, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x29, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x29, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x29, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x29, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x29, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x29, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x29, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x29, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x29, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x29, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x29, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x29, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x29, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x29, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x29, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x29, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x29, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x29, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x29, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x29, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x29, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x29, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x29, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x29, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x29, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x29, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x29, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x29, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x29, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x29, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x29, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/Xor_test.go b/src/x86/Xor_test.go
index 6456cb4..770b688 100644
--- a/src/x86/Xor_test.go
+++ b/src/x86/Xor_test.go
@@ -14,14 +14,14 @@ func TestXorRegisterNumber(t *testing.T) {
 		Number   int
 		Code     []byte
 	}{
-		{x86.RAX, 1, []byte{0x48, 0x83, 0xF0, 0x01}},
-		{x86.RCX, 1, []byte{0x48, 0x83, 0xF1, 0x01}},
-		{x86.RDX, 1, []byte{0x48, 0x83, 0xF2, 0x01}},
-		{x86.RBX, 1, []byte{0x48, 0x83, 0xF3, 0x01}},
-		{x86.RSP, 1, []byte{0x48, 0x83, 0xF4, 0x01}},
-		{x86.RBP, 1, []byte{0x48, 0x83, 0xF5, 0x01}},
-		{x86.RSI, 1, []byte{0x48, 0x83, 0xF6, 0x01}},
-		{x86.RDI, 1, []byte{0x48, 0x83, 0xF7, 0x01}},
+		{x86.R0, 1, []byte{0x48, 0x83, 0xF0, 0x01}},
+		{x86.R1, 1, []byte{0x48, 0x83, 0xF1, 0x01}},
+		{x86.R2, 1, []byte{0x48, 0x83, 0xF2, 0x01}},
+		{x86.R3, 1, []byte{0x48, 0x83, 0xF3, 0x01}},
+		{x86.SP, 1, []byte{0x48, 0x83, 0xF4, 0x01}},
+		{x86.R5, 1, []byte{0x48, 0x83, 0xF5, 0x01}},
+		{x86.R6, 1, []byte{0x48, 0x83, 0xF6, 0x01}},
+		{x86.R7, 1, []byte{0x48, 0x83, 0xF7, 0x01}},
 		{x86.R8, 1, []byte{0x49, 0x83, 0xF0, 0x01}},
 		{x86.R9, 1, []byte{0x49, 0x83, 0xF1, 0x01}},
 		{x86.R10, 1, []byte{0x49, 0x83, 0xF2, 0x01}},
@@ -31,14 +31,14 @@ func TestXorRegisterNumber(t *testing.T) {
 		{x86.R14, 1, []byte{0x49, 0x83, 0xF6, 0x01}},
 		{x86.R15, 1, []byte{0x49, 0x83, 0xF7, 0x01}},
 
-		{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF3, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF4, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF5, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
-		{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF3, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF4, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF5, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
+		{x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}},
 		{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}},
@@ -62,22 +62,22 @@ func TestXorRegisterRegister(t *testing.T) {
 		Right cpu.Register
 		Code  []byte
 	}{
-		{x86.RAX, x86.R15, []byte{0x4C, 0x31, 0xF8}},
-		{x86.RCX, x86.R14, []byte{0x4C, 0x31, 0xF1}},
-		{x86.RDX, x86.R13, []byte{0x4C, 0x31, 0xEA}},
-		{x86.RBX, x86.R12, []byte{0x4C, 0x31, 0xE3}},
-		{x86.RSP, x86.R11, []byte{0x4C, 0x31, 0xDC}},
-		{x86.RBP, x86.R10, []byte{0x4C, 0x31, 0xD5}},
-		{x86.RSI, x86.R9, []byte{0x4C, 0x31, 0xCE}},
-		{x86.RDI, x86.R8, []byte{0x4C, 0x31, 0xC7}},
-		{x86.R8, x86.RDI, []byte{0x49, 0x31, 0xF8}},
-		{x86.R9, x86.RSI, []byte{0x49, 0x31, 0xF1}},
-		{x86.R10, x86.RBP, []byte{0x49, 0x31, 0xEA}},
-		{x86.R11, x86.RSP, []byte{0x49, 0x31, 0xE3}},
-		{x86.R12, x86.RBX, []byte{0x49, 0x31, 0xDC}},
-		{x86.R13, x86.RDX, []byte{0x49, 0x31, 0xD5}},
-		{x86.R14, x86.RCX, []byte{0x49, 0x31, 0xCE}},
-		{x86.R15, x86.RAX, []byte{0x49, 0x31, 0xC7}},
+		{x86.R0, x86.R15, []byte{0x4C, 0x31, 0xF8}},
+		{x86.R1, x86.R14, []byte{0x4C, 0x31, 0xF1}},
+		{x86.R2, x86.R13, []byte{0x4C, 0x31, 0xEA}},
+		{x86.R3, x86.R12, []byte{0x4C, 0x31, 0xE3}},
+		{x86.SP, x86.R11, []byte{0x4C, 0x31, 0xDC}},
+		{x86.R5, x86.R10, []byte{0x4C, 0x31, 0xD5}},
+		{x86.R6, x86.R9, []byte{0x4C, 0x31, 0xCE}},
+		{x86.R7, x86.R8, []byte{0x4C, 0x31, 0xC7}},
+		{x86.R8, x86.R7, []byte{0x49, 0x31, 0xF8}},
+		{x86.R9, x86.R6, []byte{0x49, 0x31, 0xF1}},
+		{x86.R10, x86.R5, []byte{0x49, 0x31, 0xEA}},
+		{x86.R11, x86.SP, []byte{0x49, 0x31, 0xE3}},
+		{x86.R12, x86.R3, []byte{0x49, 0x31, 0xDC}},
+		{x86.R13, x86.R2, []byte{0x49, 0x31, 0xD5}},
+		{x86.R14, x86.R1, []byte{0x49, 0x31, 0xCE}},
+		{x86.R15, x86.R0, []byte{0x49, 0x31, 0xC7}},
 	}
 
 	for _, pattern := range usagePatterns {
diff --git a/src/x86/encode.go b/src/x86/encode.go
index d09fd44..732a156 100644
--- a/src/x86/encode.go
+++ b/src/x86/encode.go
@@ -23,7 +23,7 @@ func encode(code []byte, mod AddressMode, reg cpu.Register, rm cpu.Register, num
 		rm &= 0b111
 	}
 
-	if w != 0 || r != 0 || x != 0 || b != 0 || (numBytes == 1 && (reg == RSP || reg == RBP || reg == RSI || reg == RDI)) {
+	if w != 0 || r != 0 || x != 0 || b != 0 || (numBytes == 1 && (reg == SP || reg == R5 || reg == R6 || reg == R7)) {
 		code = append(code, REX(w, r, x, b))
 	}
 
diff --git a/src/x86/memoryAccess.go b/src/x86/memoryAccess.go
index 42e6a37..c7559b8 100644
--- a/src/x86/memoryAccess.go
+++ b/src/x86/memoryAccess.go
@@ -12,7 +12,7 @@ func memoryAccess(code []byte, opCode8 byte, opCode32 byte, register cpu.Registe
 
 	mod := AddressMemory
 
-	if offset != 0 || base == RBP || base == R13 {
+	if offset != 0 || base == R5 || base == R13 {
 		mod = AddressMemoryOffset8
 	}
 
@@ -22,7 +22,7 @@ func memoryAccess(code []byte, opCode8 byte, opCode32 byte, register cpu.Registe
 
 	code = encode(code, mod, register, base, length, opCode)
 
-	if base == RSP || base == R12 {
+	if base == SP || base == R12 {
 		code = append(code, SIB(Scale1, 0b100, 0b100))
 	}
 
diff --git a/src/x86/memoryAccessDynamic.go b/src/x86/memoryAccessDynamic.go
index 092fa64..f4eb76e 100644
--- a/src/x86/memoryAccessDynamic.go
+++ b/src/x86/memoryAccessDynamic.go
@@ -17,7 +17,7 @@ func memoryAccessDynamic(code []byte, opCode8 byte, opCode32 byte, register cpu.
 		opCode = opCode8
 	}
 
-	if offset == RSP {
+	if offset == SP {
 		offset, base = base, offset
 	}
 
@@ -40,7 +40,7 @@ func memoryAccessDynamic(code []byte, opCode8 byte, opCode32 byte, register cpu.
 		base &= 0b111
 	}
 
-	if base == RBP || base == R13 {
+	if base == R5 || base == R13 {
 		mod = AddressMemoryOffset8
 	}
 
diff --git a/src/x86/x86_test.go b/src/x86/x86_test.go
index 9d6b3bc..ece5699 100644
--- a/src/x86/x86_test.go
+++ b/src/x86/x86_test.go
@@ -10,7 +10,7 @@ import (
 func TestX86(t *testing.T) {
 	assert.DeepEqual(t, x86.Call(nil, 1), []byte{0xE8, 0x01, 0x00, 0x00, 0x00})
 	assert.DeepEqual(t, x86.CallAt(nil, 1), []byte{0xFF, 0x15, 0x01, 0x00, 0x00, 0x00})
-	assert.DeepEqual(t, x86.ExtendRAXToRDX(nil), []byte{0x48, 0x99})
+	assert.DeepEqual(t, x86.ExtendR0ToR2(nil), []byte{0x48, 0x99})
 	assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 0, 1), []byte{0xB8, 0x01, 0x00, 0x00, 0x00})
 	assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 1, 1), []byte{0xB9, 0x01, 0x00, 0x00, 0x00})
 	assert.DeepEqual(t, x86.Return(nil), []byte{0xC3})