diff --git a/ast.go b/ast.go
index 62f1e74..f0c3bb4 100644
--- a/ast.go
+++ b/ast.go
@@ -45,9 +45,13 @@ type Instruction struct {
 	// CFG.
 	Pred []*Instruction
 	Succ []*Instruction
+
+	// LiveIn/LiveOut are sets of live register IDs pre/post execution.
+	LiveIn  map[reg.ID]bool
+	LiveOut map[reg.ID]bool
 }
 
-func (i Instruction) node() {}
+func (i *Instruction) node() {}
 
 func (i Instruction) TargetLabel() *Label {
 	if !i.IsBranch {
diff --git a/build/context.go b/build/context.go
index fd418dc..3744b9b 100644
--- a/build/context.go
+++ b/build/context.go
@@ -25,7 +25,7 @@ func (c *Context) Function(name string) {
 	c.file.Functions = append(c.file.Functions, c.function)
 }
 
-func (c *Context) Instruction(i avo.Instruction) {
+func (c *Context) Instruction(i *avo.Instruction) {
 	c.node(i)
 }
 
diff --git a/build/zinstructions.go b/build/zinstructions.go
index cfe4d55..fa5ef6f 100644
--- a/build/zinstructions.go
+++ b/build/zinstructions.go
@@ -9,7 +9,7 @@ import (
 
 func (c *Context) ADCB(imr, amr operand.Op) {
 	if inst, err := x86.ADCB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -18,7 +18,7 @@ func ADCB(imr, amr operand.Op) { ctx.ADCB(imr, amr) }
 
 func (c *Context) ADCL(imr, emr operand.Op) {
 	if inst, err := x86.ADCL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -27,7 +27,7 @@ func ADCL(imr, emr operand.Op) { ctx.ADCL(imr, emr) }
 
 func (c *Context) ADCQ(imr, mr operand.Op) {
 	if inst, err := x86.ADCQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -36,7 +36,7 @@ func ADCQ(imr, mr operand.Op) { ctx.ADCQ(imr, mr) }
 
 func (c *Context) ADCW(imr, amr operand.Op) {
 	if inst, err := x86.ADCW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -45,7 +45,7 @@ func ADCW(imr, amr operand.Op) { ctx.ADCW(imr, amr) }
 
 func (c *Context) ADCXL(mr, r operand.Op) {
 	if inst, err := x86.ADCXL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -54,7 +54,7 @@ func ADCXL(mr, r operand.Op) { ctx.ADCXL(mr, r) }
 
 func (c *Context) ADCXQ(mr, r operand.Op) {
 	if inst, err := x86.ADCXQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -63,7 +63,7 @@ func ADCXQ(mr, r operand.Op) { ctx.ADCXQ(mr, r) }
 
 func (c *Context) ADDB(imr, amr operand.Op) {
 	if inst, err := x86.ADDB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -72,7 +72,7 @@ func ADDB(imr, amr operand.Op) { ctx.ADDB(imr, amr) }
 
 func (c *Context) ADDL(imr, emr operand.Op) {
 	if inst, err := x86.ADDL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -81,7 +81,7 @@ func ADDL(imr, emr operand.Op) { ctx.ADDL(imr, emr) }
 
 func (c *Context) ADDPD(mx, x operand.Op) {
 	if inst, err := x86.ADDPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -90,7 +90,7 @@ func ADDPD(mx, x operand.Op) { ctx.ADDPD(mx, x) }
 
 func (c *Context) ADDPS(mx, x operand.Op) {
 	if inst, err := x86.ADDPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -99,7 +99,7 @@ func ADDPS(mx, x operand.Op) { ctx.ADDPS(mx, x) }
 
 func (c *Context) ADDQ(imr, mr operand.Op) {
 	if inst, err := x86.ADDQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -108,7 +108,7 @@ func ADDQ(imr, mr operand.Op) { ctx.ADDQ(imr, mr) }
 
 func (c *Context) ADDSD(mx, x operand.Op) {
 	if inst, err := x86.ADDSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -117,7 +117,7 @@ func ADDSD(mx, x operand.Op) { ctx.ADDSD(mx, x) }
 
 func (c *Context) ADDSS(mx, x operand.Op) {
 	if inst, err := x86.ADDSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -126,7 +126,7 @@ func ADDSS(mx, x operand.Op) { ctx.ADDSS(mx, x) }
 
 func (c *Context) ADDSUBPD(mx, x operand.Op) {
 	if inst, err := x86.ADDSUBPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -135,7 +135,7 @@ func ADDSUBPD(mx, x operand.Op) { ctx.ADDSUBPD(mx, x) }
 
 func (c *Context) ADDSUBPS(mx, x operand.Op) {
 	if inst, err := x86.ADDSUBPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -144,7 +144,7 @@ func ADDSUBPS(mx, x operand.Op) { ctx.ADDSUBPS(mx, x) }
 
 func (c *Context) ADDW(imr, amr operand.Op) {
 	if inst, err := x86.ADDW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -153,7 +153,7 @@ func ADDW(imr, amr operand.Op) { ctx.ADDW(imr, amr) }
 
 func (c *Context) ADOXL(mr, r operand.Op) {
 	if inst, err := x86.ADOXL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -162,7 +162,7 @@ func ADOXL(mr, r operand.Op) { ctx.ADOXL(mr, r) }
 
 func (c *Context) ADOXQ(mr, r operand.Op) {
 	if inst, err := x86.ADOXQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -171,7 +171,7 @@ func ADOXQ(mr, r operand.Op) { ctx.ADOXQ(mr, r) }
 
 func (c *Context) AESDEC(mx, x operand.Op) {
 	if inst, err := x86.AESDEC(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -180,7 +180,7 @@ func AESDEC(mx, x operand.Op) { ctx.AESDEC(mx, x) }
 
 func (c *Context) AESDECLAST(mx, x operand.Op) {
 	if inst, err := x86.AESDECLAST(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -189,7 +189,7 @@ func AESDECLAST(mx, x operand.Op) { ctx.AESDECLAST(mx, x) }
 
 func (c *Context) AESENC(mx, x operand.Op) {
 	if inst, err := x86.AESENC(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -198,7 +198,7 @@ func AESENC(mx, x operand.Op) { ctx.AESENC(mx, x) }
 
 func (c *Context) AESENCLAST(mx, x operand.Op) {
 	if inst, err := x86.AESENCLAST(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -207,7 +207,7 @@ func AESENCLAST(mx, x operand.Op) { ctx.AESENCLAST(mx, x) }
 
 func (c *Context) AESIMC(mx, x operand.Op) {
 	if inst, err := x86.AESIMC(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -216,7 +216,7 @@ func AESIMC(mx, x operand.Op) { ctx.AESIMC(mx, x) }
 
 func (c *Context) AESKEYGENASSIST(i, mx, x operand.Op) {
 	if inst, err := x86.AESKEYGENASSIST(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -225,7 +225,7 @@ func AESKEYGENASSIST(i, mx, x operand.Op) { ctx.AESKEYGENASSIST(i, mx, x) }
 
 func (c *Context) ANDB(imr, amr operand.Op) {
 	if inst, err := x86.ANDB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -234,7 +234,7 @@ func ANDB(imr, amr operand.Op) { ctx.ANDB(imr, amr) }
 
 func (c *Context) ANDL(imr, emr operand.Op) {
 	if inst, err := x86.ANDL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -243,7 +243,7 @@ func ANDL(imr, emr operand.Op) { ctx.ANDL(imr, emr) }
 
 func (c *Context) ANDNL(mr, r, r1 operand.Op) {
 	if inst, err := x86.ANDNL(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -252,7 +252,7 @@ func ANDNL(mr, r, r1 operand.Op) { ctx.ANDNL(mr, r, r1) }
 
 func (c *Context) ANDNPD(mx, x operand.Op) {
 	if inst, err := x86.ANDNPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -261,7 +261,7 @@ func ANDNPD(mx, x operand.Op) { ctx.ANDNPD(mx, x) }
 
 func (c *Context) ANDNPS(mx, x operand.Op) {
 	if inst, err := x86.ANDNPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -270,7 +270,7 @@ func ANDNPS(mx, x operand.Op) { ctx.ANDNPS(mx, x) }
 
 func (c *Context) ANDNQ(mr, r, r1 operand.Op) {
 	if inst, err := x86.ANDNQ(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -279,7 +279,7 @@ func ANDNQ(mr, r, r1 operand.Op) { ctx.ANDNQ(mr, r, r1) }
 
 func (c *Context) ANDPD(mx, x operand.Op) {
 	if inst, err := x86.ANDPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -288,7 +288,7 @@ func ANDPD(mx, x operand.Op) { ctx.ANDPD(mx, x) }
 
 func (c *Context) ANDPS(mx, x operand.Op) {
 	if inst, err := x86.ANDPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -297,7 +297,7 @@ func ANDPS(mx, x operand.Op) { ctx.ANDPS(mx, x) }
 
 func (c *Context) ANDQ(imr, mr operand.Op) {
 	if inst, err := x86.ANDQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -306,7 +306,7 @@ func ANDQ(imr, mr operand.Op) { ctx.ANDQ(imr, mr) }
 
 func (c *Context) ANDW(imr, amr operand.Op) {
 	if inst, err := x86.ANDW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -315,7 +315,7 @@ func ANDW(imr, amr operand.Op) { ctx.ANDW(imr, amr) }
 
 func (c *Context) BEXTRL(r, mr, r1 operand.Op) {
 	if inst, err := x86.BEXTRL(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -324,7 +324,7 @@ func BEXTRL(r, mr, r1 operand.Op) { ctx.BEXTRL(r, mr, r1) }
 
 func (c *Context) BEXTRQ(r, mr, r1 operand.Op) {
 	if inst, err := x86.BEXTRQ(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -333,7 +333,7 @@ func BEXTRQ(r, mr, r1 operand.Op) { ctx.BEXTRQ(r, mr, r1) }
 
 func (c *Context) BLENDPD(i, mx, x operand.Op) {
 	if inst, err := x86.BLENDPD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -342,7 +342,7 @@ func BLENDPD(i, mx, x operand.Op) { ctx.BLENDPD(i, mx, x) }
 
 func (c *Context) BLENDPS(i, mx, x operand.Op) {
 	if inst, err := x86.BLENDPS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -351,7 +351,7 @@ func BLENDPS(i, mx, x operand.Op) { ctx.BLENDPS(i, mx, x) }
 
 func (c *Context) BLENDVPD(x, mx, x1 operand.Op) {
 	if inst, err := x86.BLENDVPD(x, mx, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -360,7 +360,7 @@ func BLENDVPD(x, mx, x1 operand.Op) { ctx.BLENDVPD(x, mx, x1) }
 
 func (c *Context) BLENDVPS(x, mx, x1 operand.Op) {
 	if inst, err := x86.BLENDVPS(x, mx, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -369,7 +369,7 @@ func BLENDVPS(x, mx, x1 operand.Op) { ctx.BLENDVPS(x, mx, x1) }
 
 func (c *Context) BLSIL(mr, r operand.Op) {
 	if inst, err := x86.BLSIL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -378,7 +378,7 @@ func BLSIL(mr, r operand.Op) { ctx.BLSIL(mr, r) }
 
 func (c *Context) BLSIQ(mr, r operand.Op) {
 	if inst, err := x86.BLSIQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -387,7 +387,7 @@ func BLSIQ(mr, r operand.Op) { ctx.BLSIQ(mr, r) }
 
 func (c *Context) BLSMSKL(mr, r operand.Op) {
 	if inst, err := x86.BLSMSKL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -396,7 +396,7 @@ func BLSMSKL(mr, r operand.Op) { ctx.BLSMSKL(mr, r) }
 
 func (c *Context) BLSMSKQ(mr, r operand.Op) {
 	if inst, err := x86.BLSMSKQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -405,7 +405,7 @@ func BLSMSKQ(mr, r operand.Op) { ctx.BLSMSKQ(mr, r) }
 
 func (c *Context) BLSRL(mr, r operand.Op) {
 	if inst, err := x86.BLSRL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -414,7 +414,7 @@ func BLSRL(mr, r operand.Op) { ctx.BLSRL(mr, r) }
 
 func (c *Context) BLSRQ(mr, r operand.Op) {
 	if inst, err := x86.BLSRQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -423,7 +423,7 @@ func BLSRQ(mr, r operand.Op) { ctx.BLSRQ(mr, r) }
 
 func (c *Context) BSFL(mr, r operand.Op) {
 	if inst, err := x86.BSFL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -432,7 +432,7 @@ func BSFL(mr, r operand.Op) { ctx.BSFL(mr, r) }
 
 func (c *Context) BSFQ(mr, r operand.Op) {
 	if inst, err := x86.BSFQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -441,7 +441,7 @@ func BSFQ(mr, r operand.Op) { ctx.BSFQ(mr, r) }
 
 func (c *Context) BSFW(mr, r operand.Op) {
 	if inst, err := x86.BSFW(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -450,7 +450,7 @@ func BSFW(mr, r operand.Op) { ctx.BSFW(mr, r) }
 
 func (c *Context) BSRL(mr, r operand.Op) {
 	if inst, err := x86.BSRL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -459,7 +459,7 @@ func BSRL(mr, r operand.Op) { ctx.BSRL(mr, r) }
 
 func (c *Context) BSRQ(mr, r operand.Op) {
 	if inst, err := x86.BSRQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -468,7 +468,7 @@ func BSRQ(mr, r operand.Op) { ctx.BSRQ(mr, r) }
 
 func (c *Context) BSRW(mr, r operand.Op) {
 	if inst, err := x86.BSRW(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -477,7 +477,7 @@ func BSRW(mr, r operand.Op) { ctx.BSRW(mr, r) }
 
 func (c *Context) BSWAPL(r operand.Op) {
 	if inst, err := x86.BSWAPL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -486,7 +486,7 @@ func BSWAPL(r operand.Op) { ctx.BSWAPL(r) }
 
 func (c *Context) BSWAPQ(r operand.Op) {
 	if inst, err := x86.BSWAPQ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -495,7 +495,7 @@ func BSWAPQ(r operand.Op) { ctx.BSWAPQ(r) }
 
 func (c *Context) BTCL(ir, mr operand.Op) {
 	if inst, err := x86.BTCL(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -504,7 +504,7 @@ func BTCL(ir, mr operand.Op) { ctx.BTCL(ir, mr) }
 
 func (c *Context) BTCQ(ir, mr operand.Op) {
 	if inst, err := x86.BTCQ(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -513,7 +513,7 @@ func BTCQ(ir, mr operand.Op) { ctx.BTCQ(ir, mr) }
 
 func (c *Context) BTCW(ir, mr operand.Op) {
 	if inst, err := x86.BTCW(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -522,7 +522,7 @@ func BTCW(ir, mr operand.Op) { ctx.BTCW(ir, mr) }
 
 func (c *Context) BTL(ir, mr operand.Op) {
 	if inst, err := x86.BTL(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -531,7 +531,7 @@ func BTL(ir, mr operand.Op) { ctx.BTL(ir, mr) }
 
 func (c *Context) BTQ(ir, mr operand.Op) {
 	if inst, err := x86.BTQ(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -540,7 +540,7 @@ func BTQ(ir, mr operand.Op) { ctx.BTQ(ir, mr) }
 
 func (c *Context) BTRL(ir, mr operand.Op) {
 	if inst, err := x86.BTRL(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -549,7 +549,7 @@ func BTRL(ir, mr operand.Op) { ctx.BTRL(ir, mr) }
 
 func (c *Context) BTRQ(ir, mr operand.Op) {
 	if inst, err := x86.BTRQ(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -558,7 +558,7 @@ func BTRQ(ir, mr operand.Op) { ctx.BTRQ(ir, mr) }
 
 func (c *Context) BTRW(ir, mr operand.Op) {
 	if inst, err := x86.BTRW(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -567,7 +567,7 @@ func BTRW(ir, mr operand.Op) { ctx.BTRW(ir, mr) }
 
 func (c *Context) BTSL(ir, mr operand.Op) {
 	if inst, err := x86.BTSL(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -576,7 +576,7 @@ func BTSL(ir, mr operand.Op) { ctx.BTSL(ir, mr) }
 
 func (c *Context) BTSQ(ir, mr operand.Op) {
 	if inst, err := x86.BTSQ(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -585,7 +585,7 @@ func BTSQ(ir, mr operand.Op) { ctx.BTSQ(ir, mr) }
 
 func (c *Context) BTSW(ir, mr operand.Op) {
 	if inst, err := x86.BTSW(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -594,7 +594,7 @@ func BTSW(ir, mr operand.Op) { ctx.BTSW(ir, mr) }
 
 func (c *Context) BTW(ir, mr operand.Op) {
 	if inst, err := x86.BTW(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -603,7 +603,7 @@ func BTW(ir, mr operand.Op) { ctx.BTW(ir, mr) }
 
 func (c *Context) BZHIL(r, mr, r1 operand.Op) {
 	if inst, err := x86.BZHIL(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -612,7 +612,7 @@ func BZHIL(r, mr, r1 operand.Op) { ctx.BZHIL(r, mr, r1) }
 
 func (c *Context) BZHIQ(r, mr, r1 operand.Op) {
 	if inst, err := x86.BZHIQ(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -621,7 +621,7 @@ func BZHIQ(r, mr, r1 operand.Op) { ctx.BZHIQ(r, mr, r1) }
 
 func (c *Context) CALL(r operand.Op) {
 	if inst, err := x86.CALL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -630,7 +630,7 @@ func CALL(r operand.Op) { ctx.CALL(r) }
 
 func (c *Context) CBW() {
 	if inst, err := x86.CBW(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -639,7 +639,7 @@ func CBW() { ctx.CBW() }
 
 func (c *Context) CDQ() {
 	if inst, err := x86.CDQ(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -648,7 +648,7 @@ func CDQ() { ctx.CDQ() }
 
 func (c *Context) CDQE() {
 	if inst, err := x86.CDQE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -657,7 +657,7 @@ func CDQE() { ctx.CDQE() }
 
 func (c *Context) CLC() {
 	if inst, err := x86.CLC(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -666,7 +666,7 @@ func CLC() { ctx.CLC() }
 
 func (c *Context) CLD() {
 	if inst, err := x86.CLD(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -675,7 +675,7 @@ func CLD() { ctx.CLD() }
 
 func (c *Context) CLFLUSH(m operand.Op) {
 	if inst, err := x86.CLFLUSH(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -684,7 +684,7 @@ func CLFLUSH(m operand.Op) { ctx.CLFLUSH(m) }
 
 func (c *Context) CLFLUSHOPT(m operand.Op) {
 	if inst, err := x86.CLFLUSHOPT(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -693,7 +693,7 @@ func CLFLUSHOPT(m operand.Op) { ctx.CLFLUSHOPT(m) }
 
 func (c *Context) CMC() {
 	if inst, err := x86.CMC(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -702,7 +702,7 @@ func CMC() { ctx.CMC() }
 
 func (c *Context) CMOVLCC(mr, r operand.Op) {
 	if inst, err := x86.CMOVLCC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -711,7 +711,7 @@ func CMOVLCC(mr, r operand.Op) { ctx.CMOVLCC(mr, r) }
 
 func (c *Context) CMOVLCS(mr, r operand.Op) {
 	if inst, err := x86.CMOVLCS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -720,7 +720,7 @@ func CMOVLCS(mr, r operand.Op) { ctx.CMOVLCS(mr, r) }
 
 func (c *Context) CMOVLEQ(mr, r operand.Op) {
 	if inst, err := x86.CMOVLEQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -729,7 +729,7 @@ func CMOVLEQ(mr, r operand.Op) { ctx.CMOVLEQ(mr, r) }
 
 func (c *Context) CMOVLGE(mr, r operand.Op) {
 	if inst, err := x86.CMOVLGE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -738,7 +738,7 @@ func CMOVLGE(mr, r operand.Op) { ctx.CMOVLGE(mr, r) }
 
 func (c *Context) CMOVLGT(mr, r operand.Op) {
 	if inst, err := x86.CMOVLGT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -747,7 +747,7 @@ func CMOVLGT(mr, r operand.Op) { ctx.CMOVLGT(mr, r) }
 
 func (c *Context) CMOVLHI(mr, r operand.Op) {
 	if inst, err := x86.CMOVLHI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -756,7 +756,7 @@ func CMOVLHI(mr, r operand.Op) { ctx.CMOVLHI(mr, r) }
 
 func (c *Context) CMOVLLE(mr, r operand.Op) {
 	if inst, err := x86.CMOVLLE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -765,7 +765,7 @@ func CMOVLLE(mr, r operand.Op) { ctx.CMOVLLE(mr, r) }
 
 func (c *Context) CMOVLLS(mr, r operand.Op) {
 	if inst, err := x86.CMOVLLS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -774,7 +774,7 @@ func CMOVLLS(mr, r operand.Op) { ctx.CMOVLLS(mr, r) }
 
 func (c *Context) CMOVLLT(mr, r operand.Op) {
 	if inst, err := x86.CMOVLLT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -783,7 +783,7 @@ func CMOVLLT(mr, r operand.Op) { ctx.CMOVLLT(mr, r) }
 
 func (c *Context) CMOVLMI(mr, r operand.Op) {
 	if inst, err := x86.CMOVLMI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -792,7 +792,7 @@ func CMOVLMI(mr, r operand.Op) { ctx.CMOVLMI(mr, r) }
 
 func (c *Context) CMOVLNE(mr, r operand.Op) {
 	if inst, err := x86.CMOVLNE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -801,7 +801,7 @@ func CMOVLNE(mr, r operand.Op) { ctx.CMOVLNE(mr, r) }
 
 func (c *Context) CMOVLOC(mr, r operand.Op) {
 	if inst, err := x86.CMOVLOC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -810,7 +810,7 @@ func CMOVLOC(mr, r operand.Op) { ctx.CMOVLOC(mr, r) }
 
 func (c *Context) CMOVLOS(mr, r operand.Op) {
 	if inst, err := x86.CMOVLOS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -819,7 +819,7 @@ func CMOVLOS(mr, r operand.Op) { ctx.CMOVLOS(mr, r) }
 
 func (c *Context) CMOVLPC(mr, r operand.Op) {
 	if inst, err := x86.CMOVLPC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -828,7 +828,7 @@ func CMOVLPC(mr, r operand.Op) { ctx.CMOVLPC(mr, r) }
 
 func (c *Context) CMOVLPL(mr, r operand.Op) {
 	if inst, err := x86.CMOVLPL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -837,7 +837,7 @@ func CMOVLPL(mr, r operand.Op) { ctx.CMOVLPL(mr, r) }
 
 func (c *Context) CMOVLPS(mr, r operand.Op) {
 	if inst, err := x86.CMOVLPS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -846,7 +846,7 @@ func CMOVLPS(mr, r operand.Op) { ctx.CMOVLPS(mr, r) }
 
 func (c *Context) CMOVQCC(mr, r operand.Op) {
 	if inst, err := x86.CMOVQCC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -855,7 +855,7 @@ func CMOVQCC(mr, r operand.Op) { ctx.CMOVQCC(mr, r) }
 
 func (c *Context) CMOVQCS(mr, r operand.Op) {
 	if inst, err := x86.CMOVQCS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -864,7 +864,7 @@ func CMOVQCS(mr, r operand.Op) { ctx.CMOVQCS(mr, r) }
 
 func (c *Context) CMOVQEQ(mr, r operand.Op) {
 	if inst, err := x86.CMOVQEQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -873,7 +873,7 @@ func CMOVQEQ(mr, r operand.Op) { ctx.CMOVQEQ(mr, r) }
 
 func (c *Context) CMOVQGE(mr, r operand.Op) {
 	if inst, err := x86.CMOVQGE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -882,7 +882,7 @@ func CMOVQGE(mr, r operand.Op) { ctx.CMOVQGE(mr, r) }
 
 func (c *Context) CMOVQGT(mr, r operand.Op) {
 	if inst, err := x86.CMOVQGT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -891,7 +891,7 @@ func CMOVQGT(mr, r operand.Op) { ctx.CMOVQGT(mr, r) }
 
 func (c *Context) CMOVQHI(mr, r operand.Op) {
 	if inst, err := x86.CMOVQHI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -900,7 +900,7 @@ func CMOVQHI(mr, r operand.Op) { ctx.CMOVQHI(mr, r) }
 
 func (c *Context) CMOVQLE(mr, r operand.Op) {
 	if inst, err := x86.CMOVQLE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -909,7 +909,7 @@ func CMOVQLE(mr, r operand.Op) { ctx.CMOVQLE(mr, r) }
 
 func (c *Context) CMOVQLS(mr, r operand.Op) {
 	if inst, err := x86.CMOVQLS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -918,7 +918,7 @@ func CMOVQLS(mr, r operand.Op) { ctx.CMOVQLS(mr, r) }
 
 func (c *Context) CMOVQLT(mr, r operand.Op) {
 	if inst, err := x86.CMOVQLT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -927,7 +927,7 @@ func CMOVQLT(mr, r operand.Op) { ctx.CMOVQLT(mr, r) }
 
 func (c *Context) CMOVQMI(mr, r operand.Op) {
 	if inst, err := x86.CMOVQMI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -936,7 +936,7 @@ func CMOVQMI(mr, r operand.Op) { ctx.CMOVQMI(mr, r) }
 
 func (c *Context) CMOVQNE(mr, r operand.Op) {
 	if inst, err := x86.CMOVQNE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -945,7 +945,7 @@ func CMOVQNE(mr, r operand.Op) { ctx.CMOVQNE(mr, r) }
 
 func (c *Context) CMOVQOC(mr, r operand.Op) {
 	if inst, err := x86.CMOVQOC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -954,7 +954,7 @@ func CMOVQOC(mr, r operand.Op) { ctx.CMOVQOC(mr, r) }
 
 func (c *Context) CMOVQOS(mr, r operand.Op) {
 	if inst, err := x86.CMOVQOS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -963,7 +963,7 @@ func CMOVQOS(mr, r operand.Op) { ctx.CMOVQOS(mr, r) }
 
 func (c *Context) CMOVQPC(mr, r operand.Op) {
 	if inst, err := x86.CMOVQPC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -972,7 +972,7 @@ func CMOVQPC(mr, r operand.Op) { ctx.CMOVQPC(mr, r) }
 
 func (c *Context) CMOVQPL(mr, r operand.Op) {
 	if inst, err := x86.CMOVQPL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -981,7 +981,7 @@ func CMOVQPL(mr, r operand.Op) { ctx.CMOVQPL(mr, r) }
 
 func (c *Context) CMOVQPS(mr, r operand.Op) {
 	if inst, err := x86.CMOVQPS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -990,7 +990,7 @@ func CMOVQPS(mr, r operand.Op) { ctx.CMOVQPS(mr, r) }
 
 func (c *Context) CMOVWCC(mr, r operand.Op) {
 	if inst, err := x86.CMOVWCC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -999,7 +999,7 @@ func CMOVWCC(mr, r operand.Op) { ctx.CMOVWCC(mr, r) }
 
 func (c *Context) CMOVWCS(mr, r operand.Op) {
 	if inst, err := x86.CMOVWCS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1008,7 +1008,7 @@ func CMOVWCS(mr, r operand.Op) { ctx.CMOVWCS(mr, r) }
 
 func (c *Context) CMOVWEQ(mr, r operand.Op) {
 	if inst, err := x86.CMOVWEQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1017,7 +1017,7 @@ func CMOVWEQ(mr, r operand.Op) { ctx.CMOVWEQ(mr, r) }
 
 func (c *Context) CMOVWGE(mr, r operand.Op) {
 	if inst, err := x86.CMOVWGE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1026,7 +1026,7 @@ func CMOVWGE(mr, r operand.Op) { ctx.CMOVWGE(mr, r) }
 
 func (c *Context) CMOVWGT(mr, r operand.Op) {
 	if inst, err := x86.CMOVWGT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1035,7 +1035,7 @@ func CMOVWGT(mr, r operand.Op) { ctx.CMOVWGT(mr, r) }
 
 func (c *Context) CMOVWHI(mr, r operand.Op) {
 	if inst, err := x86.CMOVWHI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1044,7 +1044,7 @@ func CMOVWHI(mr, r operand.Op) { ctx.CMOVWHI(mr, r) }
 
 func (c *Context) CMOVWLE(mr, r operand.Op) {
 	if inst, err := x86.CMOVWLE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1053,7 +1053,7 @@ func CMOVWLE(mr, r operand.Op) { ctx.CMOVWLE(mr, r) }
 
 func (c *Context) CMOVWLS(mr, r operand.Op) {
 	if inst, err := x86.CMOVWLS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1062,7 +1062,7 @@ func CMOVWLS(mr, r operand.Op) { ctx.CMOVWLS(mr, r) }
 
 func (c *Context) CMOVWLT(mr, r operand.Op) {
 	if inst, err := x86.CMOVWLT(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1071,7 +1071,7 @@ func CMOVWLT(mr, r operand.Op) { ctx.CMOVWLT(mr, r) }
 
 func (c *Context) CMOVWMI(mr, r operand.Op) {
 	if inst, err := x86.CMOVWMI(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1080,7 +1080,7 @@ func CMOVWMI(mr, r operand.Op) { ctx.CMOVWMI(mr, r) }
 
 func (c *Context) CMOVWNE(mr, r operand.Op) {
 	if inst, err := x86.CMOVWNE(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1089,7 +1089,7 @@ func CMOVWNE(mr, r operand.Op) { ctx.CMOVWNE(mr, r) }
 
 func (c *Context) CMOVWOC(mr, r operand.Op) {
 	if inst, err := x86.CMOVWOC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1098,7 +1098,7 @@ func CMOVWOC(mr, r operand.Op) { ctx.CMOVWOC(mr, r) }
 
 func (c *Context) CMOVWOS(mr, r operand.Op) {
 	if inst, err := x86.CMOVWOS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1107,7 +1107,7 @@ func CMOVWOS(mr, r operand.Op) { ctx.CMOVWOS(mr, r) }
 
 func (c *Context) CMOVWPC(mr, r operand.Op) {
 	if inst, err := x86.CMOVWPC(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1116,7 +1116,7 @@ func CMOVWPC(mr, r operand.Op) { ctx.CMOVWPC(mr, r) }
 
 func (c *Context) CMOVWPL(mr, r operand.Op) {
 	if inst, err := x86.CMOVWPL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1125,7 +1125,7 @@ func CMOVWPL(mr, r operand.Op) { ctx.CMOVWPL(mr, r) }
 
 func (c *Context) CMOVWPS(mr, r operand.Op) {
 	if inst, err := x86.CMOVWPS(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1134,7 +1134,7 @@ func CMOVWPS(mr, r operand.Op) { ctx.CMOVWPS(mr, r) }
 
 func (c *Context) CMPB(amr, imr operand.Op) {
 	if inst, err := x86.CMPB(amr, imr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1143,7 +1143,7 @@ func CMPB(amr, imr operand.Op) { ctx.CMPB(amr, imr) }
 
 func (c *Context) CMPL(emr, imr operand.Op) {
 	if inst, err := x86.CMPL(emr, imr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1152,7 +1152,7 @@ func CMPL(emr, imr operand.Op) { ctx.CMPL(emr, imr) }
 
 func (c *Context) CMPPD(mx, x, i operand.Op) {
 	if inst, err := x86.CMPPD(mx, x, i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1161,7 +1161,7 @@ func CMPPD(mx, x, i operand.Op) { ctx.CMPPD(mx, x, i) }
 
 func (c *Context) CMPPS(mx, x, i operand.Op) {
 	if inst, err := x86.CMPPS(mx, x, i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1170,7 +1170,7 @@ func CMPPS(mx, x, i operand.Op) { ctx.CMPPS(mx, x, i) }
 
 func (c *Context) CMPQ(mr, imr operand.Op) {
 	if inst, err := x86.CMPQ(mr, imr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1179,7 +1179,7 @@ func CMPQ(mr, imr operand.Op) { ctx.CMPQ(mr, imr) }
 
 func (c *Context) CMPSD(mx, x, i operand.Op) {
 	if inst, err := x86.CMPSD(mx, x, i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1188,7 +1188,7 @@ func CMPSD(mx, x, i operand.Op) { ctx.CMPSD(mx, x, i) }
 
 func (c *Context) CMPSS(mx, x, i operand.Op) {
 	if inst, err := x86.CMPSS(mx, x, i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1197,7 +1197,7 @@ func CMPSS(mx, x, i operand.Op) { ctx.CMPSS(mx, x, i) }
 
 func (c *Context) CMPW(amr, imr operand.Op) {
 	if inst, err := x86.CMPW(amr, imr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1206,7 +1206,7 @@ func CMPW(amr, imr operand.Op) { ctx.CMPW(amr, imr) }
 
 func (c *Context) CMPXCHG16B(m operand.Op) {
 	if inst, err := x86.CMPXCHG16B(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1215,7 +1215,7 @@ func CMPXCHG16B(m operand.Op) { ctx.CMPXCHG16B(m) }
 
 func (c *Context) CMPXCHG8B(m operand.Op) {
 	if inst, err := x86.CMPXCHG8B(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1224,7 +1224,7 @@ func CMPXCHG8B(m operand.Op) { ctx.CMPXCHG8B(m) }
 
 func (c *Context) CMPXCHGB(r, mr operand.Op) {
 	if inst, err := x86.CMPXCHGB(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1233,7 +1233,7 @@ func CMPXCHGB(r, mr operand.Op) { ctx.CMPXCHGB(r, mr) }
 
 func (c *Context) CMPXCHGL(r, mr operand.Op) {
 	if inst, err := x86.CMPXCHGL(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1242,7 +1242,7 @@ func CMPXCHGL(r, mr operand.Op) { ctx.CMPXCHGL(r, mr) }
 
 func (c *Context) CMPXCHGQ(r, mr operand.Op) {
 	if inst, err := x86.CMPXCHGQ(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1251,7 +1251,7 @@ func CMPXCHGQ(r, mr operand.Op) { ctx.CMPXCHGQ(r, mr) }
 
 func (c *Context) CMPXCHGW(r, mr operand.Op) {
 	if inst, err := x86.CMPXCHGW(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1260,7 +1260,7 @@ func CMPXCHGW(r, mr operand.Op) { ctx.CMPXCHGW(r, mr) }
 
 func (c *Context) COMISD(mx, x operand.Op) {
 	if inst, err := x86.COMISD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1269,7 +1269,7 @@ func COMISD(mx, x operand.Op) { ctx.COMISD(mx, x) }
 
 func (c *Context) COMISS(mx, x operand.Op) {
 	if inst, err := x86.COMISS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1278,7 +1278,7 @@ func COMISS(mx, x operand.Op) { ctx.COMISS(mx, x) }
 
 func (c *Context) CPUID() {
 	if inst, err := x86.CPUID(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1287,7 +1287,7 @@ func CPUID() { ctx.CPUID() }
 
 func (c *Context) CQO() {
 	if inst, err := x86.CQO(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1296,7 +1296,7 @@ func CQO() { ctx.CQO() }
 
 func (c *Context) CRC32B(mr, r operand.Op) {
 	if inst, err := x86.CRC32B(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1305,7 +1305,7 @@ func CRC32B(mr, r operand.Op) { ctx.CRC32B(mr, r) }
 
 func (c *Context) CRC32L(mr, r operand.Op) {
 	if inst, err := x86.CRC32L(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1314,7 +1314,7 @@ func CRC32L(mr, r operand.Op) { ctx.CRC32L(mr, r) }
 
 func (c *Context) CRC32Q(mr, r operand.Op) {
 	if inst, err := x86.CRC32Q(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1323,7 +1323,7 @@ func CRC32Q(mr, r operand.Op) { ctx.CRC32Q(mr, r) }
 
 func (c *Context) CRC32W(mr, r operand.Op) {
 	if inst, err := x86.CRC32W(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1332,7 +1332,7 @@ func CRC32W(mr, r operand.Op) { ctx.CRC32W(mr, r) }
 
 func (c *Context) CVTPD2PL(mx, x operand.Op) {
 	if inst, err := x86.CVTPD2PL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1341,7 +1341,7 @@ func CVTPD2PL(mx, x operand.Op) { ctx.CVTPD2PL(mx, x) }
 
 func (c *Context) CVTPD2PS(mx, x operand.Op) {
 	if inst, err := x86.CVTPD2PS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1350,7 +1350,7 @@ func CVTPD2PS(mx, x operand.Op) { ctx.CVTPD2PS(mx, x) }
 
 func (c *Context) CVTPL2PD(mx, x operand.Op) {
 	if inst, err := x86.CVTPL2PD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1359,7 +1359,7 @@ func CVTPL2PD(mx, x operand.Op) { ctx.CVTPL2PD(mx, x) }
 
 func (c *Context) CVTPL2PS(mx, x operand.Op) {
 	if inst, err := x86.CVTPL2PS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1368,7 +1368,7 @@ func CVTPL2PS(mx, x operand.Op) { ctx.CVTPL2PS(mx, x) }
 
 func (c *Context) CVTPS2PD(mx, x operand.Op) {
 	if inst, err := x86.CVTPS2PD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1377,7 +1377,7 @@ func CVTPS2PD(mx, x operand.Op) { ctx.CVTPS2PD(mx, x) }
 
 func (c *Context) CVTPS2PL(mx, x operand.Op) {
 	if inst, err := x86.CVTPS2PL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1386,7 +1386,7 @@ func CVTPS2PL(mx, x operand.Op) { ctx.CVTPS2PL(mx, x) }
 
 func (c *Context) CVTSD2SL(mx, r operand.Op) {
 	if inst, err := x86.CVTSD2SL(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1395,7 +1395,7 @@ func CVTSD2SL(mx, r operand.Op) { ctx.CVTSD2SL(mx, r) }
 
 func (c *Context) CVTSD2SS(mx, x operand.Op) {
 	if inst, err := x86.CVTSD2SS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1404,7 +1404,7 @@ func CVTSD2SS(mx, x operand.Op) { ctx.CVTSD2SS(mx, x) }
 
 func (c *Context) CVTSL2SD(mr, x operand.Op) {
 	if inst, err := x86.CVTSL2SD(mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1413,7 +1413,7 @@ func CVTSL2SD(mr, x operand.Op) { ctx.CVTSL2SD(mr, x) }
 
 func (c *Context) CVTSL2SS(mr, x operand.Op) {
 	if inst, err := x86.CVTSL2SS(mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1422,7 +1422,7 @@ func CVTSL2SS(mr, x operand.Op) { ctx.CVTSL2SS(mr, x) }
 
 func (c *Context) CVTSQ2SD(mr, x operand.Op) {
 	if inst, err := x86.CVTSQ2SD(mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1431,7 +1431,7 @@ func CVTSQ2SD(mr, x operand.Op) { ctx.CVTSQ2SD(mr, x) }
 
 func (c *Context) CVTSQ2SS(mr, x operand.Op) {
 	if inst, err := x86.CVTSQ2SS(mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1440,7 +1440,7 @@ func CVTSQ2SS(mr, x operand.Op) { ctx.CVTSQ2SS(mr, x) }
 
 func (c *Context) CVTSS2SD(mx, x operand.Op) {
 	if inst, err := x86.CVTSS2SD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1449,7 +1449,7 @@ func CVTSS2SD(mx, x operand.Op) { ctx.CVTSS2SD(mx, x) }
 
 func (c *Context) CVTSS2SL(mx, r operand.Op) {
 	if inst, err := x86.CVTSS2SL(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1458,7 +1458,7 @@ func CVTSS2SL(mx, r operand.Op) { ctx.CVTSS2SL(mx, r) }
 
 func (c *Context) CVTTPD2PL(mx, x operand.Op) {
 	if inst, err := x86.CVTTPD2PL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1467,7 +1467,7 @@ func CVTTPD2PL(mx, x operand.Op) { ctx.CVTTPD2PL(mx, x) }
 
 func (c *Context) CVTTPS2PL(mx, x operand.Op) {
 	if inst, err := x86.CVTTPS2PL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1476,7 +1476,7 @@ func CVTTPS2PL(mx, x operand.Op) { ctx.CVTTPS2PL(mx, x) }
 
 func (c *Context) CVTTSD2SL(mx, r operand.Op) {
 	if inst, err := x86.CVTTSD2SL(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1485,7 +1485,7 @@ func CVTTSD2SL(mx, r operand.Op) { ctx.CVTTSD2SL(mx, r) }
 
 func (c *Context) CVTTSD2SQ(mx, r operand.Op) {
 	if inst, err := x86.CVTTSD2SQ(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1494,7 +1494,7 @@ func CVTTSD2SQ(mx, r operand.Op) { ctx.CVTTSD2SQ(mx, r) }
 
 func (c *Context) CVTTSS2SL(mx, r operand.Op) {
 	if inst, err := x86.CVTTSS2SL(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1503,7 +1503,7 @@ func CVTTSS2SL(mx, r operand.Op) { ctx.CVTTSS2SL(mx, r) }
 
 func (c *Context) CWD() {
 	if inst, err := x86.CWD(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1512,7 +1512,7 @@ func CWD() { ctx.CWD() }
 
 func (c *Context) CWDE() {
 	if inst, err := x86.CWDE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1521,7 +1521,7 @@ func CWDE() { ctx.CWDE() }
 
 func (c *Context) DECB(mr operand.Op) {
 	if inst, err := x86.DECB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1530,7 +1530,7 @@ func DECB(mr operand.Op) { ctx.DECB(mr) }
 
 func (c *Context) DECL(mr operand.Op) {
 	if inst, err := x86.DECL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1539,7 +1539,7 @@ func DECL(mr operand.Op) { ctx.DECL(mr) }
 
 func (c *Context) DECQ(mr operand.Op) {
 	if inst, err := x86.DECQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1548,7 +1548,7 @@ func DECQ(mr operand.Op) { ctx.DECQ(mr) }
 
 func (c *Context) DECW(mr operand.Op) {
 	if inst, err := x86.DECW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1557,7 +1557,7 @@ func DECW(mr operand.Op) { ctx.DECW(mr) }
 
 func (c *Context) DIVB(mr operand.Op) {
 	if inst, err := x86.DIVB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1566,7 +1566,7 @@ func DIVB(mr operand.Op) { ctx.DIVB(mr) }
 
 func (c *Context) DIVL(mr operand.Op) {
 	if inst, err := x86.DIVL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1575,7 +1575,7 @@ func DIVL(mr operand.Op) { ctx.DIVL(mr) }
 
 func (c *Context) DIVPD(mx, x operand.Op) {
 	if inst, err := x86.DIVPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1584,7 +1584,7 @@ func DIVPD(mx, x operand.Op) { ctx.DIVPD(mx, x) }
 
 func (c *Context) DIVPS(mx, x operand.Op) {
 	if inst, err := x86.DIVPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1593,7 +1593,7 @@ func DIVPS(mx, x operand.Op) { ctx.DIVPS(mx, x) }
 
 func (c *Context) DIVQ(mr operand.Op) {
 	if inst, err := x86.DIVQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1602,7 +1602,7 @@ func DIVQ(mr operand.Op) { ctx.DIVQ(mr) }
 
 func (c *Context) DIVSD(mx, x operand.Op) {
 	if inst, err := x86.DIVSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1611,7 +1611,7 @@ func DIVSD(mx, x operand.Op) { ctx.DIVSD(mx, x) }
 
 func (c *Context) DIVSS(mx, x operand.Op) {
 	if inst, err := x86.DIVSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1620,7 +1620,7 @@ func DIVSS(mx, x operand.Op) { ctx.DIVSS(mx, x) }
 
 func (c *Context) DIVW(mr operand.Op) {
 	if inst, err := x86.DIVW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1629,7 +1629,7 @@ func DIVW(mr operand.Op) { ctx.DIVW(mr) }
 
 func (c *Context) DPPD(i, mx, x operand.Op) {
 	if inst, err := x86.DPPD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1638,7 +1638,7 @@ func DPPD(i, mx, x operand.Op) { ctx.DPPD(i, mx, x) }
 
 func (c *Context) DPPS(i, mx, x operand.Op) {
 	if inst, err := x86.DPPS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1647,7 +1647,7 @@ func DPPS(i, mx, x operand.Op) { ctx.DPPS(i, mx, x) }
 
 func (c *Context) EXTRACTPS(i, x, mr operand.Op) {
 	if inst, err := x86.EXTRACTPS(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1656,7 +1656,7 @@ func EXTRACTPS(i, x, mr operand.Op) { ctx.EXTRACTPS(i, x, mr) }
 
 func (c *Context) HADDPD(mx, x operand.Op) {
 	if inst, err := x86.HADDPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1665,7 +1665,7 @@ func HADDPD(mx, x operand.Op) { ctx.HADDPD(mx, x) }
 
 func (c *Context) HADDPS(mx, x operand.Op) {
 	if inst, err := x86.HADDPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1674,7 +1674,7 @@ func HADDPS(mx, x operand.Op) { ctx.HADDPS(mx, x) }
 
 func (c *Context) HSUBPD(mx, x operand.Op) {
 	if inst, err := x86.HSUBPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1683,7 +1683,7 @@ func HSUBPD(mx, x operand.Op) { ctx.HSUBPD(mx, x) }
 
 func (c *Context) HSUBPS(mx, x operand.Op) {
 	if inst, err := x86.HSUBPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1692,7 +1692,7 @@ func HSUBPS(mx, x operand.Op) { ctx.HSUBPS(mx, x) }
 
 func (c *Context) IDIVB(mr operand.Op) {
 	if inst, err := x86.IDIVB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1701,7 +1701,7 @@ func IDIVB(mr operand.Op) { ctx.IDIVB(mr) }
 
 func (c *Context) IDIVL(mr operand.Op) {
 	if inst, err := x86.IDIVL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1710,7 +1710,7 @@ func IDIVL(mr operand.Op) { ctx.IDIVL(mr) }
 
 func (c *Context) IDIVQ(mr operand.Op) {
 	if inst, err := x86.IDIVQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1719,7 +1719,7 @@ func IDIVQ(mr operand.Op) { ctx.IDIVQ(mr) }
 
 func (c *Context) IDIVW(mr operand.Op) {
 	if inst, err := x86.IDIVW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1728,7 +1728,7 @@ func IDIVW(mr operand.Op) { ctx.IDIVW(mr) }
 
 func (c *Context) IMUL3L(i, mr, r operand.Op) {
 	if inst, err := x86.IMUL3L(i, mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1737,7 +1737,7 @@ func IMUL3L(i, mr, r operand.Op) { ctx.IMUL3L(i, mr, r) }
 
 func (c *Context) IMUL3Q(i, mr, r operand.Op) {
 	if inst, err := x86.IMUL3Q(i, mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1746,7 +1746,7 @@ func IMUL3Q(i, mr, r operand.Op) { ctx.IMUL3Q(i, mr, r) }
 
 func (c *Context) IMUL3W(i, mr, r operand.Op) {
 	if inst, err := x86.IMUL3W(i, mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1755,7 +1755,7 @@ func IMUL3W(i, mr, r operand.Op) { ctx.IMUL3W(i, mr, r) }
 
 func (c *Context) IMULB(mr operand.Op) {
 	if inst, err := x86.IMULB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1764,7 +1764,7 @@ func IMULB(mr operand.Op) { ctx.IMULB(mr) }
 
 func (c *Context) IMULL(ops ...operand.Op) {
 	if inst, err := x86.IMULL(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1773,7 +1773,7 @@ func IMULL(ops ...operand.Op) { ctx.IMULL(ops...) }
 
 func (c *Context) IMULQ(ops ...operand.Op) {
 	if inst, err := x86.IMULQ(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1782,7 +1782,7 @@ func IMULQ(ops ...operand.Op) { ctx.IMULQ(ops...) }
 
 func (c *Context) IMULW(ops ...operand.Op) {
 	if inst, err := x86.IMULW(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1791,7 +1791,7 @@ func IMULW(ops ...operand.Op) { ctx.IMULW(ops...) }
 
 func (c *Context) INCB(mr operand.Op) {
 	if inst, err := x86.INCB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1800,7 +1800,7 @@ func INCB(mr operand.Op) { ctx.INCB(mr) }
 
 func (c *Context) INCL(mr operand.Op) {
 	if inst, err := x86.INCL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1809,7 +1809,7 @@ func INCL(mr operand.Op) { ctx.INCL(mr) }
 
 func (c *Context) INCQ(mr operand.Op) {
 	if inst, err := x86.INCQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1818,7 +1818,7 @@ func INCQ(mr operand.Op) { ctx.INCQ(mr) }
 
 func (c *Context) INCW(mr operand.Op) {
 	if inst, err := x86.INCW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1827,7 +1827,7 @@ func INCW(mr operand.Op) { ctx.INCW(mr) }
 
 func (c *Context) INSERTPS(i, mx, x operand.Op) {
 	if inst, err := x86.INSERTPS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1836,7 +1836,7 @@ func INSERTPS(i, mx, x operand.Op) { ctx.INSERTPS(i, mx, x) }
 
 func (c *Context) INT(i operand.Op) {
 	if inst, err := x86.INT(i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1845,7 +1845,7 @@ func INT(i operand.Op) { ctx.INT(i) }
 
 func (c *Context) JA(r operand.Op) {
 	if inst, err := x86.JA(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1854,7 +1854,7 @@ func JA(r operand.Op) { ctx.JA(r) }
 
 func (c *Context) JAE(r operand.Op) {
 	if inst, err := x86.JAE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1863,7 +1863,7 @@ func JAE(r operand.Op) { ctx.JAE(r) }
 
 func (c *Context) JB(r operand.Op) {
 	if inst, err := x86.JB(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1872,7 +1872,7 @@ func JB(r operand.Op) { ctx.JB(r) }
 
 func (c *Context) JBE(r operand.Op) {
 	if inst, err := x86.JBE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1881,7 +1881,7 @@ func JBE(r operand.Op) { ctx.JBE(r) }
 
 func (c *Context) JC(r operand.Op) {
 	if inst, err := x86.JC(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1890,7 +1890,7 @@ func JC(r operand.Op) { ctx.JC(r) }
 
 func (c *Context) JCC(r operand.Op) {
 	if inst, err := x86.JCC(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1899,7 +1899,7 @@ func JCC(r operand.Op) { ctx.JCC(r) }
 
 func (c *Context) JCS(r operand.Op) {
 	if inst, err := x86.JCS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1908,7 +1908,7 @@ func JCS(r operand.Op) { ctx.JCS(r) }
 
 func (c *Context) JCXZL(r operand.Op) {
 	if inst, err := x86.JCXZL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1917,7 +1917,7 @@ func JCXZL(r operand.Op) { ctx.JCXZL(r) }
 
 func (c *Context) JCXZQ(r operand.Op) {
 	if inst, err := x86.JCXZQ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1926,7 +1926,7 @@ func JCXZQ(r operand.Op) { ctx.JCXZQ(r) }
 
 func (c *Context) JE(r operand.Op) {
 	if inst, err := x86.JE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1935,7 +1935,7 @@ func JE(r operand.Op) { ctx.JE(r) }
 
 func (c *Context) JEQ(r operand.Op) {
 	if inst, err := x86.JEQ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1944,7 +1944,7 @@ func JEQ(r operand.Op) { ctx.JEQ(r) }
 
 func (c *Context) JG(r operand.Op) {
 	if inst, err := x86.JG(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1953,7 +1953,7 @@ func JG(r operand.Op) { ctx.JG(r) }
 
 func (c *Context) JGE(r operand.Op) {
 	if inst, err := x86.JGE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1962,7 +1962,7 @@ func JGE(r operand.Op) { ctx.JGE(r) }
 
 func (c *Context) JGT(r operand.Op) {
 	if inst, err := x86.JGT(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1971,7 +1971,7 @@ func JGT(r operand.Op) { ctx.JGT(r) }
 
 func (c *Context) JHI(r operand.Op) {
 	if inst, err := x86.JHI(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1980,7 +1980,7 @@ func JHI(r operand.Op) { ctx.JHI(r) }
 
 func (c *Context) JHS(r operand.Op) {
 	if inst, err := x86.JHS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1989,7 +1989,7 @@ func JHS(r operand.Op) { ctx.JHS(r) }
 
 func (c *Context) JL(r operand.Op) {
 	if inst, err := x86.JL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -1998,7 +1998,7 @@ func JL(r operand.Op) { ctx.JL(r) }
 
 func (c *Context) JLE(r operand.Op) {
 	if inst, err := x86.JLE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2007,7 +2007,7 @@ func JLE(r operand.Op) { ctx.JLE(r) }
 
 func (c *Context) JLO(r operand.Op) {
 	if inst, err := x86.JLO(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2016,7 +2016,7 @@ func JLO(r operand.Op) { ctx.JLO(r) }
 
 func (c *Context) JLS(r operand.Op) {
 	if inst, err := x86.JLS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2025,7 +2025,7 @@ func JLS(r operand.Op) { ctx.JLS(r) }
 
 func (c *Context) JLT(r operand.Op) {
 	if inst, err := x86.JLT(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2034,7 +2034,7 @@ func JLT(r operand.Op) { ctx.JLT(r) }
 
 func (c *Context) JMI(r operand.Op) {
 	if inst, err := x86.JMI(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2043,7 +2043,7 @@ func JMI(r operand.Op) { ctx.JMI(r) }
 
 func (c *Context) JMP(mr operand.Op) {
 	if inst, err := x86.JMP(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2052,7 +2052,7 @@ func JMP(mr operand.Op) { ctx.JMP(mr) }
 
 func (c *Context) JNA(r operand.Op) {
 	if inst, err := x86.JNA(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2061,7 +2061,7 @@ func JNA(r operand.Op) { ctx.JNA(r) }
 
 func (c *Context) JNAE(r operand.Op) {
 	if inst, err := x86.JNAE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2070,7 +2070,7 @@ func JNAE(r operand.Op) { ctx.JNAE(r) }
 
 func (c *Context) JNB(r operand.Op) {
 	if inst, err := x86.JNB(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2079,7 +2079,7 @@ func JNB(r operand.Op) { ctx.JNB(r) }
 
 func (c *Context) JNBE(r operand.Op) {
 	if inst, err := x86.JNBE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2088,7 +2088,7 @@ func JNBE(r operand.Op) { ctx.JNBE(r) }
 
 func (c *Context) JNC(r operand.Op) {
 	if inst, err := x86.JNC(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2097,7 +2097,7 @@ func JNC(r operand.Op) { ctx.JNC(r) }
 
 func (c *Context) JNE(r operand.Op) {
 	if inst, err := x86.JNE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2106,7 +2106,7 @@ func JNE(r operand.Op) { ctx.JNE(r) }
 
 func (c *Context) JNG(r operand.Op) {
 	if inst, err := x86.JNG(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2115,7 +2115,7 @@ func JNG(r operand.Op) { ctx.JNG(r) }
 
 func (c *Context) JNGE(r operand.Op) {
 	if inst, err := x86.JNGE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2124,7 +2124,7 @@ func JNGE(r operand.Op) { ctx.JNGE(r) }
 
 func (c *Context) JNL(r operand.Op) {
 	if inst, err := x86.JNL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2133,7 +2133,7 @@ func JNL(r operand.Op) { ctx.JNL(r) }
 
 func (c *Context) JNLE(r operand.Op) {
 	if inst, err := x86.JNLE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2142,7 +2142,7 @@ func JNLE(r operand.Op) { ctx.JNLE(r) }
 
 func (c *Context) JNO(r operand.Op) {
 	if inst, err := x86.JNO(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2151,7 +2151,7 @@ func JNO(r operand.Op) { ctx.JNO(r) }
 
 func (c *Context) JNP(r operand.Op) {
 	if inst, err := x86.JNP(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2160,7 +2160,7 @@ func JNP(r operand.Op) { ctx.JNP(r) }
 
 func (c *Context) JNS(r operand.Op) {
 	if inst, err := x86.JNS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2169,7 +2169,7 @@ func JNS(r operand.Op) { ctx.JNS(r) }
 
 func (c *Context) JNZ(r operand.Op) {
 	if inst, err := x86.JNZ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2178,7 +2178,7 @@ func JNZ(r operand.Op) { ctx.JNZ(r) }
 
 func (c *Context) JO(r operand.Op) {
 	if inst, err := x86.JO(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2187,7 +2187,7 @@ func JO(r operand.Op) { ctx.JO(r) }
 
 func (c *Context) JOC(r operand.Op) {
 	if inst, err := x86.JOC(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2196,7 +2196,7 @@ func JOC(r operand.Op) { ctx.JOC(r) }
 
 func (c *Context) JOS(r operand.Op) {
 	if inst, err := x86.JOS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2205,7 +2205,7 @@ func JOS(r operand.Op) { ctx.JOS(r) }
 
 func (c *Context) JP(r operand.Op) {
 	if inst, err := x86.JP(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2214,7 +2214,7 @@ func JP(r operand.Op) { ctx.JP(r) }
 
 func (c *Context) JPC(r operand.Op) {
 	if inst, err := x86.JPC(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2223,7 +2223,7 @@ func JPC(r operand.Op) { ctx.JPC(r) }
 
 func (c *Context) JPE(r operand.Op) {
 	if inst, err := x86.JPE(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2232,7 +2232,7 @@ func JPE(r operand.Op) { ctx.JPE(r) }
 
 func (c *Context) JPL(r operand.Op) {
 	if inst, err := x86.JPL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2241,7 +2241,7 @@ func JPL(r operand.Op) { ctx.JPL(r) }
 
 func (c *Context) JPO(r operand.Op) {
 	if inst, err := x86.JPO(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2250,7 +2250,7 @@ func JPO(r operand.Op) { ctx.JPO(r) }
 
 func (c *Context) JPS(r operand.Op) {
 	if inst, err := x86.JPS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2259,7 +2259,7 @@ func JPS(r operand.Op) { ctx.JPS(r) }
 
 func (c *Context) JS(r operand.Op) {
 	if inst, err := x86.JS(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2268,7 +2268,7 @@ func JS(r operand.Op) { ctx.JS(r) }
 
 func (c *Context) JZ(r operand.Op) {
 	if inst, err := x86.JZ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2277,7 +2277,7 @@ func JZ(r operand.Op) { ctx.JZ(r) }
 
 func (c *Context) LDDQU(m, x operand.Op) {
 	if inst, err := x86.LDDQU(m, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2286,7 +2286,7 @@ func LDDQU(m, x operand.Op) { ctx.LDDQU(m, x) }
 
 func (c *Context) LDMXCSR(m operand.Op) {
 	if inst, err := x86.LDMXCSR(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2295,7 +2295,7 @@ func LDMXCSR(m operand.Op) { ctx.LDMXCSR(m) }
 
 func (c *Context) LEAL(m, r operand.Op) {
 	if inst, err := x86.LEAL(m, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2304,7 +2304,7 @@ func LEAL(m, r operand.Op) { ctx.LEAL(m, r) }
 
 func (c *Context) LEAQ(m, r operand.Op) {
 	if inst, err := x86.LEAQ(m, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2313,7 +2313,7 @@ func LEAQ(m, r operand.Op) { ctx.LEAQ(m, r) }
 
 func (c *Context) LEAW(m, r operand.Op) {
 	if inst, err := x86.LEAW(m, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2322,7 +2322,7 @@ func LEAW(m, r operand.Op) { ctx.LEAW(m, r) }
 
 func (c *Context) LFENCE() {
 	if inst, err := x86.LFENCE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2331,7 +2331,7 @@ func LFENCE() { ctx.LFENCE() }
 
 func (c *Context) LZCNTL(mr, r operand.Op) {
 	if inst, err := x86.LZCNTL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2340,7 +2340,7 @@ func LZCNTL(mr, r operand.Op) { ctx.LZCNTL(mr, r) }
 
 func (c *Context) LZCNTQ(mr, r operand.Op) {
 	if inst, err := x86.LZCNTQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2349,7 +2349,7 @@ func LZCNTQ(mr, r operand.Op) { ctx.LZCNTQ(mr, r) }
 
 func (c *Context) LZCNTW(mr, r operand.Op) {
 	if inst, err := x86.LZCNTW(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2358,7 +2358,7 @@ func LZCNTW(mr, r operand.Op) { ctx.LZCNTW(mr, r) }
 
 func (c *Context) MASKMOVDQU(x, x1 operand.Op) {
 	if inst, err := x86.MASKMOVDQU(x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2367,7 +2367,7 @@ func MASKMOVDQU(x, x1 operand.Op) { ctx.MASKMOVDQU(x, x1) }
 
 func (c *Context) MASKMOVOU(x, x1 operand.Op) {
 	if inst, err := x86.MASKMOVOU(x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2376,7 +2376,7 @@ func MASKMOVOU(x, x1 operand.Op) { ctx.MASKMOVOU(x, x1) }
 
 func (c *Context) MAXPD(mx, x operand.Op) {
 	if inst, err := x86.MAXPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2385,7 +2385,7 @@ func MAXPD(mx, x operand.Op) { ctx.MAXPD(mx, x) }
 
 func (c *Context) MAXPS(mx, x operand.Op) {
 	if inst, err := x86.MAXPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2394,7 +2394,7 @@ func MAXPS(mx, x operand.Op) { ctx.MAXPS(mx, x) }
 
 func (c *Context) MAXSD(mx, x operand.Op) {
 	if inst, err := x86.MAXSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2403,7 +2403,7 @@ func MAXSD(mx, x operand.Op) { ctx.MAXSD(mx, x) }
 
 func (c *Context) MAXSS(mx, x operand.Op) {
 	if inst, err := x86.MAXSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2412,7 +2412,7 @@ func MAXSS(mx, x operand.Op) { ctx.MAXSS(mx, x) }
 
 func (c *Context) MFENCE() {
 	if inst, err := x86.MFENCE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2421,7 +2421,7 @@ func MFENCE() { ctx.MFENCE() }
 
 func (c *Context) MINPD(mx, x operand.Op) {
 	if inst, err := x86.MINPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2430,7 +2430,7 @@ func MINPD(mx, x operand.Op) { ctx.MINPD(mx, x) }
 
 func (c *Context) MINPS(mx, x operand.Op) {
 	if inst, err := x86.MINPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2439,7 +2439,7 @@ func MINPS(mx, x operand.Op) { ctx.MINPS(mx, x) }
 
 func (c *Context) MINSD(mx, x operand.Op) {
 	if inst, err := x86.MINSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2448,7 +2448,7 @@ func MINSD(mx, x operand.Op) { ctx.MINSD(mx, x) }
 
 func (c *Context) MINSS(mx, x operand.Op) {
 	if inst, err := x86.MINSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2457,7 +2457,7 @@ func MINSS(mx, x operand.Op) { ctx.MINSS(mx, x) }
 
 func (c *Context) MONITOR() {
 	if inst, err := x86.MONITOR(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2466,7 +2466,7 @@ func MONITOR() { ctx.MONITOR() }
 
 func (c *Context) MOVAPD(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVAPD(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2475,7 +2475,7 @@ func MOVAPD(mx, mx1 operand.Op) { ctx.MOVAPD(mx, mx1) }
 
 func (c *Context) MOVAPS(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVAPS(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2484,7 +2484,7 @@ func MOVAPS(mx, mx1 operand.Op) { ctx.MOVAPS(mx, mx1) }
 
 func (c *Context) MOVB(imr, mr operand.Op) {
 	if inst, err := x86.MOVB(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2493,7 +2493,7 @@ func MOVB(imr, mr operand.Op) { ctx.MOVB(imr, mr) }
 
 func (c *Context) MOVBELL(mr, mr1 operand.Op) {
 	if inst, err := x86.MOVBELL(mr, mr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2502,7 +2502,7 @@ func MOVBELL(mr, mr1 operand.Op) { ctx.MOVBELL(mr, mr1) }
 
 func (c *Context) MOVBEQQ(mr, mr1 operand.Op) {
 	if inst, err := x86.MOVBEQQ(mr, mr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2511,7 +2511,7 @@ func MOVBEQQ(mr, mr1 operand.Op) { ctx.MOVBEQQ(mr, mr1) }
 
 func (c *Context) MOVBEWW(mr, mr1 operand.Op) {
 	if inst, err := x86.MOVBEWW(mr, mr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2520,7 +2520,7 @@ func MOVBEWW(mr, mr1 operand.Op) { ctx.MOVBEWW(mr, mr1) }
 
 func (c *Context) MOVBLSX(mr, r operand.Op) {
 	if inst, err := x86.MOVBLSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2529,7 +2529,7 @@ func MOVBLSX(mr, r operand.Op) { ctx.MOVBLSX(mr, r) }
 
 func (c *Context) MOVBLZX(mr, r operand.Op) {
 	if inst, err := x86.MOVBLZX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2538,7 +2538,7 @@ func MOVBLZX(mr, r operand.Op) { ctx.MOVBLZX(mr, r) }
 
 func (c *Context) MOVBQSX(mr, r operand.Op) {
 	if inst, err := x86.MOVBQSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2547,7 +2547,7 @@ func MOVBQSX(mr, r operand.Op) { ctx.MOVBQSX(mr, r) }
 
 func (c *Context) MOVBQZX(mr, r operand.Op) {
 	if inst, err := x86.MOVBQZX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2556,7 +2556,7 @@ func MOVBQZX(mr, r operand.Op) { ctx.MOVBQZX(mr, r) }
 
 func (c *Context) MOVBWSX(mr, r operand.Op) {
 	if inst, err := x86.MOVBWSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2565,7 +2565,7 @@ func MOVBWSX(mr, r operand.Op) { ctx.MOVBWSX(mr, r) }
 
 func (c *Context) MOVBWZX(mr, r operand.Op) {
 	if inst, err := x86.MOVBWZX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2574,7 +2574,7 @@ func MOVBWZX(mr, r operand.Op) { ctx.MOVBWZX(mr, r) }
 
 func (c *Context) MOVD(imrx, mrx operand.Op) {
 	if inst, err := x86.MOVD(imrx, mrx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2583,7 +2583,7 @@ func MOVD(imrx, mrx operand.Op) { ctx.MOVD(imrx, mrx) }
 
 func (c *Context) MOVDDUP(mx, x operand.Op) {
 	if inst, err := x86.MOVDDUP(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2592,7 +2592,7 @@ func MOVDDUP(mx, x operand.Op) { ctx.MOVDDUP(mx, x) }
 
 func (c *Context) MOVDQ2Q(imrx, mrx operand.Op) {
 	if inst, err := x86.MOVDQ2Q(imrx, mrx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2601,7 +2601,7 @@ func MOVDQ2Q(imrx, mrx operand.Op) { ctx.MOVDQ2Q(imrx, mrx) }
 
 func (c *Context) MOVHLPS(x, x1 operand.Op) {
 	if inst, err := x86.MOVHLPS(x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2610,7 +2610,7 @@ func MOVHLPS(x, x1 operand.Op) { ctx.MOVHLPS(x, x1) }
 
 func (c *Context) MOVHPD(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVHPD(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2619,7 +2619,7 @@ func MOVHPD(mx, mx1 operand.Op) { ctx.MOVHPD(mx, mx1) }
 
 func (c *Context) MOVHPS(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVHPS(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2628,7 +2628,7 @@ func MOVHPS(mx, mx1 operand.Op) { ctx.MOVHPS(mx, mx1) }
 
 func (c *Context) MOVL(imr, mr operand.Op) {
 	if inst, err := x86.MOVL(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2637,7 +2637,7 @@ func MOVL(imr, mr operand.Op) { ctx.MOVL(imr, mr) }
 
 func (c *Context) MOVLHPS(x, x1 operand.Op) {
 	if inst, err := x86.MOVLHPS(x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2646,7 +2646,7 @@ func MOVLHPS(x, x1 operand.Op) { ctx.MOVLHPS(x, x1) }
 
 func (c *Context) MOVLPD(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVLPD(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2655,7 +2655,7 @@ func MOVLPD(mx, mx1 operand.Op) { ctx.MOVLPD(mx, mx1) }
 
 func (c *Context) MOVLPS(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVLPS(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2664,7 +2664,7 @@ func MOVLPS(mx, mx1 operand.Op) { ctx.MOVLPS(mx, mx1) }
 
 func (c *Context) MOVLQSX(mr, r operand.Op) {
 	if inst, err := x86.MOVLQSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2673,7 +2673,7 @@ func MOVLQSX(mr, r operand.Op) { ctx.MOVLQSX(mr, r) }
 
 func (c *Context) MOVLQZX(m, r operand.Op) {
 	if inst, err := x86.MOVLQZX(m, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2682,7 +2682,7 @@ func MOVLQZX(m, r operand.Op) { ctx.MOVLQZX(m, r) }
 
 func (c *Context) MOVMSKPD(x, r operand.Op) {
 	if inst, err := x86.MOVMSKPD(x, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2691,7 +2691,7 @@ func MOVMSKPD(x, r operand.Op) { ctx.MOVMSKPD(x, r) }
 
 func (c *Context) MOVMSKPS(x, r operand.Op) {
 	if inst, err := x86.MOVMSKPS(x, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2700,7 +2700,7 @@ func MOVMSKPS(x, r operand.Op) { ctx.MOVMSKPS(x, r) }
 
 func (c *Context) MOVNTDQ(x, m operand.Op) {
 	if inst, err := x86.MOVNTDQ(x, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2709,7 +2709,7 @@ func MOVNTDQ(x, m operand.Op) { ctx.MOVNTDQ(x, m) }
 
 func (c *Context) MOVNTDQA(m, x operand.Op) {
 	if inst, err := x86.MOVNTDQA(m, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2718,7 +2718,7 @@ func MOVNTDQA(m, x operand.Op) { ctx.MOVNTDQA(m, x) }
 
 func (c *Context) MOVNTIL(r, m operand.Op) {
 	if inst, err := x86.MOVNTIL(r, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2727,7 +2727,7 @@ func MOVNTIL(r, m operand.Op) { ctx.MOVNTIL(r, m) }
 
 func (c *Context) MOVNTIQ(r, m operand.Op) {
 	if inst, err := x86.MOVNTIQ(r, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2736,7 +2736,7 @@ func MOVNTIQ(r, m operand.Op) { ctx.MOVNTIQ(r, m) }
 
 func (c *Context) MOVNTO(x, m operand.Op) {
 	if inst, err := x86.MOVNTO(x, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2745,7 +2745,7 @@ func MOVNTO(x, m operand.Op) { ctx.MOVNTO(x, m) }
 
 func (c *Context) MOVNTPD(x, m operand.Op) {
 	if inst, err := x86.MOVNTPD(x, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2754,7 +2754,7 @@ func MOVNTPD(x, m operand.Op) { ctx.MOVNTPD(x, m) }
 
 func (c *Context) MOVNTPS(x, m operand.Op) {
 	if inst, err := x86.MOVNTPS(x, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2763,7 +2763,7 @@ func MOVNTPS(x, m operand.Op) { ctx.MOVNTPS(x, m) }
 
 func (c *Context) MOVO(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVO(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2772,7 +2772,7 @@ func MOVO(mx, mx1 operand.Op) { ctx.MOVO(mx, mx1) }
 
 func (c *Context) MOVOA(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVOA(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2781,7 +2781,7 @@ func MOVOA(mx, mx1 operand.Op) { ctx.MOVOA(mx, mx1) }
 
 func (c *Context) MOVOU(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVOU(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2790,7 +2790,7 @@ func MOVOU(mx, mx1 operand.Op) { ctx.MOVOU(mx, mx1) }
 
 func (c *Context) MOVQ(imrx, mrx operand.Op) {
 	if inst, err := x86.MOVQ(imrx, mrx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2799,7 +2799,7 @@ func MOVQ(imrx, mrx operand.Op) { ctx.MOVQ(imrx, mrx) }
 
 func (c *Context) MOVSD(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVSD(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2808,7 +2808,7 @@ func MOVSD(mx, mx1 operand.Op) { ctx.MOVSD(mx, mx1) }
 
 func (c *Context) MOVSHDUP(mx, x operand.Op) {
 	if inst, err := x86.MOVSHDUP(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2817,7 +2817,7 @@ func MOVSHDUP(mx, x operand.Op) { ctx.MOVSHDUP(mx, x) }
 
 func (c *Context) MOVSLDUP(mx, x operand.Op) {
 	if inst, err := x86.MOVSLDUP(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2826,7 +2826,7 @@ func MOVSLDUP(mx, x operand.Op) { ctx.MOVSLDUP(mx, x) }
 
 func (c *Context) MOVSS(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVSS(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2835,7 +2835,7 @@ func MOVSS(mx, mx1 operand.Op) { ctx.MOVSS(mx, mx1) }
 
 func (c *Context) MOVUPD(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVUPD(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2844,7 +2844,7 @@ func MOVUPD(mx, mx1 operand.Op) { ctx.MOVUPD(mx, mx1) }
 
 func (c *Context) MOVUPS(mx, mx1 operand.Op) {
 	if inst, err := x86.MOVUPS(mx, mx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2853,7 +2853,7 @@ func MOVUPS(mx, mx1 operand.Op) { ctx.MOVUPS(mx, mx1) }
 
 func (c *Context) MOVW(imr, mr operand.Op) {
 	if inst, err := x86.MOVW(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2862,7 +2862,7 @@ func MOVW(imr, mr operand.Op) { ctx.MOVW(imr, mr) }
 
 func (c *Context) MOVWLSX(mr, r operand.Op) {
 	if inst, err := x86.MOVWLSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2871,7 +2871,7 @@ func MOVWLSX(mr, r operand.Op) { ctx.MOVWLSX(mr, r) }
 
 func (c *Context) MOVWLZX(mr, r operand.Op) {
 	if inst, err := x86.MOVWLZX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2880,7 +2880,7 @@ func MOVWLZX(mr, r operand.Op) { ctx.MOVWLZX(mr, r) }
 
 func (c *Context) MOVWQSX(mr, r operand.Op) {
 	if inst, err := x86.MOVWQSX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2889,7 +2889,7 @@ func MOVWQSX(mr, r operand.Op) { ctx.MOVWQSX(mr, r) }
 
 func (c *Context) MOVWQZX(mr, r operand.Op) {
 	if inst, err := x86.MOVWQZX(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2898,7 +2898,7 @@ func MOVWQZX(mr, r operand.Op) { ctx.MOVWQZX(mr, r) }
 
 func (c *Context) MPSADBW(i, mx, x operand.Op) {
 	if inst, err := x86.MPSADBW(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2907,7 +2907,7 @@ func MPSADBW(i, mx, x operand.Op) { ctx.MPSADBW(i, mx, x) }
 
 func (c *Context) MULB(mr operand.Op) {
 	if inst, err := x86.MULB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2916,7 +2916,7 @@ func MULB(mr operand.Op) { ctx.MULB(mr) }
 
 func (c *Context) MULL(mr operand.Op) {
 	if inst, err := x86.MULL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2925,7 +2925,7 @@ func MULL(mr operand.Op) { ctx.MULL(mr) }
 
 func (c *Context) MULPD(mx, x operand.Op) {
 	if inst, err := x86.MULPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2934,7 +2934,7 @@ func MULPD(mx, x operand.Op) { ctx.MULPD(mx, x) }
 
 func (c *Context) MULPS(mx, x operand.Op) {
 	if inst, err := x86.MULPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2943,7 +2943,7 @@ func MULPS(mx, x operand.Op) { ctx.MULPS(mx, x) }
 
 func (c *Context) MULQ(mr operand.Op) {
 	if inst, err := x86.MULQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2952,7 +2952,7 @@ func MULQ(mr operand.Op) { ctx.MULQ(mr) }
 
 func (c *Context) MULSD(mx, x operand.Op) {
 	if inst, err := x86.MULSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2961,7 +2961,7 @@ func MULSD(mx, x operand.Op) { ctx.MULSD(mx, x) }
 
 func (c *Context) MULSS(mx, x operand.Op) {
 	if inst, err := x86.MULSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2970,7 +2970,7 @@ func MULSS(mx, x operand.Op) { ctx.MULSS(mx, x) }
 
 func (c *Context) MULW(mr operand.Op) {
 	if inst, err := x86.MULW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2979,7 +2979,7 @@ func MULW(mr operand.Op) { ctx.MULW(mr) }
 
 func (c *Context) MULXL(mr, r, r1 operand.Op) {
 	if inst, err := x86.MULXL(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2988,7 +2988,7 @@ func MULXL(mr, r, r1 operand.Op) { ctx.MULXL(mr, r, r1) }
 
 func (c *Context) MULXQ(mr, r, r1 operand.Op) {
 	if inst, err := x86.MULXQ(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -2997,7 +2997,7 @@ func MULXQ(mr, r, r1 operand.Op) { ctx.MULXQ(mr, r, r1) }
 
 func (c *Context) MWAIT() {
 	if inst, err := x86.MWAIT(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3006,7 +3006,7 @@ func MWAIT() { ctx.MWAIT() }
 
 func (c *Context) NEGB(mr operand.Op) {
 	if inst, err := x86.NEGB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3015,7 +3015,7 @@ func NEGB(mr operand.Op) { ctx.NEGB(mr) }
 
 func (c *Context) NEGL(mr operand.Op) {
 	if inst, err := x86.NEGL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3024,7 +3024,7 @@ func NEGL(mr operand.Op) { ctx.NEGL(mr) }
 
 func (c *Context) NEGQ(mr operand.Op) {
 	if inst, err := x86.NEGQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3033,7 +3033,7 @@ func NEGQ(mr operand.Op) { ctx.NEGQ(mr) }
 
 func (c *Context) NEGW(mr operand.Op) {
 	if inst, err := x86.NEGW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3042,7 +3042,7 @@ func NEGW(mr operand.Op) { ctx.NEGW(mr) }
 
 func (c *Context) NOP() {
 	if inst, err := x86.NOP(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3051,7 +3051,7 @@ func NOP() { ctx.NOP() }
 
 func (c *Context) NOTB(mr operand.Op) {
 	if inst, err := x86.NOTB(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3060,7 +3060,7 @@ func NOTB(mr operand.Op) { ctx.NOTB(mr) }
 
 func (c *Context) NOTL(mr operand.Op) {
 	if inst, err := x86.NOTL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3069,7 +3069,7 @@ func NOTL(mr operand.Op) { ctx.NOTL(mr) }
 
 func (c *Context) NOTQ(mr operand.Op) {
 	if inst, err := x86.NOTQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3078,7 +3078,7 @@ func NOTQ(mr operand.Op) { ctx.NOTQ(mr) }
 
 func (c *Context) NOTW(mr operand.Op) {
 	if inst, err := x86.NOTW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3087,7 +3087,7 @@ func NOTW(mr operand.Op) { ctx.NOTW(mr) }
 
 func (c *Context) ORB(imr, amr operand.Op) {
 	if inst, err := x86.ORB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3096,7 +3096,7 @@ func ORB(imr, amr operand.Op) { ctx.ORB(imr, amr) }
 
 func (c *Context) ORL(imr, emr operand.Op) {
 	if inst, err := x86.ORL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3105,7 +3105,7 @@ func ORL(imr, emr operand.Op) { ctx.ORL(imr, emr) }
 
 func (c *Context) ORPD(mx, x operand.Op) {
 	if inst, err := x86.ORPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3114,7 +3114,7 @@ func ORPD(mx, x operand.Op) { ctx.ORPD(mx, x) }
 
 func (c *Context) ORPS(mx, x operand.Op) {
 	if inst, err := x86.ORPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3123,7 +3123,7 @@ func ORPS(mx, x operand.Op) { ctx.ORPS(mx, x) }
 
 func (c *Context) ORQ(imr, mr operand.Op) {
 	if inst, err := x86.ORQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3132,7 +3132,7 @@ func ORQ(imr, mr operand.Op) { ctx.ORQ(imr, mr) }
 
 func (c *Context) ORW(imr, amr operand.Op) {
 	if inst, err := x86.ORW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3141,7 +3141,7 @@ func ORW(imr, amr operand.Op) { ctx.ORW(imr, amr) }
 
 func (c *Context) PABSB(mx, x operand.Op) {
 	if inst, err := x86.PABSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3150,7 +3150,7 @@ func PABSB(mx, x operand.Op) { ctx.PABSB(mx, x) }
 
 func (c *Context) PABSD(mx, x operand.Op) {
 	if inst, err := x86.PABSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3159,7 +3159,7 @@ func PABSD(mx, x operand.Op) { ctx.PABSD(mx, x) }
 
 func (c *Context) PABSW(mx, x operand.Op) {
 	if inst, err := x86.PABSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3168,7 +3168,7 @@ func PABSW(mx, x operand.Op) { ctx.PABSW(mx, x) }
 
 func (c *Context) PACKSSLW(mx, x operand.Op) {
 	if inst, err := x86.PACKSSLW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3177,7 +3177,7 @@ func PACKSSLW(mx, x operand.Op) { ctx.PACKSSLW(mx, x) }
 
 func (c *Context) PACKSSWB(mx, x operand.Op) {
 	if inst, err := x86.PACKSSWB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3186,7 +3186,7 @@ func PACKSSWB(mx, x operand.Op) { ctx.PACKSSWB(mx, x) }
 
 func (c *Context) PACKUSDW(mx, x operand.Op) {
 	if inst, err := x86.PACKUSDW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3195,7 +3195,7 @@ func PACKUSDW(mx, x operand.Op) { ctx.PACKUSDW(mx, x) }
 
 func (c *Context) PACKUSWB(mx, x operand.Op) {
 	if inst, err := x86.PACKUSWB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3204,7 +3204,7 @@ func PACKUSWB(mx, x operand.Op) { ctx.PACKUSWB(mx, x) }
 
 func (c *Context) PADDB(mx, x operand.Op) {
 	if inst, err := x86.PADDB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3213,7 +3213,7 @@ func PADDB(mx, x operand.Op) { ctx.PADDB(mx, x) }
 
 func (c *Context) PADDD(mx, x operand.Op) {
 	if inst, err := x86.PADDD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3222,7 +3222,7 @@ func PADDD(mx, x operand.Op) { ctx.PADDD(mx, x) }
 
 func (c *Context) PADDL(mx, x operand.Op) {
 	if inst, err := x86.PADDL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3231,7 +3231,7 @@ func PADDL(mx, x operand.Op) { ctx.PADDL(mx, x) }
 
 func (c *Context) PADDQ(mx, x operand.Op) {
 	if inst, err := x86.PADDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3240,7 +3240,7 @@ func PADDQ(mx, x operand.Op) { ctx.PADDQ(mx, x) }
 
 func (c *Context) PADDSB(mx, x operand.Op) {
 	if inst, err := x86.PADDSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3249,7 +3249,7 @@ func PADDSB(mx, x operand.Op) { ctx.PADDSB(mx, x) }
 
 func (c *Context) PADDSW(mx, x operand.Op) {
 	if inst, err := x86.PADDSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3258,7 +3258,7 @@ func PADDSW(mx, x operand.Op) { ctx.PADDSW(mx, x) }
 
 func (c *Context) PADDUSB(mx, x operand.Op) {
 	if inst, err := x86.PADDUSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3267,7 +3267,7 @@ func PADDUSB(mx, x operand.Op) { ctx.PADDUSB(mx, x) }
 
 func (c *Context) PADDUSW(mx, x operand.Op) {
 	if inst, err := x86.PADDUSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3276,7 +3276,7 @@ func PADDUSW(mx, x operand.Op) { ctx.PADDUSW(mx, x) }
 
 func (c *Context) PADDW(mx, x operand.Op) {
 	if inst, err := x86.PADDW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3285,7 +3285,7 @@ func PADDW(mx, x operand.Op) { ctx.PADDW(mx, x) }
 
 func (c *Context) PALIGNR(i, mx, x operand.Op) {
 	if inst, err := x86.PALIGNR(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3294,7 +3294,7 @@ func PALIGNR(i, mx, x operand.Op) { ctx.PALIGNR(i, mx, x) }
 
 func (c *Context) PAND(mx, x operand.Op) {
 	if inst, err := x86.PAND(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3303,7 +3303,7 @@ func PAND(mx, x operand.Op) { ctx.PAND(mx, x) }
 
 func (c *Context) PANDN(mx, x operand.Op) {
 	if inst, err := x86.PANDN(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3312,7 +3312,7 @@ func PANDN(mx, x operand.Op) { ctx.PANDN(mx, x) }
 
 func (c *Context) PAUSE() {
 	if inst, err := x86.PAUSE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3321,7 +3321,7 @@ func PAUSE() { ctx.PAUSE() }
 
 func (c *Context) PAVGB(mx, x operand.Op) {
 	if inst, err := x86.PAVGB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3330,7 +3330,7 @@ func PAVGB(mx, x operand.Op) { ctx.PAVGB(mx, x) }
 
 func (c *Context) PAVGW(mx, x operand.Op) {
 	if inst, err := x86.PAVGW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3339,7 +3339,7 @@ func PAVGW(mx, x operand.Op) { ctx.PAVGW(mx, x) }
 
 func (c *Context) PBLENDVB(x, mx, x1 operand.Op) {
 	if inst, err := x86.PBLENDVB(x, mx, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3348,7 +3348,7 @@ func PBLENDVB(x, mx, x1 operand.Op) { ctx.PBLENDVB(x, mx, x1) }
 
 func (c *Context) PBLENDW(i, mx, x operand.Op) {
 	if inst, err := x86.PBLENDW(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3357,7 +3357,7 @@ func PBLENDW(i, mx, x operand.Op) { ctx.PBLENDW(i, mx, x) }
 
 func (c *Context) PCLMULQDQ(i, mx, x operand.Op) {
 	if inst, err := x86.PCLMULQDQ(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3366,7 +3366,7 @@ func PCLMULQDQ(i, mx, x operand.Op) { ctx.PCLMULQDQ(i, mx, x) }
 
 func (c *Context) PCMPEQB(mx, x operand.Op) {
 	if inst, err := x86.PCMPEQB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3375,7 +3375,7 @@ func PCMPEQB(mx, x operand.Op) { ctx.PCMPEQB(mx, x) }
 
 func (c *Context) PCMPEQL(mx, x operand.Op) {
 	if inst, err := x86.PCMPEQL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3384,7 +3384,7 @@ func PCMPEQL(mx, x operand.Op) { ctx.PCMPEQL(mx, x) }
 
 func (c *Context) PCMPEQQ(mx, x operand.Op) {
 	if inst, err := x86.PCMPEQQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3393,7 +3393,7 @@ func PCMPEQQ(mx, x operand.Op) { ctx.PCMPEQQ(mx, x) }
 
 func (c *Context) PCMPEQW(mx, x operand.Op) {
 	if inst, err := x86.PCMPEQW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3402,7 +3402,7 @@ func PCMPEQW(mx, x operand.Op) { ctx.PCMPEQW(mx, x) }
 
 func (c *Context) PCMPESTRI(i, mx, x operand.Op) {
 	if inst, err := x86.PCMPESTRI(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3411,7 +3411,7 @@ func PCMPESTRI(i, mx, x operand.Op) { ctx.PCMPESTRI(i, mx, x) }
 
 func (c *Context) PCMPESTRM(i, mx, x operand.Op) {
 	if inst, err := x86.PCMPESTRM(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3420,7 +3420,7 @@ func PCMPESTRM(i, mx, x operand.Op) { ctx.PCMPESTRM(i, mx, x) }
 
 func (c *Context) PCMPGTB(mx, x operand.Op) {
 	if inst, err := x86.PCMPGTB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3429,7 +3429,7 @@ func PCMPGTB(mx, x operand.Op) { ctx.PCMPGTB(mx, x) }
 
 func (c *Context) PCMPGTL(mx, x operand.Op) {
 	if inst, err := x86.PCMPGTL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3438,7 +3438,7 @@ func PCMPGTL(mx, x operand.Op) { ctx.PCMPGTL(mx, x) }
 
 func (c *Context) PCMPGTQ(mx, x operand.Op) {
 	if inst, err := x86.PCMPGTQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3447,7 +3447,7 @@ func PCMPGTQ(mx, x operand.Op) { ctx.PCMPGTQ(mx, x) }
 
 func (c *Context) PCMPGTW(mx, x operand.Op) {
 	if inst, err := x86.PCMPGTW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3456,7 +3456,7 @@ func PCMPGTW(mx, x operand.Op) { ctx.PCMPGTW(mx, x) }
 
 func (c *Context) PCMPISTRI(i, mx, x operand.Op) {
 	if inst, err := x86.PCMPISTRI(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3465,7 +3465,7 @@ func PCMPISTRI(i, mx, x operand.Op) { ctx.PCMPISTRI(i, mx, x) }
 
 func (c *Context) PCMPISTRM(i, mx, x operand.Op) {
 	if inst, err := x86.PCMPISTRM(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3474,7 +3474,7 @@ func PCMPISTRM(i, mx, x operand.Op) { ctx.PCMPISTRM(i, mx, x) }
 
 func (c *Context) PDEPL(mr, r, r1 operand.Op) {
 	if inst, err := x86.PDEPL(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3483,7 +3483,7 @@ func PDEPL(mr, r, r1 operand.Op) { ctx.PDEPL(mr, r, r1) }
 
 func (c *Context) PDEPQ(mr, r, r1 operand.Op) {
 	if inst, err := x86.PDEPQ(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3492,7 +3492,7 @@ func PDEPQ(mr, r, r1 operand.Op) { ctx.PDEPQ(mr, r, r1) }
 
 func (c *Context) PEXTL(mr, r, r1 operand.Op) {
 	if inst, err := x86.PEXTL(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3501,7 +3501,7 @@ func PEXTL(mr, r, r1 operand.Op) { ctx.PEXTL(mr, r, r1) }
 
 func (c *Context) PEXTQ(mr, r, r1 operand.Op) {
 	if inst, err := x86.PEXTQ(mr, r, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3510,7 +3510,7 @@ func PEXTQ(mr, r, r1 operand.Op) { ctx.PEXTQ(mr, r, r1) }
 
 func (c *Context) PEXTRB(i, x, mr operand.Op) {
 	if inst, err := x86.PEXTRB(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3519,7 +3519,7 @@ func PEXTRB(i, x, mr operand.Op) { ctx.PEXTRB(i, x, mr) }
 
 func (c *Context) PEXTRD(i, x, mr operand.Op) {
 	if inst, err := x86.PEXTRD(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3528,7 +3528,7 @@ func PEXTRD(i, x, mr operand.Op) { ctx.PEXTRD(i, x, mr) }
 
 func (c *Context) PEXTRQ(i, x, mr operand.Op) {
 	if inst, err := x86.PEXTRQ(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3537,7 +3537,7 @@ func PEXTRQ(i, x, mr operand.Op) { ctx.PEXTRQ(i, x, mr) }
 
 func (c *Context) PEXTRW(i, x, mr operand.Op) {
 	if inst, err := x86.PEXTRW(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3546,7 +3546,7 @@ func PEXTRW(i, x, mr operand.Op) { ctx.PEXTRW(i, x, mr) }
 
 func (c *Context) PHADDD(mx, x operand.Op) {
 	if inst, err := x86.PHADDD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3555,7 +3555,7 @@ func PHADDD(mx, x operand.Op) { ctx.PHADDD(mx, x) }
 
 func (c *Context) PHADDSW(mx, x operand.Op) {
 	if inst, err := x86.PHADDSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3564,7 +3564,7 @@ func PHADDSW(mx, x operand.Op) { ctx.PHADDSW(mx, x) }
 
 func (c *Context) PHADDW(mx, x operand.Op) {
 	if inst, err := x86.PHADDW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3573,7 +3573,7 @@ func PHADDW(mx, x operand.Op) { ctx.PHADDW(mx, x) }
 
 func (c *Context) PHMINPOSUW(mx, x operand.Op) {
 	if inst, err := x86.PHMINPOSUW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3582,7 +3582,7 @@ func PHMINPOSUW(mx, x operand.Op) { ctx.PHMINPOSUW(mx, x) }
 
 func (c *Context) PHSUBD(mx, x operand.Op) {
 	if inst, err := x86.PHSUBD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3591,7 +3591,7 @@ func PHSUBD(mx, x operand.Op) { ctx.PHSUBD(mx, x) }
 
 func (c *Context) PHSUBSW(mx, x operand.Op) {
 	if inst, err := x86.PHSUBSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3600,7 +3600,7 @@ func PHSUBSW(mx, x operand.Op) { ctx.PHSUBSW(mx, x) }
 
 func (c *Context) PHSUBW(mx, x operand.Op) {
 	if inst, err := x86.PHSUBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3609,7 +3609,7 @@ func PHSUBW(mx, x operand.Op) { ctx.PHSUBW(mx, x) }
 
 func (c *Context) PINSRB(i, mr, x operand.Op) {
 	if inst, err := x86.PINSRB(i, mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3618,7 +3618,7 @@ func PINSRB(i, mr, x operand.Op) { ctx.PINSRB(i, mr, x) }
 
 func (c *Context) PINSRD(i, mr, x operand.Op) {
 	if inst, err := x86.PINSRD(i, mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3627,7 +3627,7 @@ func PINSRD(i, mr, x operand.Op) { ctx.PINSRD(i, mr, x) }
 
 func (c *Context) PINSRQ(i, mr, x operand.Op) {
 	if inst, err := x86.PINSRQ(i, mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3636,7 +3636,7 @@ func PINSRQ(i, mr, x operand.Op) { ctx.PINSRQ(i, mr, x) }
 
 func (c *Context) PINSRW(i, mr, x operand.Op) {
 	if inst, err := x86.PINSRW(i, mr, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3645,7 +3645,7 @@ func PINSRW(i, mr, x operand.Op) { ctx.PINSRW(i, mr, x) }
 
 func (c *Context) PMADDUBSW(mx, x operand.Op) {
 	if inst, err := x86.PMADDUBSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3654,7 +3654,7 @@ func PMADDUBSW(mx, x operand.Op) { ctx.PMADDUBSW(mx, x) }
 
 func (c *Context) PMADDWL(mx, x operand.Op) {
 	if inst, err := x86.PMADDWL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3663,7 +3663,7 @@ func PMADDWL(mx, x operand.Op) { ctx.PMADDWL(mx, x) }
 
 func (c *Context) PMAXSB(mx, x operand.Op) {
 	if inst, err := x86.PMAXSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3672,7 +3672,7 @@ func PMAXSB(mx, x operand.Op) { ctx.PMAXSB(mx, x) }
 
 func (c *Context) PMAXSD(mx, x operand.Op) {
 	if inst, err := x86.PMAXSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3681,7 +3681,7 @@ func PMAXSD(mx, x operand.Op) { ctx.PMAXSD(mx, x) }
 
 func (c *Context) PMAXSW(mx, x operand.Op) {
 	if inst, err := x86.PMAXSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3690,7 +3690,7 @@ func PMAXSW(mx, x operand.Op) { ctx.PMAXSW(mx, x) }
 
 func (c *Context) PMAXUB(mx, x operand.Op) {
 	if inst, err := x86.PMAXUB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3699,7 +3699,7 @@ func PMAXUB(mx, x operand.Op) { ctx.PMAXUB(mx, x) }
 
 func (c *Context) PMAXUD(mx, x operand.Op) {
 	if inst, err := x86.PMAXUD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3708,7 +3708,7 @@ func PMAXUD(mx, x operand.Op) { ctx.PMAXUD(mx, x) }
 
 func (c *Context) PMAXUW(mx, x operand.Op) {
 	if inst, err := x86.PMAXUW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3717,7 +3717,7 @@ func PMAXUW(mx, x operand.Op) { ctx.PMAXUW(mx, x) }
 
 func (c *Context) PMINSB(mx, x operand.Op) {
 	if inst, err := x86.PMINSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3726,7 +3726,7 @@ func PMINSB(mx, x operand.Op) { ctx.PMINSB(mx, x) }
 
 func (c *Context) PMINSD(mx, x operand.Op) {
 	if inst, err := x86.PMINSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3735,7 +3735,7 @@ func PMINSD(mx, x operand.Op) { ctx.PMINSD(mx, x) }
 
 func (c *Context) PMINSW(mx, x operand.Op) {
 	if inst, err := x86.PMINSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3744,7 +3744,7 @@ func PMINSW(mx, x operand.Op) { ctx.PMINSW(mx, x) }
 
 func (c *Context) PMINUB(mx, x operand.Op) {
 	if inst, err := x86.PMINUB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3753,7 +3753,7 @@ func PMINUB(mx, x operand.Op) { ctx.PMINUB(mx, x) }
 
 func (c *Context) PMINUD(mx, x operand.Op) {
 	if inst, err := x86.PMINUD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3762,7 +3762,7 @@ func PMINUD(mx, x operand.Op) { ctx.PMINUD(mx, x) }
 
 func (c *Context) PMINUW(mx, x operand.Op) {
 	if inst, err := x86.PMINUW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3771,7 +3771,7 @@ func PMINUW(mx, x operand.Op) { ctx.PMINUW(mx, x) }
 
 func (c *Context) PMOVMSKB(x, r operand.Op) {
 	if inst, err := x86.PMOVMSKB(x, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3780,7 +3780,7 @@ func PMOVMSKB(x, r operand.Op) { ctx.PMOVMSKB(x, r) }
 
 func (c *Context) PMOVSXBD(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXBD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3789,7 +3789,7 @@ func PMOVSXBD(mx, x operand.Op) { ctx.PMOVSXBD(mx, x) }
 
 func (c *Context) PMOVSXBQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXBQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3798,7 +3798,7 @@ func PMOVSXBQ(mx, x operand.Op) { ctx.PMOVSXBQ(mx, x) }
 
 func (c *Context) PMOVSXBW(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3807,7 +3807,7 @@ func PMOVSXBW(mx, x operand.Op) { ctx.PMOVSXBW(mx, x) }
 
 func (c *Context) PMOVSXDQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3816,7 +3816,7 @@ func PMOVSXDQ(mx, x operand.Op) { ctx.PMOVSXDQ(mx, x) }
 
 func (c *Context) PMOVSXWD(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXWD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3825,7 +3825,7 @@ func PMOVSXWD(mx, x operand.Op) { ctx.PMOVSXWD(mx, x) }
 
 func (c *Context) PMOVSXWQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVSXWQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3834,7 +3834,7 @@ func PMOVSXWQ(mx, x operand.Op) { ctx.PMOVSXWQ(mx, x) }
 
 func (c *Context) PMOVZXBD(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXBD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3843,7 +3843,7 @@ func PMOVZXBD(mx, x operand.Op) { ctx.PMOVZXBD(mx, x) }
 
 func (c *Context) PMOVZXBQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXBQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3852,7 +3852,7 @@ func PMOVZXBQ(mx, x operand.Op) { ctx.PMOVZXBQ(mx, x) }
 
 func (c *Context) PMOVZXBW(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3861,7 +3861,7 @@ func PMOVZXBW(mx, x operand.Op) { ctx.PMOVZXBW(mx, x) }
 
 func (c *Context) PMOVZXDQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3870,7 +3870,7 @@ func PMOVZXDQ(mx, x operand.Op) { ctx.PMOVZXDQ(mx, x) }
 
 func (c *Context) PMOVZXWD(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXWD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3879,7 +3879,7 @@ func PMOVZXWD(mx, x operand.Op) { ctx.PMOVZXWD(mx, x) }
 
 func (c *Context) PMOVZXWQ(mx, x operand.Op) {
 	if inst, err := x86.PMOVZXWQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3888,7 +3888,7 @@ func PMOVZXWQ(mx, x operand.Op) { ctx.PMOVZXWQ(mx, x) }
 
 func (c *Context) PMULDQ(mx, x operand.Op) {
 	if inst, err := x86.PMULDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3897,7 +3897,7 @@ func PMULDQ(mx, x operand.Op) { ctx.PMULDQ(mx, x) }
 
 func (c *Context) PMULHRSW(mx, x operand.Op) {
 	if inst, err := x86.PMULHRSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3906,7 +3906,7 @@ func PMULHRSW(mx, x operand.Op) { ctx.PMULHRSW(mx, x) }
 
 func (c *Context) PMULHUW(mx, x operand.Op) {
 	if inst, err := x86.PMULHUW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3915,7 +3915,7 @@ func PMULHUW(mx, x operand.Op) { ctx.PMULHUW(mx, x) }
 
 func (c *Context) PMULHW(mx, x operand.Op) {
 	if inst, err := x86.PMULHW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3924,7 +3924,7 @@ func PMULHW(mx, x operand.Op) { ctx.PMULHW(mx, x) }
 
 func (c *Context) PMULLD(mx, x operand.Op) {
 	if inst, err := x86.PMULLD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3933,7 +3933,7 @@ func PMULLD(mx, x operand.Op) { ctx.PMULLD(mx, x) }
 
 func (c *Context) PMULLW(mx, x operand.Op) {
 	if inst, err := x86.PMULLW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3942,7 +3942,7 @@ func PMULLW(mx, x operand.Op) { ctx.PMULLW(mx, x) }
 
 func (c *Context) PMULULQ(mx, x operand.Op) {
 	if inst, err := x86.PMULULQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3951,7 +3951,7 @@ func PMULULQ(mx, x operand.Op) { ctx.PMULULQ(mx, x) }
 
 func (c *Context) POPCNTL(mr, r operand.Op) {
 	if inst, err := x86.POPCNTL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3960,7 +3960,7 @@ func POPCNTL(mr, r operand.Op) { ctx.POPCNTL(mr, r) }
 
 func (c *Context) POPCNTQ(mr, r operand.Op) {
 	if inst, err := x86.POPCNTQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3969,7 +3969,7 @@ func POPCNTQ(mr, r operand.Op) { ctx.POPCNTQ(mr, r) }
 
 func (c *Context) POPCNTW(mr, r operand.Op) {
 	if inst, err := x86.POPCNTW(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3978,7 +3978,7 @@ func POPCNTW(mr, r operand.Op) { ctx.POPCNTW(mr, r) }
 
 func (c *Context) POPQ(mr operand.Op) {
 	if inst, err := x86.POPQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3987,7 +3987,7 @@ func POPQ(mr operand.Op) { ctx.POPQ(mr) }
 
 func (c *Context) POPW(mr operand.Op) {
 	if inst, err := x86.POPW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -3996,7 +3996,7 @@ func POPW(mr operand.Op) { ctx.POPW(mr) }
 
 func (c *Context) POR(mx, x operand.Op) {
 	if inst, err := x86.POR(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4005,7 +4005,7 @@ func POR(mx, x operand.Op) { ctx.POR(mx, x) }
 
 func (c *Context) PREFETCHNTA(m operand.Op) {
 	if inst, err := x86.PREFETCHNTA(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4014,7 +4014,7 @@ func PREFETCHNTA(m operand.Op) { ctx.PREFETCHNTA(m) }
 
 func (c *Context) PREFETCHT0(m operand.Op) {
 	if inst, err := x86.PREFETCHT0(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4023,7 +4023,7 @@ func PREFETCHT0(m operand.Op) { ctx.PREFETCHT0(m) }
 
 func (c *Context) PREFETCHT1(m operand.Op) {
 	if inst, err := x86.PREFETCHT1(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4032,7 +4032,7 @@ func PREFETCHT1(m operand.Op) { ctx.PREFETCHT1(m) }
 
 func (c *Context) PREFETCHT2(m operand.Op) {
 	if inst, err := x86.PREFETCHT2(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4041,7 +4041,7 @@ func PREFETCHT2(m operand.Op) { ctx.PREFETCHT2(m) }
 
 func (c *Context) PSADBW(mx, x operand.Op) {
 	if inst, err := x86.PSADBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4050,7 +4050,7 @@ func PSADBW(mx, x operand.Op) { ctx.PSADBW(mx, x) }
 
 func (c *Context) PSHUFB(mx, x operand.Op) {
 	if inst, err := x86.PSHUFB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4059,7 +4059,7 @@ func PSHUFB(mx, x operand.Op) { ctx.PSHUFB(mx, x) }
 
 func (c *Context) PSHUFD(i, mx, x operand.Op) {
 	if inst, err := x86.PSHUFD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4068,7 +4068,7 @@ func PSHUFD(i, mx, x operand.Op) { ctx.PSHUFD(i, mx, x) }
 
 func (c *Context) PSHUFHW(i, mx, x operand.Op) {
 	if inst, err := x86.PSHUFHW(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4077,7 +4077,7 @@ func PSHUFHW(i, mx, x operand.Op) { ctx.PSHUFHW(i, mx, x) }
 
 func (c *Context) PSHUFL(i, mx, x operand.Op) {
 	if inst, err := x86.PSHUFL(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4086,7 +4086,7 @@ func PSHUFL(i, mx, x operand.Op) { ctx.PSHUFL(i, mx, x) }
 
 func (c *Context) PSHUFLW(i, mx, x operand.Op) {
 	if inst, err := x86.PSHUFLW(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4095,7 +4095,7 @@ func PSHUFLW(i, mx, x operand.Op) { ctx.PSHUFLW(i, mx, x) }
 
 func (c *Context) PSIGNB(mx, x operand.Op) {
 	if inst, err := x86.PSIGNB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4104,7 +4104,7 @@ func PSIGNB(mx, x operand.Op) { ctx.PSIGNB(mx, x) }
 
 func (c *Context) PSIGND(mx, x operand.Op) {
 	if inst, err := x86.PSIGND(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4113,7 +4113,7 @@ func PSIGND(mx, x operand.Op) { ctx.PSIGND(mx, x) }
 
 func (c *Context) PSIGNW(mx, x operand.Op) {
 	if inst, err := x86.PSIGNW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4122,7 +4122,7 @@ func PSIGNW(mx, x operand.Op) { ctx.PSIGNW(mx, x) }
 
 func (c *Context) PSLLDQ(i, x operand.Op) {
 	if inst, err := x86.PSLLDQ(i, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4131,7 +4131,7 @@ func PSLLDQ(i, x operand.Op) { ctx.PSLLDQ(i, x) }
 
 func (c *Context) PSLLL(imx, x operand.Op) {
 	if inst, err := x86.PSLLL(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4140,7 +4140,7 @@ func PSLLL(imx, x operand.Op) { ctx.PSLLL(imx, x) }
 
 func (c *Context) PSLLO(i, x operand.Op) {
 	if inst, err := x86.PSLLO(i, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4149,7 +4149,7 @@ func PSLLO(i, x operand.Op) { ctx.PSLLO(i, x) }
 
 func (c *Context) PSLLQ(imx, x operand.Op) {
 	if inst, err := x86.PSLLQ(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4158,7 +4158,7 @@ func PSLLQ(imx, x operand.Op) { ctx.PSLLQ(imx, x) }
 
 func (c *Context) PSLLW(imx, x operand.Op) {
 	if inst, err := x86.PSLLW(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4167,7 +4167,7 @@ func PSLLW(imx, x operand.Op) { ctx.PSLLW(imx, x) }
 
 func (c *Context) PSRAL(imx, x operand.Op) {
 	if inst, err := x86.PSRAL(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4176,7 +4176,7 @@ func PSRAL(imx, x operand.Op) { ctx.PSRAL(imx, x) }
 
 func (c *Context) PSRAW(imx, x operand.Op) {
 	if inst, err := x86.PSRAW(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4185,7 +4185,7 @@ func PSRAW(imx, x operand.Op) { ctx.PSRAW(imx, x) }
 
 func (c *Context) PSRLDQ(i, x operand.Op) {
 	if inst, err := x86.PSRLDQ(i, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4194,7 +4194,7 @@ func PSRLDQ(i, x operand.Op) { ctx.PSRLDQ(i, x) }
 
 func (c *Context) PSRLL(imx, x operand.Op) {
 	if inst, err := x86.PSRLL(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4203,7 +4203,7 @@ func PSRLL(imx, x operand.Op) { ctx.PSRLL(imx, x) }
 
 func (c *Context) PSRLO(i, x operand.Op) {
 	if inst, err := x86.PSRLO(i, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4212,7 +4212,7 @@ func PSRLO(i, x operand.Op) { ctx.PSRLO(i, x) }
 
 func (c *Context) PSRLQ(imx, x operand.Op) {
 	if inst, err := x86.PSRLQ(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4221,7 +4221,7 @@ func PSRLQ(imx, x operand.Op) { ctx.PSRLQ(imx, x) }
 
 func (c *Context) PSRLW(imx, x operand.Op) {
 	if inst, err := x86.PSRLW(imx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4230,7 +4230,7 @@ func PSRLW(imx, x operand.Op) { ctx.PSRLW(imx, x) }
 
 func (c *Context) PSUBB(mx, x operand.Op) {
 	if inst, err := x86.PSUBB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4239,7 +4239,7 @@ func PSUBB(mx, x operand.Op) { ctx.PSUBB(mx, x) }
 
 func (c *Context) PSUBL(mx, x operand.Op) {
 	if inst, err := x86.PSUBL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4248,7 +4248,7 @@ func PSUBL(mx, x operand.Op) { ctx.PSUBL(mx, x) }
 
 func (c *Context) PSUBQ(mx, x operand.Op) {
 	if inst, err := x86.PSUBQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4257,7 +4257,7 @@ func PSUBQ(mx, x operand.Op) { ctx.PSUBQ(mx, x) }
 
 func (c *Context) PSUBSB(mx, x operand.Op) {
 	if inst, err := x86.PSUBSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4266,7 +4266,7 @@ func PSUBSB(mx, x operand.Op) { ctx.PSUBSB(mx, x) }
 
 func (c *Context) PSUBSW(mx, x operand.Op) {
 	if inst, err := x86.PSUBSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4275,7 +4275,7 @@ func PSUBSW(mx, x operand.Op) { ctx.PSUBSW(mx, x) }
 
 func (c *Context) PSUBUSB(mx, x operand.Op) {
 	if inst, err := x86.PSUBUSB(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4284,7 +4284,7 @@ func PSUBUSB(mx, x operand.Op) { ctx.PSUBUSB(mx, x) }
 
 func (c *Context) PSUBUSW(mx, x operand.Op) {
 	if inst, err := x86.PSUBUSW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4293,7 +4293,7 @@ func PSUBUSW(mx, x operand.Op) { ctx.PSUBUSW(mx, x) }
 
 func (c *Context) PSUBW(mx, x operand.Op) {
 	if inst, err := x86.PSUBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4302,7 +4302,7 @@ func PSUBW(mx, x operand.Op) { ctx.PSUBW(mx, x) }
 
 func (c *Context) PTEST(mx, x operand.Op) {
 	if inst, err := x86.PTEST(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4311,7 +4311,7 @@ func PTEST(mx, x operand.Op) { ctx.PTEST(mx, x) }
 
 func (c *Context) PUNPCKHBW(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKHBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4320,7 +4320,7 @@ func PUNPCKHBW(mx, x operand.Op) { ctx.PUNPCKHBW(mx, x) }
 
 func (c *Context) PUNPCKHLQ(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKHLQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4329,7 +4329,7 @@ func PUNPCKHLQ(mx, x operand.Op) { ctx.PUNPCKHLQ(mx, x) }
 
 func (c *Context) PUNPCKHQDQ(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKHQDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4338,7 +4338,7 @@ func PUNPCKHQDQ(mx, x operand.Op) { ctx.PUNPCKHQDQ(mx, x) }
 
 func (c *Context) PUNPCKHWL(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKHWL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4347,7 +4347,7 @@ func PUNPCKHWL(mx, x operand.Op) { ctx.PUNPCKHWL(mx, x) }
 
 func (c *Context) PUNPCKLBW(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKLBW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4356,7 +4356,7 @@ func PUNPCKLBW(mx, x operand.Op) { ctx.PUNPCKLBW(mx, x) }
 
 func (c *Context) PUNPCKLLQ(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKLLQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4365,7 +4365,7 @@ func PUNPCKLLQ(mx, x operand.Op) { ctx.PUNPCKLLQ(mx, x) }
 
 func (c *Context) PUNPCKLQDQ(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKLQDQ(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4374,7 +4374,7 @@ func PUNPCKLQDQ(mx, x operand.Op) { ctx.PUNPCKLQDQ(mx, x) }
 
 func (c *Context) PUNPCKLWL(mx, x operand.Op) {
 	if inst, err := x86.PUNPCKLWL(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4383,7 +4383,7 @@ func PUNPCKLWL(mx, x operand.Op) { ctx.PUNPCKLWL(mx, x) }
 
 func (c *Context) PUSHQ(imr operand.Op) {
 	if inst, err := x86.PUSHQ(imr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4392,7 +4392,7 @@ func PUSHQ(imr operand.Op) { ctx.PUSHQ(imr) }
 
 func (c *Context) PUSHW(mr operand.Op) {
 	if inst, err := x86.PUSHW(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4401,7 +4401,7 @@ func PUSHW(mr operand.Op) { ctx.PUSHW(mr) }
 
 func (c *Context) PXOR(mx, x operand.Op) {
 	if inst, err := x86.PXOR(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4410,7 +4410,7 @@ func PXOR(mx, x operand.Op) { ctx.PXOR(mx, x) }
 
 func (c *Context) RCLB(ci, mr operand.Op) {
 	if inst, err := x86.RCLB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4419,7 +4419,7 @@ func RCLB(ci, mr operand.Op) { ctx.RCLB(ci, mr) }
 
 func (c *Context) RCLL(ci, mr operand.Op) {
 	if inst, err := x86.RCLL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4428,7 +4428,7 @@ func RCLL(ci, mr operand.Op) { ctx.RCLL(ci, mr) }
 
 func (c *Context) RCLQ(ci, mr operand.Op) {
 	if inst, err := x86.RCLQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4437,7 +4437,7 @@ func RCLQ(ci, mr operand.Op) { ctx.RCLQ(ci, mr) }
 
 func (c *Context) RCLW(ci, mr operand.Op) {
 	if inst, err := x86.RCLW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4446,7 +4446,7 @@ func RCLW(ci, mr operand.Op) { ctx.RCLW(ci, mr) }
 
 func (c *Context) RCPPS(mx, x operand.Op) {
 	if inst, err := x86.RCPPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4455,7 +4455,7 @@ func RCPPS(mx, x operand.Op) { ctx.RCPPS(mx, x) }
 
 func (c *Context) RCPSS(mx, x operand.Op) {
 	if inst, err := x86.RCPSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4464,7 +4464,7 @@ func RCPSS(mx, x operand.Op) { ctx.RCPSS(mx, x) }
 
 func (c *Context) RCRB(ci, mr operand.Op) {
 	if inst, err := x86.RCRB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4473,7 +4473,7 @@ func RCRB(ci, mr operand.Op) { ctx.RCRB(ci, mr) }
 
 func (c *Context) RCRL(ci, mr operand.Op) {
 	if inst, err := x86.RCRL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4482,7 +4482,7 @@ func RCRL(ci, mr operand.Op) { ctx.RCRL(ci, mr) }
 
 func (c *Context) RCRQ(ci, mr operand.Op) {
 	if inst, err := x86.RCRQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4491,7 +4491,7 @@ func RCRQ(ci, mr operand.Op) { ctx.RCRQ(ci, mr) }
 
 func (c *Context) RCRW(ci, mr operand.Op) {
 	if inst, err := x86.RCRW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4500,7 +4500,7 @@ func RCRW(ci, mr operand.Op) { ctx.RCRW(ci, mr) }
 
 func (c *Context) RDRANDL(r operand.Op) {
 	if inst, err := x86.RDRANDL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4509,7 +4509,7 @@ func RDRANDL(r operand.Op) { ctx.RDRANDL(r) }
 
 func (c *Context) RDRANDQ(r operand.Op) {
 	if inst, err := x86.RDRANDQ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4518,7 +4518,7 @@ func RDRANDQ(r operand.Op) { ctx.RDRANDQ(r) }
 
 func (c *Context) RDRANDW(r operand.Op) {
 	if inst, err := x86.RDRANDW(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4527,7 +4527,7 @@ func RDRANDW(r operand.Op) { ctx.RDRANDW(r) }
 
 func (c *Context) RDSEEDL(r operand.Op) {
 	if inst, err := x86.RDSEEDL(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4536,7 +4536,7 @@ func RDSEEDL(r operand.Op) { ctx.RDSEEDL(r) }
 
 func (c *Context) RDSEEDQ(r operand.Op) {
 	if inst, err := x86.RDSEEDQ(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4545,7 +4545,7 @@ func RDSEEDQ(r operand.Op) { ctx.RDSEEDQ(r) }
 
 func (c *Context) RDSEEDW(r operand.Op) {
 	if inst, err := x86.RDSEEDW(r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4554,7 +4554,7 @@ func RDSEEDW(r operand.Op) { ctx.RDSEEDW(r) }
 
 func (c *Context) RDTSC() {
 	if inst, err := x86.RDTSC(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4563,7 +4563,7 @@ func RDTSC() { ctx.RDTSC() }
 
 func (c *Context) RDTSCP() {
 	if inst, err := x86.RDTSCP(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4572,7 +4572,7 @@ func RDTSCP() { ctx.RDTSCP() }
 
 func (c *Context) RET() {
 	if inst, err := x86.RET(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4581,7 +4581,7 @@ func RET() { ctx.RET() }
 
 func (c *Context) RETFL(i operand.Op) {
 	if inst, err := x86.RETFL(i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4590,7 +4590,7 @@ func RETFL(i operand.Op) { ctx.RETFL(i) }
 
 func (c *Context) RETFQ(i operand.Op) {
 	if inst, err := x86.RETFQ(i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4599,7 +4599,7 @@ func RETFQ(i operand.Op) { ctx.RETFQ(i) }
 
 func (c *Context) RETFW(i operand.Op) {
 	if inst, err := x86.RETFW(i); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4608,7 +4608,7 @@ func RETFW(i operand.Op) { ctx.RETFW(i) }
 
 func (c *Context) ROLB(ci, mr operand.Op) {
 	if inst, err := x86.ROLB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4617,7 +4617,7 @@ func ROLB(ci, mr operand.Op) { ctx.ROLB(ci, mr) }
 
 func (c *Context) ROLL(ci, mr operand.Op) {
 	if inst, err := x86.ROLL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4626,7 +4626,7 @@ func ROLL(ci, mr operand.Op) { ctx.ROLL(ci, mr) }
 
 func (c *Context) ROLQ(ci, mr operand.Op) {
 	if inst, err := x86.ROLQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4635,7 +4635,7 @@ func ROLQ(ci, mr operand.Op) { ctx.ROLQ(ci, mr) }
 
 func (c *Context) ROLW(ci, mr operand.Op) {
 	if inst, err := x86.ROLW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4644,7 +4644,7 @@ func ROLW(ci, mr operand.Op) { ctx.ROLW(ci, mr) }
 
 func (c *Context) RORB(ci, mr operand.Op) {
 	if inst, err := x86.RORB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4653,7 +4653,7 @@ func RORB(ci, mr operand.Op) { ctx.RORB(ci, mr) }
 
 func (c *Context) RORL(ci, mr operand.Op) {
 	if inst, err := x86.RORL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4662,7 +4662,7 @@ func RORL(ci, mr operand.Op) { ctx.RORL(ci, mr) }
 
 func (c *Context) RORQ(ci, mr operand.Op) {
 	if inst, err := x86.RORQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4671,7 +4671,7 @@ func RORQ(ci, mr operand.Op) { ctx.RORQ(ci, mr) }
 
 func (c *Context) RORW(ci, mr operand.Op) {
 	if inst, err := x86.RORW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4680,7 +4680,7 @@ func RORW(ci, mr operand.Op) { ctx.RORW(ci, mr) }
 
 func (c *Context) RORXL(i, mr, r operand.Op) {
 	if inst, err := x86.RORXL(i, mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4689,7 +4689,7 @@ func RORXL(i, mr, r operand.Op) { ctx.RORXL(i, mr, r) }
 
 func (c *Context) RORXQ(i, mr, r operand.Op) {
 	if inst, err := x86.RORXQ(i, mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4698,7 +4698,7 @@ func RORXQ(i, mr, r operand.Op) { ctx.RORXQ(i, mr, r) }
 
 func (c *Context) ROUNDPD(i, mx, x operand.Op) {
 	if inst, err := x86.ROUNDPD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4707,7 +4707,7 @@ func ROUNDPD(i, mx, x operand.Op) { ctx.ROUNDPD(i, mx, x) }
 
 func (c *Context) ROUNDPS(i, mx, x operand.Op) {
 	if inst, err := x86.ROUNDPS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4716,7 +4716,7 @@ func ROUNDPS(i, mx, x operand.Op) { ctx.ROUNDPS(i, mx, x) }
 
 func (c *Context) ROUNDSD(i, mx, x operand.Op) {
 	if inst, err := x86.ROUNDSD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4725,7 +4725,7 @@ func ROUNDSD(i, mx, x operand.Op) { ctx.ROUNDSD(i, mx, x) }
 
 func (c *Context) ROUNDSS(i, mx, x operand.Op) {
 	if inst, err := x86.ROUNDSS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4734,7 +4734,7 @@ func ROUNDSS(i, mx, x operand.Op) { ctx.ROUNDSS(i, mx, x) }
 
 func (c *Context) RSQRTPS(mx, x operand.Op) {
 	if inst, err := x86.RSQRTPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4743,7 +4743,7 @@ func RSQRTPS(mx, x operand.Op) { ctx.RSQRTPS(mx, x) }
 
 func (c *Context) RSQRTSS(mx, x operand.Op) {
 	if inst, err := x86.RSQRTSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4752,7 +4752,7 @@ func RSQRTSS(mx, x operand.Op) { ctx.RSQRTSS(mx, x) }
 
 func (c *Context) SALB(ci, mr operand.Op) {
 	if inst, err := x86.SALB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4761,7 +4761,7 @@ func SALB(ci, mr operand.Op) { ctx.SALB(ci, mr) }
 
 func (c *Context) SALL(ci, mr operand.Op) {
 	if inst, err := x86.SALL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4770,7 +4770,7 @@ func SALL(ci, mr operand.Op) { ctx.SALL(ci, mr) }
 
 func (c *Context) SALQ(ci, mr operand.Op) {
 	if inst, err := x86.SALQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4779,7 +4779,7 @@ func SALQ(ci, mr operand.Op) { ctx.SALQ(ci, mr) }
 
 func (c *Context) SALW(ci, mr operand.Op) {
 	if inst, err := x86.SALW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4788,7 +4788,7 @@ func SALW(ci, mr operand.Op) { ctx.SALW(ci, mr) }
 
 func (c *Context) SARB(ci, mr operand.Op) {
 	if inst, err := x86.SARB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4797,7 +4797,7 @@ func SARB(ci, mr operand.Op) { ctx.SARB(ci, mr) }
 
 func (c *Context) SARL(ci, mr operand.Op) {
 	if inst, err := x86.SARL(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4806,7 +4806,7 @@ func SARL(ci, mr operand.Op) { ctx.SARL(ci, mr) }
 
 func (c *Context) SARQ(ci, mr operand.Op) {
 	if inst, err := x86.SARQ(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4815,7 +4815,7 @@ func SARQ(ci, mr operand.Op) { ctx.SARQ(ci, mr) }
 
 func (c *Context) SARW(ci, mr operand.Op) {
 	if inst, err := x86.SARW(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4824,7 +4824,7 @@ func SARW(ci, mr operand.Op) { ctx.SARW(ci, mr) }
 
 func (c *Context) SARXL(r, mr, r1 operand.Op) {
 	if inst, err := x86.SARXL(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4833,7 +4833,7 @@ func SARXL(r, mr, r1 operand.Op) { ctx.SARXL(r, mr, r1) }
 
 func (c *Context) SARXQ(r, mr, r1 operand.Op) {
 	if inst, err := x86.SARXQ(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4842,7 +4842,7 @@ func SARXQ(r, mr, r1 operand.Op) { ctx.SARXQ(r, mr, r1) }
 
 func (c *Context) SBBB(imr, amr operand.Op) {
 	if inst, err := x86.SBBB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4851,7 +4851,7 @@ func SBBB(imr, amr operand.Op) { ctx.SBBB(imr, amr) }
 
 func (c *Context) SBBL(imr, emr operand.Op) {
 	if inst, err := x86.SBBL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4860,7 +4860,7 @@ func SBBL(imr, emr operand.Op) { ctx.SBBL(imr, emr) }
 
 func (c *Context) SBBQ(imr, mr operand.Op) {
 	if inst, err := x86.SBBQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4869,7 +4869,7 @@ func SBBQ(imr, mr operand.Op) { ctx.SBBQ(imr, mr) }
 
 func (c *Context) SBBW(imr, amr operand.Op) {
 	if inst, err := x86.SBBW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4878,7 +4878,7 @@ func SBBW(imr, amr operand.Op) { ctx.SBBW(imr, amr) }
 
 func (c *Context) SETCC(mr operand.Op) {
 	if inst, err := x86.SETCC(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4887,7 +4887,7 @@ func SETCC(mr operand.Op) { ctx.SETCC(mr) }
 
 func (c *Context) SETCS(mr operand.Op) {
 	if inst, err := x86.SETCS(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4896,7 +4896,7 @@ func SETCS(mr operand.Op) { ctx.SETCS(mr) }
 
 func (c *Context) SETEQ(mr operand.Op) {
 	if inst, err := x86.SETEQ(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4905,7 +4905,7 @@ func SETEQ(mr operand.Op) { ctx.SETEQ(mr) }
 
 func (c *Context) SETGE(mr operand.Op) {
 	if inst, err := x86.SETGE(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4914,7 +4914,7 @@ func SETGE(mr operand.Op) { ctx.SETGE(mr) }
 
 func (c *Context) SETGT(mr operand.Op) {
 	if inst, err := x86.SETGT(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4923,7 +4923,7 @@ func SETGT(mr operand.Op) { ctx.SETGT(mr) }
 
 func (c *Context) SETHI(mr operand.Op) {
 	if inst, err := x86.SETHI(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4932,7 +4932,7 @@ func SETHI(mr operand.Op) { ctx.SETHI(mr) }
 
 func (c *Context) SETLE(mr operand.Op) {
 	if inst, err := x86.SETLE(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4941,7 +4941,7 @@ func SETLE(mr operand.Op) { ctx.SETLE(mr) }
 
 func (c *Context) SETLS(mr operand.Op) {
 	if inst, err := x86.SETLS(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4950,7 +4950,7 @@ func SETLS(mr operand.Op) { ctx.SETLS(mr) }
 
 func (c *Context) SETLT(mr operand.Op) {
 	if inst, err := x86.SETLT(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4959,7 +4959,7 @@ func SETLT(mr operand.Op) { ctx.SETLT(mr) }
 
 func (c *Context) SETMI(mr operand.Op) {
 	if inst, err := x86.SETMI(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4968,7 +4968,7 @@ func SETMI(mr operand.Op) { ctx.SETMI(mr) }
 
 func (c *Context) SETNE(mr operand.Op) {
 	if inst, err := x86.SETNE(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4977,7 +4977,7 @@ func SETNE(mr operand.Op) { ctx.SETNE(mr) }
 
 func (c *Context) SETOC(mr operand.Op) {
 	if inst, err := x86.SETOC(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4986,7 +4986,7 @@ func SETOC(mr operand.Op) { ctx.SETOC(mr) }
 
 func (c *Context) SETOS(mr operand.Op) {
 	if inst, err := x86.SETOS(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -4995,7 +4995,7 @@ func SETOS(mr operand.Op) { ctx.SETOS(mr) }
 
 func (c *Context) SETPC(mr operand.Op) {
 	if inst, err := x86.SETPC(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5004,7 +5004,7 @@ func SETPC(mr operand.Op) { ctx.SETPC(mr) }
 
 func (c *Context) SETPL(mr operand.Op) {
 	if inst, err := x86.SETPL(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5013,7 +5013,7 @@ func SETPL(mr operand.Op) { ctx.SETPL(mr) }
 
 func (c *Context) SETPS(mr operand.Op) {
 	if inst, err := x86.SETPS(mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5022,7 +5022,7 @@ func SETPS(mr operand.Op) { ctx.SETPS(mr) }
 
 func (c *Context) SFENCE() {
 	if inst, err := x86.SFENCE(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5031,7 +5031,7 @@ func SFENCE() { ctx.SFENCE() }
 
 func (c *Context) SHA1MSG1(mx, x operand.Op) {
 	if inst, err := x86.SHA1MSG1(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5040,7 +5040,7 @@ func SHA1MSG1(mx, x operand.Op) { ctx.SHA1MSG1(mx, x) }
 
 func (c *Context) SHA1MSG2(mx, x operand.Op) {
 	if inst, err := x86.SHA1MSG2(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5049,7 +5049,7 @@ func SHA1MSG2(mx, x operand.Op) { ctx.SHA1MSG2(mx, x) }
 
 func (c *Context) SHA1NEXTE(mx, x operand.Op) {
 	if inst, err := x86.SHA1NEXTE(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5058,7 +5058,7 @@ func SHA1NEXTE(mx, x operand.Op) { ctx.SHA1NEXTE(mx, x) }
 
 func (c *Context) SHA1RNDS4(i, mx, x operand.Op) {
 	if inst, err := x86.SHA1RNDS4(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5067,7 +5067,7 @@ func SHA1RNDS4(i, mx, x operand.Op) { ctx.SHA1RNDS4(i, mx, x) }
 
 func (c *Context) SHA256MSG1(mx, x operand.Op) {
 	if inst, err := x86.SHA256MSG1(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5076,7 +5076,7 @@ func SHA256MSG1(mx, x operand.Op) { ctx.SHA256MSG1(mx, x) }
 
 func (c *Context) SHA256MSG2(mx, x operand.Op) {
 	if inst, err := x86.SHA256MSG2(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5085,7 +5085,7 @@ func SHA256MSG2(mx, x operand.Op) { ctx.SHA256MSG2(mx, x) }
 
 func (c *Context) SHA256RNDS2(x, mx, x1 operand.Op) {
 	if inst, err := x86.SHA256RNDS2(x, mx, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5094,7 +5094,7 @@ func SHA256RNDS2(x, mx, x1 operand.Op) { ctx.SHA256RNDS2(x, mx, x1) }
 
 func (c *Context) SHLB(ci, mr operand.Op) {
 	if inst, err := x86.SHLB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5103,7 +5103,7 @@ func SHLB(ci, mr operand.Op) { ctx.SHLB(ci, mr) }
 
 func (c *Context) SHLL(ops ...operand.Op) {
 	if inst, err := x86.SHLL(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5112,7 +5112,7 @@ func SHLL(ops ...operand.Op) { ctx.SHLL(ops...) }
 
 func (c *Context) SHLQ(ops ...operand.Op) {
 	if inst, err := x86.SHLQ(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5121,7 +5121,7 @@ func SHLQ(ops ...operand.Op) { ctx.SHLQ(ops...) }
 
 func (c *Context) SHLW(ops ...operand.Op) {
 	if inst, err := x86.SHLW(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5130,7 +5130,7 @@ func SHLW(ops ...operand.Op) { ctx.SHLW(ops...) }
 
 func (c *Context) SHLXL(r, mr, r1 operand.Op) {
 	if inst, err := x86.SHLXL(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5139,7 +5139,7 @@ func SHLXL(r, mr, r1 operand.Op) { ctx.SHLXL(r, mr, r1) }
 
 func (c *Context) SHLXQ(r, mr, r1 operand.Op) {
 	if inst, err := x86.SHLXQ(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5148,7 +5148,7 @@ func SHLXQ(r, mr, r1 operand.Op) { ctx.SHLXQ(r, mr, r1) }
 
 func (c *Context) SHRB(ci, mr operand.Op) {
 	if inst, err := x86.SHRB(ci, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5157,7 +5157,7 @@ func SHRB(ci, mr operand.Op) { ctx.SHRB(ci, mr) }
 
 func (c *Context) SHRL(ops ...operand.Op) {
 	if inst, err := x86.SHRL(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5166,7 +5166,7 @@ func SHRL(ops ...operand.Op) { ctx.SHRL(ops...) }
 
 func (c *Context) SHRQ(ops ...operand.Op) {
 	if inst, err := x86.SHRQ(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5175,7 +5175,7 @@ func SHRQ(ops ...operand.Op) { ctx.SHRQ(ops...) }
 
 func (c *Context) SHRW(ops ...operand.Op) {
 	if inst, err := x86.SHRW(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5184,7 +5184,7 @@ func SHRW(ops ...operand.Op) { ctx.SHRW(ops...) }
 
 func (c *Context) SHRXL(r, mr, r1 operand.Op) {
 	if inst, err := x86.SHRXL(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5193,7 +5193,7 @@ func SHRXL(r, mr, r1 operand.Op) { ctx.SHRXL(r, mr, r1) }
 
 func (c *Context) SHRXQ(r, mr, r1 operand.Op) {
 	if inst, err := x86.SHRXQ(r, mr, r1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5202,7 +5202,7 @@ func SHRXQ(r, mr, r1 operand.Op) { ctx.SHRXQ(r, mr, r1) }
 
 func (c *Context) SHUFPD(i, mx, x operand.Op) {
 	if inst, err := x86.SHUFPD(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5211,7 +5211,7 @@ func SHUFPD(i, mx, x operand.Op) { ctx.SHUFPD(i, mx, x) }
 
 func (c *Context) SHUFPS(i, mx, x operand.Op) {
 	if inst, err := x86.SHUFPS(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5220,7 +5220,7 @@ func SHUFPS(i, mx, x operand.Op) { ctx.SHUFPS(i, mx, x) }
 
 func (c *Context) SQRTPD(mx, x operand.Op) {
 	if inst, err := x86.SQRTPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5229,7 +5229,7 @@ func SQRTPD(mx, x operand.Op) { ctx.SQRTPD(mx, x) }
 
 func (c *Context) SQRTPS(mx, x operand.Op) {
 	if inst, err := x86.SQRTPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5238,7 +5238,7 @@ func SQRTPS(mx, x operand.Op) { ctx.SQRTPS(mx, x) }
 
 func (c *Context) SQRTSD(mx, x operand.Op) {
 	if inst, err := x86.SQRTSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5247,7 +5247,7 @@ func SQRTSD(mx, x operand.Op) { ctx.SQRTSD(mx, x) }
 
 func (c *Context) SQRTSS(mx, x operand.Op) {
 	if inst, err := x86.SQRTSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5256,7 +5256,7 @@ func SQRTSS(mx, x operand.Op) { ctx.SQRTSS(mx, x) }
 
 func (c *Context) STC() {
 	if inst, err := x86.STC(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5265,7 +5265,7 @@ func STC() { ctx.STC() }
 
 func (c *Context) STD() {
 	if inst, err := x86.STD(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5274,7 +5274,7 @@ func STD() { ctx.STD() }
 
 func (c *Context) STMXCSR(m operand.Op) {
 	if inst, err := x86.STMXCSR(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5283,7 +5283,7 @@ func STMXCSR(m operand.Op) { ctx.STMXCSR(m) }
 
 func (c *Context) SUBB(imr, amr operand.Op) {
 	if inst, err := x86.SUBB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5292,7 +5292,7 @@ func SUBB(imr, amr operand.Op) { ctx.SUBB(imr, amr) }
 
 func (c *Context) SUBL(imr, emr operand.Op) {
 	if inst, err := x86.SUBL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5301,7 +5301,7 @@ func SUBL(imr, emr operand.Op) { ctx.SUBL(imr, emr) }
 
 func (c *Context) SUBPD(mx, x operand.Op) {
 	if inst, err := x86.SUBPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5310,7 +5310,7 @@ func SUBPD(mx, x operand.Op) { ctx.SUBPD(mx, x) }
 
 func (c *Context) SUBPS(mx, x operand.Op) {
 	if inst, err := x86.SUBPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5319,7 +5319,7 @@ func SUBPS(mx, x operand.Op) { ctx.SUBPS(mx, x) }
 
 func (c *Context) SUBQ(imr, mr operand.Op) {
 	if inst, err := x86.SUBQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5328,7 +5328,7 @@ func SUBQ(imr, mr operand.Op) { ctx.SUBQ(imr, mr) }
 
 func (c *Context) SUBSD(mx, x operand.Op) {
 	if inst, err := x86.SUBSD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5337,7 +5337,7 @@ func SUBSD(mx, x operand.Op) { ctx.SUBSD(mx, x) }
 
 func (c *Context) SUBSS(mx, x operand.Op) {
 	if inst, err := x86.SUBSS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5346,7 +5346,7 @@ func SUBSS(mx, x operand.Op) { ctx.SUBSS(mx, x) }
 
 func (c *Context) SUBW(imr, amr operand.Op) {
 	if inst, err := x86.SUBW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5355,7 +5355,7 @@ func SUBW(imr, amr operand.Op) { ctx.SUBW(imr, amr) }
 
 func (c *Context) SYSCALL() {
 	if inst, err := x86.SYSCALL(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5364,7 +5364,7 @@ func SYSCALL() { ctx.SYSCALL() }
 
 func (c *Context) TESTB(ir, amr operand.Op) {
 	if inst, err := x86.TESTB(ir, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5373,7 +5373,7 @@ func TESTB(ir, amr operand.Op) { ctx.TESTB(ir, amr) }
 
 func (c *Context) TESTL(ir, emr operand.Op) {
 	if inst, err := x86.TESTL(ir, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5382,7 +5382,7 @@ func TESTL(ir, emr operand.Op) { ctx.TESTL(ir, emr) }
 
 func (c *Context) TESTQ(ir, mr operand.Op) {
 	if inst, err := x86.TESTQ(ir, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5391,7 +5391,7 @@ func TESTQ(ir, mr operand.Op) { ctx.TESTQ(ir, mr) }
 
 func (c *Context) TESTW(ir, amr operand.Op) {
 	if inst, err := x86.TESTW(ir, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5400,7 +5400,7 @@ func TESTW(ir, amr operand.Op) { ctx.TESTW(ir, amr) }
 
 func (c *Context) TZCNTL(mr, r operand.Op) {
 	if inst, err := x86.TZCNTL(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5409,7 +5409,7 @@ func TZCNTL(mr, r operand.Op) { ctx.TZCNTL(mr, r) }
 
 func (c *Context) TZCNTQ(mr, r operand.Op) {
 	if inst, err := x86.TZCNTQ(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5418,7 +5418,7 @@ func TZCNTQ(mr, r operand.Op) { ctx.TZCNTQ(mr, r) }
 
 func (c *Context) TZCNTW(mr, r operand.Op) {
 	if inst, err := x86.TZCNTW(mr, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5427,7 +5427,7 @@ func TZCNTW(mr, r operand.Op) { ctx.TZCNTW(mr, r) }
 
 func (c *Context) UCOMISD(mx, x operand.Op) {
 	if inst, err := x86.UCOMISD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5436,7 +5436,7 @@ func UCOMISD(mx, x operand.Op) { ctx.UCOMISD(mx, x) }
 
 func (c *Context) UCOMISS(mx, x operand.Op) {
 	if inst, err := x86.UCOMISS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5445,7 +5445,7 @@ func UCOMISS(mx, x operand.Op) { ctx.UCOMISS(mx, x) }
 
 func (c *Context) UD2() {
 	if inst, err := x86.UD2(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5454,7 +5454,7 @@ func UD2() { ctx.UD2() }
 
 func (c *Context) UNPCKHPD(mx, x operand.Op) {
 	if inst, err := x86.UNPCKHPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5463,7 +5463,7 @@ func UNPCKHPD(mx, x operand.Op) { ctx.UNPCKHPD(mx, x) }
 
 func (c *Context) UNPCKHPS(mx, x operand.Op) {
 	if inst, err := x86.UNPCKHPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5472,7 +5472,7 @@ func UNPCKHPS(mx, x operand.Op) { ctx.UNPCKHPS(mx, x) }
 
 func (c *Context) UNPCKLPD(mx, x operand.Op) {
 	if inst, err := x86.UNPCKLPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5481,7 +5481,7 @@ func UNPCKLPD(mx, x operand.Op) { ctx.UNPCKLPD(mx, x) }
 
 func (c *Context) UNPCKLPS(mx, x operand.Op) {
 	if inst, err := x86.UNPCKLPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5490,7 +5490,7 @@ func UNPCKLPS(mx, x operand.Op) { ctx.UNPCKLPS(mx, x) }
 
 func (c *Context) VADDPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VADDPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5499,7 +5499,7 @@ func VADDPD(mxy, xy, xy1 operand.Op) { ctx.VADDPD(mxy, xy, xy1) }
 
 func (c *Context) VADDPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VADDPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5508,7 +5508,7 @@ func VADDPS(mxy, xy, xy1 operand.Op) { ctx.VADDPS(mxy, xy, xy1) }
 
 func (c *Context) VADDSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VADDSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5517,7 +5517,7 @@ func VADDSD(mx, x, x1 operand.Op) { ctx.VADDSD(mx, x, x1) }
 
 func (c *Context) VADDSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VADDSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5526,7 +5526,7 @@ func VADDSS(mx, x, x1 operand.Op) { ctx.VADDSS(mx, x, x1) }
 
 func (c *Context) VADDSUBPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VADDSUBPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5535,7 +5535,7 @@ func VADDSUBPD(mxy, xy, xy1 operand.Op) { ctx.VADDSUBPD(mxy, xy, xy1) }
 
 func (c *Context) VADDSUBPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VADDSUBPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5544,7 +5544,7 @@ func VADDSUBPS(mxy, xy, xy1 operand.Op) { ctx.VADDSUBPS(mxy, xy, xy1) }
 
 func (c *Context) VAESDEC(mx, x, x1 operand.Op) {
 	if inst, err := x86.VAESDEC(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5553,7 +5553,7 @@ func VAESDEC(mx, x, x1 operand.Op) { ctx.VAESDEC(mx, x, x1) }
 
 func (c *Context) VAESDECLAST(mx, x, x1 operand.Op) {
 	if inst, err := x86.VAESDECLAST(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5562,7 +5562,7 @@ func VAESDECLAST(mx, x, x1 operand.Op) { ctx.VAESDECLAST(mx, x, x1) }
 
 func (c *Context) VAESENC(mx, x, x1 operand.Op) {
 	if inst, err := x86.VAESENC(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5571,7 +5571,7 @@ func VAESENC(mx, x, x1 operand.Op) { ctx.VAESENC(mx, x, x1) }
 
 func (c *Context) VAESENCLAST(mx, x, x1 operand.Op) {
 	if inst, err := x86.VAESENCLAST(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5580,7 +5580,7 @@ func VAESENCLAST(mx, x, x1 operand.Op) { ctx.VAESENCLAST(mx, x, x1) }
 
 func (c *Context) VAESIMC(mx, x operand.Op) {
 	if inst, err := x86.VAESIMC(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5589,7 +5589,7 @@ func VAESIMC(mx, x operand.Op) { ctx.VAESIMC(mx, x) }
 
 func (c *Context) VAESKEYGENASSIST(i, mx, x operand.Op) {
 	if inst, err := x86.VAESKEYGENASSIST(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5598,7 +5598,7 @@ func VAESKEYGENASSIST(i, mx, x operand.Op) { ctx.VAESKEYGENASSIST(i, mx, x) }
 
 func (c *Context) VANDNPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VANDNPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5607,7 +5607,7 @@ func VANDNPD(mxy, xy, xy1 operand.Op) { ctx.VANDNPD(mxy, xy, xy1) }
 
 func (c *Context) VANDNPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VANDNPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5616,7 +5616,7 @@ func VANDNPS(mxy, xy, xy1 operand.Op) { ctx.VANDNPS(mxy, xy, xy1) }
 
 func (c *Context) VANDPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VANDPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5625,7 +5625,7 @@ func VANDPD(mxy, xy, xy1 operand.Op) { ctx.VANDPD(mxy, xy, xy1) }
 
 func (c *Context) VANDPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VANDPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5634,7 +5634,7 @@ func VANDPS(mxy, xy, xy1 operand.Op) { ctx.VANDPS(mxy, xy, xy1) }
 
 func (c *Context) VBLENDPD(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VBLENDPD(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5643,7 +5643,7 @@ func VBLENDPD(i, mxy, xy, xy1 operand.Op) { ctx.VBLENDPD(i, mxy, xy, xy1) }
 
 func (c *Context) VBLENDPS(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VBLENDPS(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5652,7 +5652,7 @@ func VBLENDPS(i, mxy, xy, xy1 operand.Op) { ctx.VBLENDPS(i, mxy, xy, xy1) }
 
 func (c *Context) VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) {
 	if inst, err := x86.VBLENDVPD(xy, mxy, xy1, xy2); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5661,7 +5661,7 @@ func VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) { ctx.VBLENDVPD(xy, mxy, xy1, xy2)
 
 func (c *Context) VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) {
 	if inst, err := x86.VBLENDVPS(xy, mxy, xy1, xy2); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5670,7 +5670,7 @@ func VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) { ctx.VBLENDVPS(xy, mxy, xy1, xy2)
 
 func (c *Context) VBROADCASTF128(m, y operand.Op) {
 	if inst, err := x86.VBROADCASTF128(m, y); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5679,7 +5679,7 @@ func VBROADCASTF128(m, y operand.Op) { ctx.VBROADCASTF128(m, y) }
 
 func (c *Context) VBROADCASTI128(m, y operand.Op) {
 	if inst, err := x86.VBROADCASTI128(m, y); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5688,7 +5688,7 @@ func VBROADCASTI128(m, y operand.Op) { ctx.VBROADCASTI128(m, y) }
 
 func (c *Context) VBROADCASTSD(mx, y operand.Op) {
 	if inst, err := x86.VBROADCASTSD(mx, y); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5697,7 +5697,7 @@ func VBROADCASTSD(mx, y operand.Op) { ctx.VBROADCASTSD(mx, y) }
 
 func (c *Context) VBROADCASTSS(mx, xy operand.Op) {
 	if inst, err := x86.VBROADCASTSS(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5706,7 +5706,7 @@ func VBROADCASTSS(mx, xy operand.Op) { ctx.VBROADCASTSS(mx, xy) }
 
 func (c *Context) VCMPPD(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VCMPPD(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5715,7 +5715,7 @@ func VCMPPD(i, mxy, xy, xy1 operand.Op) { ctx.VCMPPD(i, mxy, xy, xy1) }
 
 func (c *Context) VCMPPS(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VCMPPS(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5724,7 +5724,7 @@ func VCMPPS(i, mxy, xy, xy1 operand.Op) { ctx.VCMPPS(i, mxy, xy, xy1) }
 
 func (c *Context) VCMPSD(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VCMPSD(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5733,7 +5733,7 @@ func VCMPSD(i, mx, x, x1 operand.Op) { ctx.VCMPSD(i, mx, x, x1) }
 
 func (c *Context) VCMPSS(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VCMPSS(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5742,7 +5742,7 @@ func VCMPSS(i, mx, x, x1 operand.Op) { ctx.VCMPSS(i, mx, x, x1) }
 
 func (c *Context) VCOMISD(mx, x operand.Op) {
 	if inst, err := x86.VCOMISD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5751,7 +5751,7 @@ func VCOMISD(mx, x operand.Op) { ctx.VCOMISD(mx, x) }
 
 func (c *Context) VCOMISS(mx, x operand.Op) {
 	if inst, err := x86.VCOMISS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5760,7 +5760,7 @@ func VCOMISS(mx, x operand.Op) { ctx.VCOMISS(mx, x) }
 
 func (c *Context) VCVTDQ2PD(mx, xy operand.Op) {
 	if inst, err := x86.VCVTDQ2PD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5769,7 +5769,7 @@ func VCVTDQ2PD(mx, xy operand.Op) { ctx.VCVTDQ2PD(mx, xy) }
 
 func (c *Context) VCVTDQ2PS(mxy, xy operand.Op) {
 	if inst, err := x86.VCVTDQ2PS(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5778,7 +5778,7 @@ func VCVTDQ2PS(mxy, xy operand.Op) { ctx.VCVTDQ2PS(mxy, xy) }
 
 func (c *Context) VCVTPD2DQX(mx, x operand.Op) {
 	if inst, err := x86.VCVTPD2DQX(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5787,7 +5787,7 @@ func VCVTPD2DQX(mx, x operand.Op) { ctx.VCVTPD2DQX(mx, x) }
 
 func (c *Context) VCVTPD2DQY(my, x operand.Op) {
 	if inst, err := x86.VCVTPD2DQY(my, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5796,7 +5796,7 @@ func VCVTPD2DQY(my, x operand.Op) { ctx.VCVTPD2DQY(my, x) }
 
 func (c *Context) VCVTPD2PSX(mx, x operand.Op) {
 	if inst, err := x86.VCVTPD2PSX(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5805,7 +5805,7 @@ func VCVTPD2PSX(mx, x operand.Op) { ctx.VCVTPD2PSX(mx, x) }
 
 func (c *Context) VCVTPD2PSY(my, x operand.Op) {
 	if inst, err := x86.VCVTPD2PSY(my, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5814,7 +5814,7 @@ func VCVTPD2PSY(my, x operand.Op) { ctx.VCVTPD2PSY(my, x) }
 
 func (c *Context) VCVTPH2PS(mx, xy operand.Op) {
 	if inst, err := x86.VCVTPH2PS(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5823,7 +5823,7 @@ func VCVTPH2PS(mx, xy operand.Op) { ctx.VCVTPH2PS(mx, xy) }
 
 func (c *Context) VCVTPS2DQ(mxy, xy operand.Op) {
 	if inst, err := x86.VCVTPS2DQ(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5832,7 +5832,7 @@ func VCVTPS2DQ(mxy, xy operand.Op) { ctx.VCVTPS2DQ(mxy, xy) }
 
 func (c *Context) VCVTPS2PD(mx, xy operand.Op) {
 	if inst, err := x86.VCVTPS2PD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5841,7 +5841,7 @@ func VCVTPS2PD(mx, xy operand.Op) { ctx.VCVTPS2PD(mx, xy) }
 
 func (c *Context) VCVTPS2PH(i, xy, mx operand.Op) {
 	if inst, err := x86.VCVTPS2PH(i, xy, mx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5850,7 +5850,7 @@ func VCVTPS2PH(i, xy, mx operand.Op) { ctx.VCVTPS2PH(i, xy, mx) }
 
 func (c *Context) VCVTSD2SI(mx, r operand.Op) {
 	if inst, err := x86.VCVTSD2SI(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5859,7 +5859,7 @@ func VCVTSD2SI(mx, r operand.Op) { ctx.VCVTSD2SI(mx, r) }
 
 func (c *Context) VCVTSD2SIQ(mx, r operand.Op) {
 	if inst, err := x86.VCVTSD2SIQ(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5868,7 +5868,7 @@ func VCVTSD2SIQ(mx, r operand.Op) { ctx.VCVTSD2SIQ(mx, r) }
 
 func (c *Context) VCVTSD2SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSD2SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5877,7 +5877,7 @@ func VCVTSD2SS(mx, x, x1 operand.Op) { ctx.VCVTSD2SS(mx, x, x1) }
 
 func (c *Context) VCVTSI2SDL(mr, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSI2SDL(mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5886,7 +5886,7 @@ func VCVTSI2SDL(mr, x, x1 operand.Op) { ctx.VCVTSI2SDL(mr, x, x1) }
 
 func (c *Context) VCVTSI2SDQ(mr, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSI2SDQ(mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5895,7 +5895,7 @@ func VCVTSI2SDQ(mr, x, x1 operand.Op) { ctx.VCVTSI2SDQ(mr, x, x1) }
 
 func (c *Context) VCVTSI2SSL(mr, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSI2SSL(mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5904,7 +5904,7 @@ func VCVTSI2SSL(mr, x, x1 operand.Op) { ctx.VCVTSI2SSL(mr, x, x1) }
 
 func (c *Context) VCVTSI2SSQ(mr, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSI2SSQ(mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5913,7 +5913,7 @@ func VCVTSI2SSQ(mr, x, x1 operand.Op) { ctx.VCVTSI2SSQ(mr, x, x1) }
 
 func (c *Context) VCVTSS2SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VCVTSS2SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5922,7 +5922,7 @@ func VCVTSS2SD(mx, x, x1 operand.Op) { ctx.VCVTSS2SD(mx, x, x1) }
 
 func (c *Context) VCVTSS2SI(mx, r operand.Op) {
 	if inst, err := x86.VCVTSS2SI(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5931,7 +5931,7 @@ func VCVTSS2SI(mx, r operand.Op) { ctx.VCVTSS2SI(mx, r) }
 
 func (c *Context) VCVTSS2SIQ(mx, r operand.Op) {
 	if inst, err := x86.VCVTSS2SIQ(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5940,7 +5940,7 @@ func VCVTSS2SIQ(mx, r operand.Op) { ctx.VCVTSS2SIQ(mx, r) }
 
 func (c *Context) VCVTTPD2DQX(mx, x operand.Op) {
 	if inst, err := x86.VCVTTPD2DQX(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5949,7 +5949,7 @@ func VCVTTPD2DQX(mx, x operand.Op) { ctx.VCVTTPD2DQX(mx, x) }
 
 func (c *Context) VCVTTPD2DQY(my, x operand.Op) {
 	if inst, err := x86.VCVTTPD2DQY(my, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5958,7 +5958,7 @@ func VCVTTPD2DQY(my, x operand.Op) { ctx.VCVTTPD2DQY(my, x) }
 
 func (c *Context) VCVTTPS2DQ(mxy, xy operand.Op) {
 	if inst, err := x86.VCVTTPS2DQ(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5967,7 +5967,7 @@ func VCVTTPS2DQ(mxy, xy operand.Op) { ctx.VCVTTPS2DQ(mxy, xy) }
 
 func (c *Context) VCVTTSD2SI(mx, r operand.Op) {
 	if inst, err := x86.VCVTTSD2SI(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5976,7 +5976,7 @@ func VCVTTSD2SI(mx, r operand.Op) { ctx.VCVTTSD2SI(mx, r) }
 
 func (c *Context) VCVTTSD2SIQ(mx, r operand.Op) {
 	if inst, err := x86.VCVTTSD2SIQ(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5985,7 +5985,7 @@ func VCVTTSD2SIQ(mx, r operand.Op) { ctx.VCVTTSD2SIQ(mx, r) }
 
 func (c *Context) VCVTTSS2SI(mx, r operand.Op) {
 	if inst, err := x86.VCVTTSS2SI(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -5994,7 +5994,7 @@ func VCVTTSS2SI(mx, r operand.Op) { ctx.VCVTTSS2SI(mx, r) }
 
 func (c *Context) VCVTTSS2SIQ(mx, r operand.Op) {
 	if inst, err := x86.VCVTTSS2SIQ(mx, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6003,7 +6003,7 @@ func VCVTTSS2SIQ(mx, r operand.Op) { ctx.VCVTTSS2SIQ(mx, r) }
 
 func (c *Context) VDIVPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VDIVPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6012,7 +6012,7 @@ func VDIVPD(mxy, xy, xy1 operand.Op) { ctx.VDIVPD(mxy, xy, xy1) }
 
 func (c *Context) VDIVPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VDIVPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6021,7 +6021,7 @@ func VDIVPS(mxy, xy, xy1 operand.Op) { ctx.VDIVPS(mxy, xy, xy1) }
 
 func (c *Context) VDIVSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VDIVSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6030,7 +6030,7 @@ func VDIVSD(mx, x, x1 operand.Op) { ctx.VDIVSD(mx, x, x1) }
 
 func (c *Context) VDIVSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VDIVSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6039,7 +6039,7 @@ func VDIVSS(mx, x, x1 operand.Op) { ctx.VDIVSS(mx, x, x1) }
 
 func (c *Context) VDPPD(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VDPPD(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6048,7 +6048,7 @@ func VDPPD(i, mx, x, x1 operand.Op) { ctx.VDPPD(i, mx, x, x1) }
 
 func (c *Context) VDPPS(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VDPPS(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6057,7 +6057,7 @@ func VDPPS(i, mxy, xy, xy1 operand.Op) { ctx.VDPPS(i, mxy, xy, xy1) }
 
 func (c *Context) VEXTRACTF128(i, y, mx operand.Op) {
 	if inst, err := x86.VEXTRACTF128(i, y, mx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6066,7 +6066,7 @@ func VEXTRACTF128(i, y, mx operand.Op) { ctx.VEXTRACTF128(i, y, mx) }
 
 func (c *Context) VEXTRACTI128(i, y, mx operand.Op) {
 	if inst, err := x86.VEXTRACTI128(i, y, mx); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6075,7 +6075,7 @@ func VEXTRACTI128(i, y, mx operand.Op) { ctx.VEXTRACTI128(i, y, mx) }
 
 func (c *Context) VEXTRACTPS(i, x, mr operand.Op) {
 	if inst, err := x86.VEXTRACTPS(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6084,7 +6084,7 @@ func VEXTRACTPS(i, x, mr operand.Op) { ctx.VEXTRACTPS(i, x, mr) }
 
 func (c *Context) VFMADD132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6093,7 +6093,7 @@ func VFMADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD132PD(mxy, xy, xy1) }
 
 func (c *Context) VFMADD132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6102,7 +6102,7 @@ func VFMADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD132PS(mxy, xy, xy1) }
 
 func (c *Context) VFMADD132SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD132SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6111,7 +6111,7 @@ func VFMADD132SD(mx, x, x1 operand.Op) { ctx.VFMADD132SD(mx, x, x1) }
 
 func (c *Context) VFMADD132SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD132SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6120,7 +6120,7 @@ func VFMADD132SS(mx, x, x1 operand.Op) { ctx.VFMADD132SS(mx, x, x1) }
 
 func (c *Context) VFMADD213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6129,7 +6129,7 @@ func VFMADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD213PD(mxy, xy, xy1) }
 
 func (c *Context) VFMADD213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6138,7 +6138,7 @@ func VFMADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD213PS(mxy, xy, xy1) }
 
 func (c *Context) VFMADD213SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD213SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6147,7 +6147,7 @@ func VFMADD213SD(mx, x, x1 operand.Op) { ctx.VFMADD213SD(mx, x, x1) }
 
 func (c *Context) VFMADD213SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD213SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6156,7 +6156,7 @@ func VFMADD213SS(mx, x, x1 operand.Op) { ctx.VFMADD213SS(mx, x, x1) }
 
 func (c *Context) VFMADD231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6165,7 +6165,7 @@ func VFMADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD231PD(mxy, xy, xy1) }
 
 func (c *Context) VFMADD231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADD231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6174,7 +6174,7 @@ func VFMADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD231PS(mxy, xy, xy1) }
 
 func (c *Context) VFMADD231SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD231SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6183,7 +6183,7 @@ func VFMADD231SD(mx, x, x1 operand.Op) { ctx.VFMADD231SD(mx, x, x1) }
 
 func (c *Context) VFMADD231SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMADD231SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6192,7 +6192,7 @@ func VFMADD231SS(mx, x, x1 operand.Op) { ctx.VFMADD231SS(mx, x, x1) }
 
 func (c *Context) VFMADDSUB132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6201,7 +6201,7 @@ func VFMADDSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB132PD(mxy, xy, xy1)
 
 func (c *Context) VFMADDSUB132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6210,7 +6210,7 @@ func VFMADDSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB132PS(mxy, xy, xy1)
 
 func (c *Context) VFMADDSUB213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6219,7 +6219,7 @@ func VFMADDSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB213PD(mxy, xy, xy1)
 
 func (c *Context) VFMADDSUB213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6228,7 +6228,7 @@ func VFMADDSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB213PS(mxy, xy, xy1)
 
 func (c *Context) VFMADDSUB231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6237,7 +6237,7 @@ func VFMADDSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB231PD(mxy, xy, xy1)
 
 func (c *Context) VFMADDSUB231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMADDSUB231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6246,7 +6246,7 @@ func VFMADDSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB231PS(mxy, xy, xy1)
 
 func (c *Context) VFMSUB132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6255,7 +6255,7 @@ func VFMSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB132PD(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6264,7 +6264,7 @@ func VFMSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB132PS(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB132SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB132SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6273,7 +6273,7 @@ func VFMSUB132SD(mx, x, x1 operand.Op) { ctx.VFMSUB132SD(mx, x, x1) }
 
 func (c *Context) VFMSUB132SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB132SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6282,7 +6282,7 @@ func VFMSUB132SS(mx, x, x1 operand.Op) { ctx.VFMSUB132SS(mx, x, x1) }
 
 func (c *Context) VFMSUB213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6291,7 +6291,7 @@ func VFMSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB213PD(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6300,7 +6300,7 @@ func VFMSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB213PS(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB213SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB213SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6309,7 +6309,7 @@ func VFMSUB213SD(mx, x, x1 operand.Op) { ctx.VFMSUB213SD(mx, x, x1) }
 
 func (c *Context) VFMSUB213SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB213SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6318,7 +6318,7 @@ func VFMSUB213SS(mx, x, x1 operand.Op) { ctx.VFMSUB213SS(mx, x, x1) }
 
 func (c *Context) VFMSUB231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6327,7 +6327,7 @@ func VFMSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB231PD(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUB231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6336,7 +6336,7 @@ func VFMSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB231PS(mxy, xy, xy1) }
 
 func (c *Context) VFMSUB231SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB231SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6345,7 +6345,7 @@ func VFMSUB231SD(mx, x, x1 operand.Op) { ctx.VFMSUB231SD(mx, x, x1) }
 
 func (c *Context) VFMSUB231SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFMSUB231SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6354,7 +6354,7 @@ func VFMSUB231SS(mx, x, x1 operand.Op) { ctx.VFMSUB231SS(mx, x, x1) }
 
 func (c *Context) VFMSUBADD132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6363,7 +6363,7 @@ func VFMSUBADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD132PD(mxy, xy, xy1)
 
 func (c *Context) VFMSUBADD132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6372,7 +6372,7 @@ func VFMSUBADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD132PS(mxy, xy, xy1)
 
 func (c *Context) VFMSUBADD213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6381,7 +6381,7 @@ func VFMSUBADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD213PD(mxy, xy, xy1)
 
 func (c *Context) VFMSUBADD213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6390,7 +6390,7 @@ func VFMSUBADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD213PS(mxy, xy, xy1)
 
 func (c *Context) VFMSUBADD231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6399,7 +6399,7 @@ func VFMSUBADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD231PD(mxy, xy, xy1)
 
 func (c *Context) VFMSUBADD231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFMSUBADD231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6408,7 +6408,7 @@ func VFMSUBADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD231PS(mxy, xy, xy1)
 
 func (c *Context) VFNMADD132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6417,7 +6417,7 @@ func VFNMADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD132PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6426,7 +6426,7 @@ func VFNMADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD132PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD132SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD132SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6435,7 +6435,7 @@ func VFNMADD132SD(mx, x, x1 operand.Op) { ctx.VFNMADD132SD(mx, x, x1) }
 
 func (c *Context) VFNMADD132SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD132SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6444,7 +6444,7 @@ func VFNMADD132SS(mx, x, x1 operand.Op) { ctx.VFNMADD132SS(mx, x, x1) }
 
 func (c *Context) VFNMADD213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6453,7 +6453,7 @@ func VFNMADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD213PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6462,7 +6462,7 @@ func VFNMADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD213PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD213SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD213SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6471,7 +6471,7 @@ func VFNMADD213SD(mx, x, x1 operand.Op) { ctx.VFNMADD213SD(mx, x, x1) }
 
 func (c *Context) VFNMADD213SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD213SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6480,7 +6480,7 @@ func VFNMADD213SS(mx, x, x1 operand.Op) { ctx.VFNMADD213SS(mx, x, x1) }
 
 func (c *Context) VFNMADD231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6489,7 +6489,7 @@ func VFNMADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD231PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMADD231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6498,7 +6498,7 @@ func VFNMADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD231PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMADD231SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD231SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6507,7 +6507,7 @@ func VFNMADD231SD(mx, x, x1 operand.Op) { ctx.VFNMADD231SD(mx, x, x1) }
 
 func (c *Context) VFNMADD231SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMADD231SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6516,7 +6516,7 @@ func VFNMADD231SS(mx, x, x1 operand.Op) { ctx.VFNMADD231SS(mx, x, x1) }
 
 func (c *Context) VFNMSUB132PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB132PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6525,7 +6525,7 @@ func VFNMSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB132PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB132PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB132PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6534,7 +6534,7 @@ func VFNMSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB132PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB132SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB132SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6543,7 +6543,7 @@ func VFNMSUB132SD(mx, x, x1 operand.Op) { ctx.VFNMSUB132SD(mx, x, x1) }
 
 func (c *Context) VFNMSUB132SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB132SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6552,7 +6552,7 @@ func VFNMSUB132SS(mx, x, x1 operand.Op) { ctx.VFNMSUB132SS(mx, x, x1) }
 
 func (c *Context) VFNMSUB213PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB213PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6561,7 +6561,7 @@ func VFNMSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB213PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB213PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB213PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6570,7 +6570,7 @@ func VFNMSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB213PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB213SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB213SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6579,7 +6579,7 @@ func VFNMSUB213SD(mx, x, x1 operand.Op) { ctx.VFNMSUB213SD(mx, x, x1) }
 
 func (c *Context) VFNMSUB213SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB213SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6588,7 +6588,7 @@ func VFNMSUB213SS(mx, x, x1 operand.Op) { ctx.VFNMSUB213SS(mx, x, x1) }
 
 func (c *Context) VFNMSUB231PD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB231PD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6597,7 +6597,7 @@ func VFNMSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB231PD(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB231PS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VFNMSUB231PS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6606,7 +6606,7 @@ func VFNMSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB231PS(mxy, xy, xy1) }
 
 func (c *Context) VFNMSUB231SD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB231SD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6615,7 +6615,7 @@ func VFNMSUB231SD(mx, x, x1 operand.Op) { ctx.VFNMSUB231SD(mx, x, x1) }
 
 func (c *Context) VFNMSUB231SS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VFNMSUB231SS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6624,7 +6624,7 @@ func VFNMSUB231SS(mx, x, x1 operand.Op) { ctx.VFNMSUB231SS(mx, x, x1) }
 
 func (c *Context) VGATHERDPD(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VGATHERDPD(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6633,7 +6633,7 @@ func VGATHERDPD(xy, v, xy1 operand.Op) { ctx.VGATHERDPD(xy, v, xy1) }
 
 func (c *Context) VGATHERDPS(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VGATHERDPS(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6642,7 +6642,7 @@ func VGATHERDPS(xy, v, xy1 operand.Op) { ctx.VGATHERDPS(xy, v, xy1) }
 
 func (c *Context) VGATHERQPD(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VGATHERQPD(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6651,7 +6651,7 @@ func VGATHERQPD(xy, v, xy1 operand.Op) { ctx.VGATHERQPD(xy, v, xy1) }
 
 func (c *Context) VGATHERQPS(x, v, x1 operand.Op) {
 	if inst, err := x86.VGATHERQPS(x, v, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6660,7 +6660,7 @@ func VGATHERQPS(x, v, x1 operand.Op) { ctx.VGATHERQPS(x, v, x1) }
 
 func (c *Context) VHADDPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VHADDPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6669,7 +6669,7 @@ func VHADDPD(mxy, xy, xy1 operand.Op) { ctx.VHADDPD(mxy, xy, xy1) }
 
 func (c *Context) VHADDPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VHADDPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6678,7 +6678,7 @@ func VHADDPS(mxy, xy, xy1 operand.Op) { ctx.VHADDPS(mxy, xy, xy1) }
 
 func (c *Context) VHSUBPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VHSUBPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6687,7 +6687,7 @@ func VHSUBPD(mxy, xy, xy1 operand.Op) { ctx.VHSUBPD(mxy, xy, xy1) }
 
 func (c *Context) VHSUBPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VHSUBPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6696,7 +6696,7 @@ func VHSUBPS(mxy, xy, xy1 operand.Op) { ctx.VHSUBPS(mxy, xy, xy1) }
 
 func (c *Context) VINSERTF128(i, mx, y, y1 operand.Op) {
 	if inst, err := x86.VINSERTF128(i, mx, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6705,7 +6705,7 @@ func VINSERTF128(i, mx, y, y1 operand.Op) { ctx.VINSERTF128(i, mx, y, y1) }
 
 func (c *Context) VINSERTI128(i, mx, y, y1 operand.Op) {
 	if inst, err := x86.VINSERTI128(i, mx, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6714,7 +6714,7 @@ func VINSERTI128(i, mx, y, y1 operand.Op) { ctx.VINSERTI128(i, mx, y, y1) }
 
 func (c *Context) VINSERTPS(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VINSERTPS(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6723,7 +6723,7 @@ func VINSERTPS(i, mx, x, x1 operand.Op) { ctx.VINSERTPS(i, mx, x, x1) }
 
 func (c *Context) VLDDQU(m, xy operand.Op) {
 	if inst, err := x86.VLDDQU(m, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6732,7 +6732,7 @@ func VLDDQU(m, xy operand.Op) { ctx.VLDDQU(m, xy) }
 
 func (c *Context) VLDMXCSR(m operand.Op) {
 	if inst, err := x86.VLDMXCSR(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6741,7 +6741,7 @@ func VLDMXCSR(m operand.Op) { ctx.VLDMXCSR(m) }
 
 func (c *Context) VMASKMOVDQU(x, x1 operand.Op) {
 	if inst, err := x86.VMASKMOVDQU(x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6750,7 +6750,7 @@ func VMASKMOVDQU(x, x1 operand.Op) { ctx.VMASKMOVDQU(x, x1) }
 
 func (c *Context) VMASKMOVPD(mxy, xy, mxy1 operand.Op) {
 	if inst, err := x86.VMASKMOVPD(mxy, xy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6759,7 +6759,7 @@ func VMASKMOVPD(mxy, xy, mxy1 operand.Op) { ctx.VMASKMOVPD(mxy, xy, mxy1) }
 
 func (c *Context) VMASKMOVPS(mxy, xy, mxy1 operand.Op) {
 	if inst, err := x86.VMASKMOVPS(mxy, xy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6768,7 +6768,7 @@ func VMASKMOVPS(mxy, xy, mxy1 operand.Op) { ctx.VMASKMOVPS(mxy, xy, mxy1) }
 
 func (c *Context) VMAXPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMAXPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6777,7 +6777,7 @@ func VMAXPD(mxy, xy, xy1 operand.Op) { ctx.VMAXPD(mxy, xy, xy1) }
 
 func (c *Context) VMAXPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMAXPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6786,7 +6786,7 @@ func VMAXPS(mxy, xy, xy1 operand.Op) { ctx.VMAXPS(mxy, xy, xy1) }
 
 func (c *Context) VMAXSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMAXSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6795,7 +6795,7 @@ func VMAXSD(mx, x, x1 operand.Op) { ctx.VMAXSD(mx, x, x1) }
 
 func (c *Context) VMAXSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMAXSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6804,7 +6804,7 @@ func VMAXSS(mx, x, x1 operand.Op) { ctx.VMAXSS(mx, x, x1) }
 
 func (c *Context) VMINPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMINPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6813,7 +6813,7 @@ func VMINPD(mxy, xy, xy1 operand.Op) { ctx.VMINPD(mxy, xy, xy1) }
 
 func (c *Context) VMINPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMINPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6822,7 +6822,7 @@ func VMINPS(mxy, xy, xy1 operand.Op) { ctx.VMINPS(mxy, xy, xy1) }
 
 func (c *Context) VMINSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMINSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6831,7 +6831,7 @@ func VMINSD(mx, x, x1 operand.Op) { ctx.VMINSD(mx, x, x1) }
 
 func (c *Context) VMINSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMINSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6840,7 +6840,7 @@ func VMINSS(mx, x, x1 operand.Op) { ctx.VMINSS(mx, x, x1) }
 
 func (c *Context) VMOVAPD(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVAPD(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6849,7 +6849,7 @@ func VMOVAPD(mxy, mxy1 operand.Op) { ctx.VMOVAPD(mxy, mxy1) }
 
 func (c *Context) VMOVAPS(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVAPS(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6858,7 +6858,7 @@ func VMOVAPS(mxy, mxy1 operand.Op) { ctx.VMOVAPS(mxy, mxy1) }
 
 func (c *Context) VMOVD(mrx, mrx1 operand.Op) {
 	if inst, err := x86.VMOVD(mrx, mrx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6867,7 +6867,7 @@ func VMOVD(mrx, mrx1 operand.Op) { ctx.VMOVD(mrx, mrx1) }
 
 func (c *Context) VMOVDDUP(mxy, xy operand.Op) {
 	if inst, err := x86.VMOVDDUP(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6876,7 +6876,7 @@ func VMOVDDUP(mxy, xy operand.Op) { ctx.VMOVDDUP(mxy, xy) }
 
 func (c *Context) VMOVDQA(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVDQA(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6885,7 +6885,7 @@ func VMOVDQA(mxy, mxy1 operand.Op) { ctx.VMOVDQA(mxy, mxy1) }
 
 func (c *Context) VMOVDQU(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVDQU(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6894,7 +6894,7 @@ func VMOVDQU(mxy, mxy1 operand.Op) { ctx.VMOVDQU(mxy, mxy1) }
 
 func (c *Context) VMOVHLPS(x, x1, x2 operand.Op) {
 	if inst, err := x86.VMOVHLPS(x, x1, x2); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6903,7 +6903,7 @@ func VMOVHLPS(x, x1, x2 operand.Op) { ctx.VMOVHLPS(x, x1, x2) }
 
 func (c *Context) VMOVHPD(ops ...operand.Op) {
 	if inst, err := x86.VMOVHPD(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6912,7 +6912,7 @@ func VMOVHPD(ops ...operand.Op) { ctx.VMOVHPD(ops...) }
 
 func (c *Context) VMOVHPS(ops ...operand.Op) {
 	if inst, err := x86.VMOVHPS(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6921,7 +6921,7 @@ func VMOVHPS(ops ...operand.Op) { ctx.VMOVHPS(ops...) }
 
 func (c *Context) VMOVLHPS(x, x1, x2 operand.Op) {
 	if inst, err := x86.VMOVLHPS(x, x1, x2); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6930,7 +6930,7 @@ func VMOVLHPS(x, x1, x2 operand.Op) { ctx.VMOVLHPS(x, x1, x2) }
 
 func (c *Context) VMOVLPD(ops ...operand.Op) {
 	if inst, err := x86.VMOVLPD(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6939,7 +6939,7 @@ func VMOVLPD(ops ...operand.Op) { ctx.VMOVLPD(ops...) }
 
 func (c *Context) VMOVLPS(ops ...operand.Op) {
 	if inst, err := x86.VMOVLPS(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6948,7 +6948,7 @@ func VMOVLPS(ops ...operand.Op) { ctx.VMOVLPS(ops...) }
 
 func (c *Context) VMOVMSKPD(xy, r operand.Op) {
 	if inst, err := x86.VMOVMSKPD(xy, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6957,7 +6957,7 @@ func VMOVMSKPD(xy, r operand.Op) { ctx.VMOVMSKPD(xy, r) }
 
 func (c *Context) VMOVMSKPS(xy, r operand.Op) {
 	if inst, err := x86.VMOVMSKPS(xy, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6966,7 +6966,7 @@ func VMOVMSKPS(xy, r operand.Op) { ctx.VMOVMSKPS(xy, r) }
 
 func (c *Context) VMOVNTDQ(xy, m operand.Op) {
 	if inst, err := x86.VMOVNTDQ(xy, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6975,7 +6975,7 @@ func VMOVNTDQ(xy, m operand.Op) { ctx.VMOVNTDQ(xy, m) }
 
 func (c *Context) VMOVNTDQA(m, xy operand.Op) {
 	if inst, err := x86.VMOVNTDQA(m, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6984,7 +6984,7 @@ func VMOVNTDQA(m, xy operand.Op) { ctx.VMOVNTDQA(m, xy) }
 
 func (c *Context) VMOVNTPD(xy, m operand.Op) {
 	if inst, err := x86.VMOVNTPD(xy, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -6993,7 +6993,7 @@ func VMOVNTPD(xy, m operand.Op) { ctx.VMOVNTPD(xy, m) }
 
 func (c *Context) VMOVNTPS(xy, m operand.Op) {
 	if inst, err := x86.VMOVNTPS(xy, m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7002,7 +7002,7 @@ func VMOVNTPS(xy, m operand.Op) { ctx.VMOVNTPS(xy, m) }
 
 func (c *Context) VMOVQ(mrx, mrx1 operand.Op) {
 	if inst, err := x86.VMOVQ(mrx, mrx1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7011,7 +7011,7 @@ func VMOVQ(mrx, mrx1 operand.Op) { ctx.VMOVQ(mrx, mrx1) }
 
 func (c *Context) VMOVSD(ops ...operand.Op) {
 	if inst, err := x86.VMOVSD(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7020,7 +7020,7 @@ func VMOVSD(ops ...operand.Op) { ctx.VMOVSD(ops...) }
 
 func (c *Context) VMOVSHDUP(mxy, xy operand.Op) {
 	if inst, err := x86.VMOVSHDUP(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7029,7 +7029,7 @@ func VMOVSHDUP(mxy, xy operand.Op) { ctx.VMOVSHDUP(mxy, xy) }
 
 func (c *Context) VMOVSLDUP(mxy, xy operand.Op) {
 	if inst, err := x86.VMOVSLDUP(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7038,7 +7038,7 @@ func VMOVSLDUP(mxy, xy operand.Op) { ctx.VMOVSLDUP(mxy, xy) }
 
 func (c *Context) VMOVSS(ops ...operand.Op) {
 	if inst, err := x86.VMOVSS(ops...); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7047,7 +7047,7 @@ func VMOVSS(ops ...operand.Op) { ctx.VMOVSS(ops...) }
 
 func (c *Context) VMOVUPD(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVUPD(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7056,7 +7056,7 @@ func VMOVUPD(mxy, mxy1 operand.Op) { ctx.VMOVUPD(mxy, mxy1) }
 
 func (c *Context) VMOVUPS(mxy, mxy1 operand.Op) {
 	if inst, err := x86.VMOVUPS(mxy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7065,7 +7065,7 @@ func VMOVUPS(mxy, mxy1 operand.Op) { ctx.VMOVUPS(mxy, mxy1) }
 
 func (c *Context) VMPSADBW(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMPSADBW(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7074,7 +7074,7 @@ func VMPSADBW(i, mxy, xy, xy1 operand.Op) { ctx.VMPSADBW(i, mxy, xy, xy1) }
 
 func (c *Context) VMULPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMULPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7083,7 +7083,7 @@ func VMULPD(mxy, xy, xy1 operand.Op) { ctx.VMULPD(mxy, xy, xy1) }
 
 func (c *Context) VMULPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VMULPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7092,7 +7092,7 @@ func VMULPS(mxy, xy, xy1 operand.Op) { ctx.VMULPS(mxy, xy, xy1) }
 
 func (c *Context) VMULSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMULSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7101,7 +7101,7 @@ func VMULSD(mx, x, x1 operand.Op) { ctx.VMULSD(mx, x, x1) }
 
 func (c *Context) VMULSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VMULSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7110,7 +7110,7 @@ func VMULSS(mx, x, x1 operand.Op) { ctx.VMULSS(mx, x, x1) }
 
 func (c *Context) VORPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VORPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7119,7 +7119,7 @@ func VORPD(mxy, xy, xy1 operand.Op) { ctx.VORPD(mxy, xy, xy1) }
 
 func (c *Context) VORPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VORPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7128,7 +7128,7 @@ func VORPS(mxy, xy, xy1 operand.Op) { ctx.VORPS(mxy, xy, xy1) }
 
 func (c *Context) VPABSB(mxy, xy operand.Op) {
 	if inst, err := x86.VPABSB(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7137,7 +7137,7 @@ func VPABSB(mxy, xy operand.Op) { ctx.VPABSB(mxy, xy) }
 
 func (c *Context) VPABSD(mxy, xy operand.Op) {
 	if inst, err := x86.VPABSD(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7146,7 +7146,7 @@ func VPABSD(mxy, xy operand.Op) { ctx.VPABSD(mxy, xy) }
 
 func (c *Context) VPABSW(mxy, xy operand.Op) {
 	if inst, err := x86.VPABSW(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7155,7 +7155,7 @@ func VPABSW(mxy, xy operand.Op) { ctx.VPABSW(mxy, xy) }
 
 func (c *Context) VPACKSSDW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPACKSSDW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7164,7 +7164,7 @@ func VPACKSSDW(mxy, xy, xy1 operand.Op) { ctx.VPACKSSDW(mxy, xy, xy1) }
 
 func (c *Context) VPACKSSWB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPACKSSWB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7173,7 +7173,7 @@ func VPACKSSWB(mxy, xy, xy1 operand.Op) { ctx.VPACKSSWB(mxy, xy, xy1) }
 
 func (c *Context) VPACKUSDW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPACKUSDW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7182,7 +7182,7 @@ func VPACKUSDW(mxy, xy, xy1 operand.Op) { ctx.VPACKUSDW(mxy, xy, xy1) }
 
 func (c *Context) VPACKUSWB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPACKUSWB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7191,7 +7191,7 @@ func VPACKUSWB(mxy, xy, xy1 operand.Op) { ctx.VPACKUSWB(mxy, xy, xy1) }
 
 func (c *Context) VPADDB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7200,7 +7200,7 @@ func VPADDB(mxy, xy, xy1 operand.Op) { ctx.VPADDB(mxy, xy, xy1) }
 
 func (c *Context) VPADDD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7209,7 +7209,7 @@ func VPADDD(mxy, xy, xy1 operand.Op) { ctx.VPADDD(mxy, xy, xy1) }
 
 func (c *Context) VPADDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7218,7 +7218,7 @@ func VPADDQ(mxy, xy, xy1 operand.Op) { ctx.VPADDQ(mxy, xy, xy1) }
 
 func (c *Context) VPADDSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7227,7 +7227,7 @@ func VPADDSB(mxy, xy, xy1 operand.Op) { ctx.VPADDSB(mxy, xy, xy1) }
 
 func (c *Context) VPADDSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7236,7 +7236,7 @@ func VPADDSW(mxy, xy, xy1 operand.Op) { ctx.VPADDSW(mxy, xy, xy1) }
 
 func (c *Context) VPADDUSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDUSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7245,7 +7245,7 @@ func VPADDUSB(mxy, xy, xy1 operand.Op) { ctx.VPADDUSB(mxy, xy, xy1) }
 
 func (c *Context) VPADDUSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDUSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7254,7 +7254,7 @@ func VPADDUSW(mxy, xy, xy1 operand.Op) { ctx.VPADDUSW(mxy, xy, xy1) }
 
 func (c *Context) VPADDW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPADDW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7263,7 +7263,7 @@ func VPADDW(mxy, xy, xy1 operand.Op) { ctx.VPADDW(mxy, xy, xy1) }
 
 func (c *Context) VPALIGNR(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPALIGNR(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7272,7 +7272,7 @@ func VPALIGNR(i, mxy, xy, xy1 operand.Op) { ctx.VPALIGNR(i, mxy, xy, xy1) }
 
 func (c *Context) VPAND(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPAND(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7281,7 +7281,7 @@ func VPAND(mxy, xy, xy1 operand.Op) { ctx.VPAND(mxy, xy, xy1) }
 
 func (c *Context) VPANDN(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPANDN(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7290,7 +7290,7 @@ func VPANDN(mxy, xy, xy1 operand.Op) { ctx.VPANDN(mxy, xy, xy1) }
 
 func (c *Context) VPAVGB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPAVGB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7299,7 +7299,7 @@ func VPAVGB(mxy, xy, xy1 operand.Op) { ctx.VPAVGB(mxy, xy, xy1) }
 
 func (c *Context) VPAVGW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPAVGW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7308,7 +7308,7 @@ func VPAVGW(mxy, xy, xy1 operand.Op) { ctx.VPAVGW(mxy, xy, xy1) }
 
 func (c *Context) VPBLENDD(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPBLENDD(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7317,7 +7317,7 @@ func VPBLENDD(i, mxy, xy, xy1 operand.Op) { ctx.VPBLENDD(i, mxy, xy, xy1) }
 
 func (c *Context) VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) {
 	if inst, err := x86.VPBLENDVB(xy, mxy, xy1, xy2); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7326,7 +7326,7 @@ func VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) { ctx.VPBLENDVB(xy, mxy, xy1, xy2)
 
 func (c *Context) VPBLENDW(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPBLENDW(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7335,7 +7335,7 @@ func VPBLENDW(i, mxy, xy, xy1 operand.Op) { ctx.VPBLENDW(i, mxy, xy, xy1) }
 
 func (c *Context) VPBROADCASTB(mx, xy operand.Op) {
 	if inst, err := x86.VPBROADCASTB(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7344,7 +7344,7 @@ func VPBROADCASTB(mx, xy operand.Op) { ctx.VPBROADCASTB(mx, xy) }
 
 func (c *Context) VPBROADCASTD(mx, xy operand.Op) {
 	if inst, err := x86.VPBROADCASTD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7353,7 +7353,7 @@ func VPBROADCASTD(mx, xy operand.Op) { ctx.VPBROADCASTD(mx, xy) }
 
 func (c *Context) VPBROADCASTQ(mx, xy operand.Op) {
 	if inst, err := x86.VPBROADCASTQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7362,7 +7362,7 @@ func VPBROADCASTQ(mx, xy operand.Op) { ctx.VPBROADCASTQ(mx, xy) }
 
 func (c *Context) VPBROADCASTW(mx, xy operand.Op) {
 	if inst, err := x86.VPBROADCASTW(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7371,7 +7371,7 @@ func VPBROADCASTW(mx, xy operand.Op) { ctx.VPBROADCASTW(mx, xy) }
 
 func (c *Context) VPCLMULQDQ(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VPCLMULQDQ(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7380,7 +7380,7 @@ func VPCLMULQDQ(i, mx, x, x1 operand.Op) { ctx.VPCLMULQDQ(i, mx, x, x1) }
 
 func (c *Context) VPCMPEQB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPEQB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7389,7 +7389,7 @@ func VPCMPEQB(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQB(mxy, xy, xy1) }
 
 func (c *Context) VPCMPEQD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPEQD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7398,7 +7398,7 @@ func VPCMPEQD(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQD(mxy, xy, xy1) }
 
 func (c *Context) VPCMPEQQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPEQQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7407,7 +7407,7 @@ func VPCMPEQQ(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQQ(mxy, xy, xy1) }
 
 func (c *Context) VPCMPEQW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPEQW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7416,7 +7416,7 @@ func VPCMPEQW(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQW(mxy, xy, xy1) }
 
 func (c *Context) VPCMPESTRI(i, mx, x operand.Op) {
 	if inst, err := x86.VPCMPESTRI(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7425,7 +7425,7 @@ func VPCMPESTRI(i, mx, x operand.Op) { ctx.VPCMPESTRI(i, mx, x) }
 
 func (c *Context) VPCMPESTRM(i, mx, x operand.Op) {
 	if inst, err := x86.VPCMPESTRM(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7434,7 +7434,7 @@ func VPCMPESTRM(i, mx, x operand.Op) { ctx.VPCMPESTRM(i, mx, x) }
 
 func (c *Context) VPCMPGTB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPGTB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7443,7 +7443,7 @@ func VPCMPGTB(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTB(mxy, xy, xy1) }
 
 func (c *Context) VPCMPGTD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPGTD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7452,7 +7452,7 @@ func VPCMPGTD(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTD(mxy, xy, xy1) }
 
 func (c *Context) VPCMPGTQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPGTQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7461,7 +7461,7 @@ func VPCMPGTQ(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTQ(mxy, xy, xy1) }
 
 func (c *Context) VPCMPGTW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPCMPGTW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7470,7 +7470,7 @@ func VPCMPGTW(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTW(mxy, xy, xy1) }
 
 func (c *Context) VPCMPISTRI(i, mx, x operand.Op) {
 	if inst, err := x86.VPCMPISTRI(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7479,7 +7479,7 @@ func VPCMPISTRI(i, mx, x operand.Op) { ctx.VPCMPISTRI(i, mx, x) }
 
 func (c *Context) VPCMPISTRM(i, mx, x operand.Op) {
 	if inst, err := x86.VPCMPISTRM(i, mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7488,7 +7488,7 @@ func VPCMPISTRM(i, mx, x operand.Op) { ctx.VPCMPISTRM(i, mx, x) }
 
 func (c *Context) VPERM2F128(i, my, y, y1 operand.Op) {
 	if inst, err := x86.VPERM2F128(i, my, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7497,7 +7497,7 @@ func VPERM2F128(i, my, y, y1 operand.Op) { ctx.VPERM2F128(i, my, y, y1) }
 
 func (c *Context) VPERM2I128(i, my, y, y1 operand.Op) {
 	if inst, err := x86.VPERM2I128(i, my, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7506,7 +7506,7 @@ func VPERM2I128(i, my, y, y1 operand.Op) { ctx.VPERM2I128(i, my, y, y1) }
 
 func (c *Context) VPERMD(my, y, y1 operand.Op) {
 	if inst, err := x86.VPERMD(my, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7515,7 +7515,7 @@ func VPERMD(my, y, y1 operand.Op) { ctx.VPERMD(my, y, y1) }
 
 func (c *Context) VPERMILPD(imxy, mxy, xy operand.Op) {
 	if inst, err := x86.VPERMILPD(imxy, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7524,7 +7524,7 @@ func VPERMILPD(imxy, mxy, xy operand.Op) { ctx.VPERMILPD(imxy, mxy, xy) }
 
 func (c *Context) VPERMILPS(imxy, mxy, xy operand.Op) {
 	if inst, err := x86.VPERMILPS(imxy, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7533,7 +7533,7 @@ func VPERMILPS(imxy, mxy, xy operand.Op) { ctx.VPERMILPS(imxy, mxy, xy) }
 
 func (c *Context) VPERMPD(i, my, y operand.Op) {
 	if inst, err := x86.VPERMPD(i, my, y); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7542,7 +7542,7 @@ func VPERMPD(i, my, y operand.Op) { ctx.VPERMPD(i, my, y) }
 
 func (c *Context) VPERMPS(my, y, y1 operand.Op) {
 	if inst, err := x86.VPERMPS(my, y, y1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7551,7 +7551,7 @@ func VPERMPS(my, y, y1 operand.Op) { ctx.VPERMPS(my, y, y1) }
 
 func (c *Context) VPERMQ(i, my, y operand.Op) {
 	if inst, err := x86.VPERMQ(i, my, y); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7560,7 +7560,7 @@ func VPERMQ(i, my, y operand.Op) { ctx.VPERMQ(i, my, y) }
 
 func (c *Context) VPEXTRB(i, x, mr operand.Op) {
 	if inst, err := x86.VPEXTRB(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7569,7 +7569,7 @@ func VPEXTRB(i, x, mr operand.Op) { ctx.VPEXTRB(i, x, mr) }
 
 func (c *Context) VPEXTRD(i, x, mr operand.Op) {
 	if inst, err := x86.VPEXTRD(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7578,7 +7578,7 @@ func VPEXTRD(i, x, mr operand.Op) { ctx.VPEXTRD(i, x, mr) }
 
 func (c *Context) VPEXTRQ(i, x, mr operand.Op) {
 	if inst, err := x86.VPEXTRQ(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7587,7 +7587,7 @@ func VPEXTRQ(i, x, mr operand.Op) { ctx.VPEXTRQ(i, x, mr) }
 
 func (c *Context) VPEXTRW(i, x, mr operand.Op) {
 	if inst, err := x86.VPEXTRW(i, x, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7596,7 +7596,7 @@ func VPEXTRW(i, x, mr operand.Op) { ctx.VPEXTRW(i, x, mr) }
 
 func (c *Context) VPGATHERDD(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VPGATHERDD(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7605,7 +7605,7 @@ func VPGATHERDD(xy, v, xy1 operand.Op) { ctx.VPGATHERDD(xy, v, xy1) }
 
 func (c *Context) VPGATHERDQ(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VPGATHERDQ(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7614,7 +7614,7 @@ func VPGATHERDQ(xy, v, xy1 operand.Op) { ctx.VPGATHERDQ(xy, v, xy1) }
 
 func (c *Context) VPGATHERQD(x, v, x1 operand.Op) {
 	if inst, err := x86.VPGATHERQD(x, v, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7623,7 +7623,7 @@ func VPGATHERQD(x, v, x1 operand.Op) { ctx.VPGATHERQD(x, v, x1) }
 
 func (c *Context) VPGATHERQQ(xy, v, xy1 operand.Op) {
 	if inst, err := x86.VPGATHERQQ(xy, v, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7632,7 +7632,7 @@ func VPGATHERQQ(xy, v, xy1 operand.Op) { ctx.VPGATHERQQ(xy, v, xy1) }
 
 func (c *Context) VPHADDD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHADDD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7641,7 +7641,7 @@ func VPHADDD(mxy, xy, xy1 operand.Op) { ctx.VPHADDD(mxy, xy, xy1) }
 
 func (c *Context) VPHADDSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHADDSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7650,7 +7650,7 @@ func VPHADDSW(mxy, xy, xy1 operand.Op) { ctx.VPHADDSW(mxy, xy, xy1) }
 
 func (c *Context) VPHADDW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHADDW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7659,7 +7659,7 @@ func VPHADDW(mxy, xy, xy1 operand.Op) { ctx.VPHADDW(mxy, xy, xy1) }
 
 func (c *Context) VPHMINPOSUW(mx, x operand.Op) {
 	if inst, err := x86.VPHMINPOSUW(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7668,7 +7668,7 @@ func VPHMINPOSUW(mx, x operand.Op) { ctx.VPHMINPOSUW(mx, x) }
 
 func (c *Context) VPHSUBD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHSUBD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7677,7 +7677,7 @@ func VPHSUBD(mxy, xy, xy1 operand.Op) { ctx.VPHSUBD(mxy, xy, xy1) }
 
 func (c *Context) VPHSUBSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHSUBSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7686,7 +7686,7 @@ func VPHSUBSW(mxy, xy, xy1 operand.Op) { ctx.VPHSUBSW(mxy, xy, xy1) }
 
 func (c *Context) VPHSUBW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPHSUBW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7695,7 +7695,7 @@ func VPHSUBW(mxy, xy, xy1 operand.Op) { ctx.VPHSUBW(mxy, xy, xy1) }
 
 func (c *Context) VPINSRB(i, mr, x, x1 operand.Op) {
 	if inst, err := x86.VPINSRB(i, mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7704,7 +7704,7 @@ func VPINSRB(i, mr, x, x1 operand.Op) { ctx.VPINSRB(i, mr, x, x1) }
 
 func (c *Context) VPINSRD(i, mr, x, x1 operand.Op) {
 	if inst, err := x86.VPINSRD(i, mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7713,7 +7713,7 @@ func VPINSRD(i, mr, x, x1 operand.Op) { ctx.VPINSRD(i, mr, x, x1) }
 
 func (c *Context) VPINSRQ(i, mr, x, x1 operand.Op) {
 	if inst, err := x86.VPINSRQ(i, mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7722,7 +7722,7 @@ func VPINSRQ(i, mr, x, x1 operand.Op) { ctx.VPINSRQ(i, mr, x, x1) }
 
 func (c *Context) VPINSRW(i, mr, x, x1 operand.Op) {
 	if inst, err := x86.VPINSRW(i, mr, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7731,7 +7731,7 @@ func VPINSRW(i, mr, x, x1 operand.Op) { ctx.VPINSRW(i, mr, x, x1) }
 
 func (c *Context) VPMADDUBSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMADDUBSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7740,7 +7740,7 @@ func VPMADDUBSW(mxy, xy, xy1 operand.Op) { ctx.VPMADDUBSW(mxy, xy, xy1) }
 
 func (c *Context) VPMADDWD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMADDWD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7749,7 +7749,7 @@ func VPMADDWD(mxy, xy, xy1 operand.Op) { ctx.VPMADDWD(mxy, xy, xy1) }
 
 func (c *Context) VPMASKMOVD(mxy, xy, mxy1 operand.Op) {
 	if inst, err := x86.VPMASKMOVD(mxy, xy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7758,7 +7758,7 @@ func VPMASKMOVD(mxy, xy, mxy1 operand.Op) { ctx.VPMASKMOVD(mxy, xy, mxy1) }
 
 func (c *Context) VPMASKMOVQ(mxy, xy, mxy1 operand.Op) {
 	if inst, err := x86.VPMASKMOVQ(mxy, xy, mxy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7767,7 +7767,7 @@ func VPMASKMOVQ(mxy, xy, mxy1 operand.Op) { ctx.VPMASKMOVQ(mxy, xy, mxy1) }
 
 func (c *Context) VPMAXSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7776,7 +7776,7 @@ func VPMAXSB(mxy, xy, xy1 operand.Op) { ctx.VPMAXSB(mxy, xy, xy1) }
 
 func (c *Context) VPMAXSD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXSD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7785,7 +7785,7 @@ func VPMAXSD(mxy, xy, xy1 operand.Op) { ctx.VPMAXSD(mxy, xy, xy1) }
 
 func (c *Context) VPMAXSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7794,7 +7794,7 @@ func VPMAXSW(mxy, xy, xy1 operand.Op) { ctx.VPMAXSW(mxy, xy, xy1) }
 
 func (c *Context) VPMAXUB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXUB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7803,7 +7803,7 @@ func VPMAXUB(mxy, xy, xy1 operand.Op) { ctx.VPMAXUB(mxy, xy, xy1) }
 
 func (c *Context) VPMAXUD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXUD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7812,7 +7812,7 @@ func VPMAXUD(mxy, xy, xy1 operand.Op) { ctx.VPMAXUD(mxy, xy, xy1) }
 
 func (c *Context) VPMAXUW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMAXUW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7821,7 +7821,7 @@ func VPMAXUW(mxy, xy, xy1 operand.Op) { ctx.VPMAXUW(mxy, xy, xy1) }
 
 func (c *Context) VPMINSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7830,7 +7830,7 @@ func VPMINSB(mxy, xy, xy1 operand.Op) { ctx.VPMINSB(mxy, xy, xy1) }
 
 func (c *Context) VPMINSD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINSD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7839,7 +7839,7 @@ func VPMINSD(mxy, xy, xy1 operand.Op) { ctx.VPMINSD(mxy, xy, xy1) }
 
 func (c *Context) VPMINSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7848,7 +7848,7 @@ func VPMINSW(mxy, xy, xy1 operand.Op) { ctx.VPMINSW(mxy, xy, xy1) }
 
 func (c *Context) VPMINUB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINUB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7857,7 +7857,7 @@ func VPMINUB(mxy, xy, xy1 operand.Op) { ctx.VPMINUB(mxy, xy, xy1) }
 
 func (c *Context) VPMINUD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINUD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7866,7 +7866,7 @@ func VPMINUD(mxy, xy, xy1 operand.Op) { ctx.VPMINUD(mxy, xy, xy1) }
 
 func (c *Context) VPMINUW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMINUW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7875,7 +7875,7 @@ func VPMINUW(mxy, xy, xy1 operand.Op) { ctx.VPMINUW(mxy, xy, xy1) }
 
 func (c *Context) VPMOVMSKB(xy, r operand.Op) {
 	if inst, err := x86.VPMOVMSKB(xy, r); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7884,7 +7884,7 @@ func VPMOVMSKB(xy, r operand.Op) { ctx.VPMOVMSKB(xy, r) }
 
 func (c *Context) VPMOVSXBD(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXBD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7893,7 +7893,7 @@ func VPMOVSXBD(mx, xy operand.Op) { ctx.VPMOVSXBD(mx, xy) }
 
 func (c *Context) VPMOVSXBQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXBQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7902,7 +7902,7 @@ func VPMOVSXBQ(mx, xy operand.Op) { ctx.VPMOVSXBQ(mx, xy) }
 
 func (c *Context) VPMOVSXBW(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXBW(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7911,7 +7911,7 @@ func VPMOVSXBW(mx, xy operand.Op) { ctx.VPMOVSXBW(mx, xy) }
 
 func (c *Context) VPMOVSXDQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXDQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7920,7 +7920,7 @@ func VPMOVSXDQ(mx, xy operand.Op) { ctx.VPMOVSXDQ(mx, xy) }
 
 func (c *Context) VPMOVSXWD(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXWD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7929,7 +7929,7 @@ func VPMOVSXWD(mx, xy operand.Op) { ctx.VPMOVSXWD(mx, xy) }
 
 func (c *Context) VPMOVSXWQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVSXWQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7938,7 +7938,7 @@ func VPMOVSXWQ(mx, xy operand.Op) { ctx.VPMOVSXWQ(mx, xy) }
 
 func (c *Context) VPMOVZXBD(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXBD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7947,7 +7947,7 @@ func VPMOVZXBD(mx, xy operand.Op) { ctx.VPMOVZXBD(mx, xy) }
 
 func (c *Context) VPMOVZXBQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXBQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7956,7 +7956,7 @@ func VPMOVZXBQ(mx, xy operand.Op) { ctx.VPMOVZXBQ(mx, xy) }
 
 func (c *Context) VPMOVZXBW(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXBW(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7965,7 +7965,7 @@ func VPMOVZXBW(mx, xy operand.Op) { ctx.VPMOVZXBW(mx, xy) }
 
 func (c *Context) VPMOVZXDQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXDQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7974,7 +7974,7 @@ func VPMOVZXDQ(mx, xy operand.Op) { ctx.VPMOVZXDQ(mx, xy) }
 
 func (c *Context) VPMOVZXWD(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXWD(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7983,7 +7983,7 @@ func VPMOVZXWD(mx, xy operand.Op) { ctx.VPMOVZXWD(mx, xy) }
 
 func (c *Context) VPMOVZXWQ(mx, xy operand.Op) {
 	if inst, err := x86.VPMOVZXWQ(mx, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -7992,7 +7992,7 @@ func VPMOVZXWQ(mx, xy operand.Op) { ctx.VPMOVZXWQ(mx, xy) }
 
 func (c *Context) VPMULDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8001,7 +8001,7 @@ func VPMULDQ(mxy, xy, xy1 operand.Op) { ctx.VPMULDQ(mxy, xy, xy1) }
 
 func (c *Context) VPMULHRSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULHRSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8010,7 +8010,7 @@ func VPMULHRSW(mxy, xy, xy1 operand.Op) { ctx.VPMULHRSW(mxy, xy, xy1) }
 
 func (c *Context) VPMULHUW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULHUW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8019,7 +8019,7 @@ func VPMULHUW(mxy, xy, xy1 operand.Op) { ctx.VPMULHUW(mxy, xy, xy1) }
 
 func (c *Context) VPMULHW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULHW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8028,7 +8028,7 @@ func VPMULHW(mxy, xy, xy1 operand.Op) { ctx.VPMULHW(mxy, xy, xy1) }
 
 func (c *Context) VPMULLD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULLD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8037,7 +8037,7 @@ func VPMULLD(mxy, xy, xy1 operand.Op) { ctx.VPMULLD(mxy, xy, xy1) }
 
 func (c *Context) VPMULLW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULLW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8046,7 +8046,7 @@ func VPMULLW(mxy, xy, xy1 operand.Op) { ctx.VPMULLW(mxy, xy, xy1) }
 
 func (c *Context) VPMULUDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPMULUDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8055,7 +8055,7 @@ func VPMULUDQ(mxy, xy, xy1 operand.Op) { ctx.VPMULUDQ(mxy, xy, xy1) }
 
 func (c *Context) VPOR(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPOR(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8064,7 +8064,7 @@ func VPOR(mxy, xy, xy1 operand.Op) { ctx.VPOR(mxy, xy, xy1) }
 
 func (c *Context) VPSADBW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSADBW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8073,7 +8073,7 @@ func VPSADBW(mxy, xy, xy1 operand.Op) { ctx.VPSADBW(mxy, xy, xy1) }
 
 func (c *Context) VPSHUFB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSHUFB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8082,7 +8082,7 @@ func VPSHUFB(mxy, xy, xy1 operand.Op) { ctx.VPSHUFB(mxy, xy, xy1) }
 
 func (c *Context) VPSHUFD(i, mxy, xy operand.Op) {
 	if inst, err := x86.VPSHUFD(i, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8091,7 +8091,7 @@ func VPSHUFD(i, mxy, xy operand.Op) { ctx.VPSHUFD(i, mxy, xy) }
 
 func (c *Context) VPSHUFHW(i, mxy, xy operand.Op) {
 	if inst, err := x86.VPSHUFHW(i, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8100,7 +8100,7 @@ func VPSHUFHW(i, mxy, xy operand.Op) { ctx.VPSHUFHW(i, mxy, xy) }
 
 func (c *Context) VPSHUFLW(i, mxy, xy operand.Op) {
 	if inst, err := x86.VPSHUFLW(i, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8109,7 +8109,7 @@ func VPSHUFLW(i, mxy, xy operand.Op) { ctx.VPSHUFLW(i, mxy, xy) }
 
 func (c *Context) VPSIGNB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSIGNB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8118,7 +8118,7 @@ func VPSIGNB(mxy, xy, xy1 operand.Op) { ctx.VPSIGNB(mxy, xy, xy1) }
 
 func (c *Context) VPSIGND(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSIGND(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8127,7 +8127,7 @@ func VPSIGND(mxy, xy, xy1 operand.Op) { ctx.VPSIGND(mxy, xy, xy1) }
 
 func (c *Context) VPSIGNW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSIGNW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8136,7 +8136,7 @@ func VPSIGNW(mxy, xy, xy1 operand.Op) { ctx.VPSIGNW(mxy, xy, xy1) }
 
 func (c *Context) VPSLLD(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLD(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8145,7 +8145,7 @@ func VPSLLD(imx, xy, xy1 operand.Op) { ctx.VPSLLD(imx, xy, xy1) }
 
 func (c *Context) VPSLLDQ(i, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLDQ(i, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8154,7 +8154,7 @@ func VPSLLDQ(i, xy, xy1 operand.Op) { ctx.VPSLLDQ(i, xy, xy1) }
 
 func (c *Context) VPSLLQ(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLQ(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8163,7 +8163,7 @@ func VPSLLQ(imx, xy, xy1 operand.Op) { ctx.VPSLLQ(imx, xy, xy1) }
 
 func (c *Context) VPSLLVD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLVD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8172,7 +8172,7 @@ func VPSLLVD(mxy, xy, xy1 operand.Op) { ctx.VPSLLVD(mxy, xy, xy1) }
 
 func (c *Context) VPSLLVQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLVQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8181,7 +8181,7 @@ func VPSLLVQ(mxy, xy, xy1 operand.Op) { ctx.VPSLLVQ(mxy, xy, xy1) }
 
 func (c *Context) VPSLLW(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSLLW(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8190,7 +8190,7 @@ func VPSLLW(imx, xy, xy1 operand.Op) { ctx.VPSLLW(imx, xy, xy1) }
 
 func (c *Context) VPSRAD(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRAD(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8199,7 +8199,7 @@ func VPSRAD(imx, xy, xy1 operand.Op) { ctx.VPSRAD(imx, xy, xy1) }
 
 func (c *Context) VPSRAVD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRAVD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8208,7 +8208,7 @@ func VPSRAVD(mxy, xy, xy1 operand.Op) { ctx.VPSRAVD(mxy, xy, xy1) }
 
 func (c *Context) VPSRAW(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRAW(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8217,7 +8217,7 @@ func VPSRAW(imx, xy, xy1 operand.Op) { ctx.VPSRAW(imx, xy, xy1) }
 
 func (c *Context) VPSRLD(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLD(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8226,7 +8226,7 @@ func VPSRLD(imx, xy, xy1 operand.Op) { ctx.VPSRLD(imx, xy, xy1) }
 
 func (c *Context) VPSRLDQ(i, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLDQ(i, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8235,7 +8235,7 @@ func VPSRLDQ(i, xy, xy1 operand.Op) { ctx.VPSRLDQ(i, xy, xy1) }
 
 func (c *Context) VPSRLQ(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLQ(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8244,7 +8244,7 @@ func VPSRLQ(imx, xy, xy1 operand.Op) { ctx.VPSRLQ(imx, xy, xy1) }
 
 func (c *Context) VPSRLVD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLVD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8253,7 +8253,7 @@ func VPSRLVD(mxy, xy, xy1 operand.Op) { ctx.VPSRLVD(mxy, xy, xy1) }
 
 func (c *Context) VPSRLVQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLVQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8262,7 +8262,7 @@ func VPSRLVQ(mxy, xy, xy1 operand.Op) { ctx.VPSRLVQ(mxy, xy, xy1) }
 
 func (c *Context) VPSRLW(imx, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSRLW(imx, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8271,7 +8271,7 @@ func VPSRLW(imx, xy, xy1 operand.Op) { ctx.VPSRLW(imx, xy, xy1) }
 
 func (c *Context) VPSUBB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8280,7 +8280,7 @@ func VPSUBB(mxy, xy, xy1 operand.Op) { ctx.VPSUBB(mxy, xy, xy1) }
 
 func (c *Context) VPSUBD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8289,7 +8289,7 @@ func VPSUBD(mxy, xy, xy1 operand.Op) { ctx.VPSUBD(mxy, xy, xy1) }
 
 func (c *Context) VPSUBQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8298,7 +8298,7 @@ func VPSUBQ(mxy, xy, xy1 operand.Op) { ctx.VPSUBQ(mxy, xy, xy1) }
 
 func (c *Context) VPSUBSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8307,7 +8307,7 @@ func VPSUBSB(mxy, xy, xy1 operand.Op) { ctx.VPSUBSB(mxy, xy, xy1) }
 
 func (c *Context) VPSUBSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8316,7 +8316,7 @@ func VPSUBSW(mxy, xy, xy1 operand.Op) { ctx.VPSUBSW(mxy, xy, xy1) }
 
 func (c *Context) VPSUBUSB(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBUSB(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8325,7 +8325,7 @@ func VPSUBUSB(mxy, xy, xy1 operand.Op) { ctx.VPSUBUSB(mxy, xy, xy1) }
 
 func (c *Context) VPSUBUSW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBUSW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8334,7 +8334,7 @@ func VPSUBUSW(mxy, xy, xy1 operand.Op) { ctx.VPSUBUSW(mxy, xy, xy1) }
 
 func (c *Context) VPSUBW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPSUBW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8343,7 +8343,7 @@ func VPSUBW(mxy, xy, xy1 operand.Op) { ctx.VPSUBW(mxy, xy, xy1) }
 
 func (c *Context) VPTEST(mxy, xy operand.Op) {
 	if inst, err := x86.VPTEST(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8352,7 +8352,7 @@ func VPTEST(mxy, xy operand.Op) { ctx.VPTEST(mxy, xy) }
 
 func (c *Context) VPUNPCKHBW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKHBW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8361,7 +8361,7 @@ func VPUNPCKHBW(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHBW(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKHDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKHDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8370,7 +8370,7 @@ func VPUNPCKHDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHDQ(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKHQDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8379,7 +8379,7 @@ func VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHQDQ(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKHWD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKHWD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8388,7 +8388,7 @@ func VPUNPCKHWD(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHWD(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKLBW(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKLBW(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8397,7 +8397,7 @@ func VPUNPCKLBW(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLBW(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKLDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKLDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8406,7 +8406,7 @@ func VPUNPCKLDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLDQ(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKLQDQ(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8415,7 +8415,7 @@ func VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLQDQ(mxy, xy, xy1) }
 
 func (c *Context) VPUNPCKLWD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPUNPCKLWD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8424,7 +8424,7 @@ func VPUNPCKLWD(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLWD(mxy, xy, xy1) }
 
 func (c *Context) VPXOR(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VPXOR(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8433,7 +8433,7 @@ func VPXOR(mxy, xy, xy1 operand.Op) { ctx.VPXOR(mxy, xy, xy1) }
 
 func (c *Context) VRCPPS(mxy, xy operand.Op) {
 	if inst, err := x86.VRCPPS(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8442,7 +8442,7 @@ func VRCPPS(mxy, xy operand.Op) { ctx.VRCPPS(mxy, xy) }
 
 func (c *Context) VRCPSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VRCPSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8451,7 +8451,7 @@ func VRCPSS(mx, x, x1 operand.Op) { ctx.VRCPSS(mx, x, x1) }
 
 func (c *Context) VROUNDPD(i, mxy, xy operand.Op) {
 	if inst, err := x86.VROUNDPD(i, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8460,7 +8460,7 @@ func VROUNDPD(i, mxy, xy operand.Op) { ctx.VROUNDPD(i, mxy, xy) }
 
 func (c *Context) VROUNDPS(i, mxy, xy operand.Op) {
 	if inst, err := x86.VROUNDPS(i, mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8469,7 +8469,7 @@ func VROUNDPS(i, mxy, xy operand.Op) { ctx.VROUNDPS(i, mxy, xy) }
 
 func (c *Context) VROUNDSD(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VROUNDSD(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8478,7 +8478,7 @@ func VROUNDSD(i, mx, x, x1 operand.Op) { ctx.VROUNDSD(i, mx, x, x1) }
 
 func (c *Context) VROUNDSS(i, mx, x, x1 operand.Op) {
 	if inst, err := x86.VROUNDSS(i, mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8487,7 +8487,7 @@ func VROUNDSS(i, mx, x, x1 operand.Op) { ctx.VROUNDSS(i, mx, x, x1) }
 
 func (c *Context) VRSQRTPS(mxy, xy operand.Op) {
 	if inst, err := x86.VRSQRTPS(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8496,7 +8496,7 @@ func VRSQRTPS(mxy, xy operand.Op) { ctx.VRSQRTPS(mxy, xy) }
 
 func (c *Context) VRSQRTSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VRSQRTSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8505,7 +8505,7 @@ func VRSQRTSS(mx, x, x1 operand.Op) { ctx.VRSQRTSS(mx, x, x1) }
 
 func (c *Context) VSHUFPD(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VSHUFPD(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8514,7 +8514,7 @@ func VSHUFPD(i, mxy, xy, xy1 operand.Op) { ctx.VSHUFPD(i, mxy, xy, xy1) }
 
 func (c *Context) VSHUFPS(i, mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VSHUFPS(i, mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8523,7 +8523,7 @@ func VSHUFPS(i, mxy, xy, xy1 operand.Op) { ctx.VSHUFPS(i, mxy, xy, xy1) }
 
 func (c *Context) VSQRTPD(mxy, xy operand.Op) {
 	if inst, err := x86.VSQRTPD(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8532,7 +8532,7 @@ func VSQRTPD(mxy, xy operand.Op) { ctx.VSQRTPD(mxy, xy) }
 
 func (c *Context) VSQRTPS(mxy, xy operand.Op) {
 	if inst, err := x86.VSQRTPS(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8541,7 +8541,7 @@ func VSQRTPS(mxy, xy operand.Op) { ctx.VSQRTPS(mxy, xy) }
 
 func (c *Context) VSQRTSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VSQRTSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8550,7 +8550,7 @@ func VSQRTSD(mx, x, x1 operand.Op) { ctx.VSQRTSD(mx, x, x1) }
 
 func (c *Context) VSQRTSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VSQRTSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8559,7 +8559,7 @@ func VSQRTSS(mx, x, x1 operand.Op) { ctx.VSQRTSS(mx, x, x1) }
 
 func (c *Context) VSTMXCSR(m operand.Op) {
 	if inst, err := x86.VSTMXCSR(m); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8568,7 +8568,7 @@ func VSTMXCSR(m operand.Op) { ctx.VSTMXCSR(m) }
 
 func (c *Context) VSUBPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VSUBPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8577,7 +8577,7 @@ func VSUBPD(mxy, xy, xy1 operand.Op) { ctx.VSUBPD(mxy, xy, xy1) }
 
 func (c *Context) VSUBPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VSUBPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8586,7 +8586,7 @@ func VSUBPS(mxy, xy, xy1 operand.Op) { ctx.VSUBPS(mxy, xy, xy1) }
 
 func (c *Context) VSUBSD(mx, x, x1 operand.Op) {
 	if inst, err := x86.VSUBSD(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8595,7 +8595,7 @@ func VSUBSD(mx, x, x1 operand.Op) { ctx.VSUBSD(mx, x, x1) }
 
 func (c *Context) VSUBSS(mx, x, x1 operand.Op) {
 	if inst, err := x86.VSUBSS(mx, x, x1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8604,7 +8604,7 @@ func VSUBSS(mx, x, x1 operand.Op) { ctx.VSUBSS(mx, x, x1) }
 
 func (c *Context) VTESTPD(mxy, xy operand.Op) {
 	if inst, err := x86.VTESTPD(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8613,7 +8613,7 @@ func VTESTPD(mxy, xy operand.Op) { ctx.VTESTPD(mxy, xy) }
 
 func (c *Context) VTESTPS(mxy, xy operand.Op) {
 	if inst, err := x86.VTESTPS(mxy, xy); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8622,7 +8622,7 @@ func VTESTPS(mxy, xy operand.Op) { ctx.VTESTPS(mxy, xy) }
 
 func (c *Context) VUCOMISD(mx, x operand.Op) {
 	if inst, err := x86.VUCOMISD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8631,7 +8631,7 @@ func VUCOMISD(mx, x operand.Op) { ctx.VUCOMISD(mx, x) }
 
 func (c *Context) VUCOMISS(mx, x operand.Op) {
 	if inst, err := x86.VUCOMISS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8640,7 +8640,7 @@ func VUCOMISS(mx, x operand.Op) { ctx.VUCOMISS(mx, x) }
 
 func (c *Context) VUNPCKHPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VUNPCKHPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8649,7 +8649,7 @@ func VUNPCKHPD(mxy, xy, xy1 operand.Op) { ctx.VUNPCKHPD(mxy, xy, xy1) }
 
 func (c *Context) VUNPCKHPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VUNPCKHPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8658,7 +8658,7 @@ func VUNPCKHPS(mxy, xy, xy1 operand.Op) { ctx.VUNPCKHPS(mxy, xy, xy1) }
 
 func (c *Context) VUNPCKLPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VUNPCKLPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8667,7 +8667,7 @@ func VUNPCKLPD(mxy, xy, xy1 operand.Op) { ctx.VUNPCKLPD(mxy, xy, xy1) }
 
 func (c *Context) VUNPCKLPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VUNPCKLPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8676,7 +8676,7 @@ func VUNPCKLPS(mxy, xy, xy1 operand.Op) { ctx.VUNPCKLPS(mxy, xy, xy1) }
 
 func (c *Context) VXORPD(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VXORPD(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8685,7 +8685,7 @@ func VXORPD(mxy, xy, xy1 operand.Op) { ctx.VXORPD(mxy, xy, xy1) }
 
 func (c *Context) VXORPS(mxy, xy, xy1 operand.Op) {
 	if inst, err := x86.VXORPS(mxy, xy, xy1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8694,7 +8694,7 @@ func VXORPS(mxy, xy, xy1 operand.Op) { ctx.VXORPS(mxy, xy, xy1) }
 
 func (c *Context) VZEROALL() {
 	if inst, err := x86.VZEROALL(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8703,7 +8703,7 @@ func VZEROALL() { ctx.VZEROALL() }
 
 func (c *Context) VZEROUPPER() {
 	if inst, err := x86.VZEROUPPER(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8712,7 +8712,7 @@ func VZEROUPPER() { ctx.VZEROUPPER() }
 
 func (c *Context) XADDB(r, mr operand.Op) {
 	if inst, err := x86.XADDB(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8721,7 +8721,7 @@ func XADDB(r, mr operand.Op) { ctx.XADDB(r, mr) }
 
 func (c *Context) XADDL(r, mr operand.Op) {
 	if inst, err := x86.XADDL(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8730,7 +8730,7 @@ func XADDL(r, mr operand.Op) { ctx.XADDL(r, mr) }
 
 func (c *Context) XADDQ(r, mr operand.Op) {
 	if inst, err := x86.XADDQ(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8739,7 +8739,7 @@ func XADDQ(r, mr operand.Op) { ctx.XADDQ(r, mr) }
 
 func (c *Context) XADDW(r, mr operand.Op) {
 	if inst, err := x86.XADDW(r, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8748,7 +8748,7 @@ func XADDW(r, mr operand.Op) { ctx.XADDW(r, mr) }
 
 func (c *Context) XCHGB(mr, mr1 operand.Op) {
 	if inst, err := x86.XCHGB(mr, mr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8757,7 +8757,7 @@ func XCHGB(mr, mr1 operand.Op) { ctx.XCHGB(mr, mr1) }
 
 func (c *Context) XCHGL(emr, emr1 operand.Op) {
 	if inst, err := x86.XCHGL(emr, emr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8766,7 +8766,7 @@ func XCHGL(emr, emr1 operand.Op) { ctx.XCHGL(emr, emr1) }
 
 func (c *Context) XCHGQ(mr, mr1 operand.Op) {
 	if inst, err := x86.XCHGQ(mr, mr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8775,7 +8775,7 @@ func XCHGQ(mr, mr1 operand.Op) { ctx.XCHGQ(mr, mr1) }
 
 func (c *Context) XCHGW(amr, amr1 operand.Op) {
 	if inst, err := x86.XCHGW(amr, amr1); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8784,7 +8784,7 @@ func XCHGW(amr, amr1 operand.Op) { ctx.XCHGW(amr, amr1) }
 
 func (c *Context) XGETBV() {
 	if inst, err := x86.XGETBV(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8793,7 +8793,7 @@ func XGETBV() { ctx.XGETBV() }
 
 func (c *Context) XLAT() {
 	if inst, err := x86.XLAT(); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8802,7 +8802,7 @@ func XLAT() { ctx.XLAT() }
 
 func (c *Context) XORB(imr, amr operand.Op) {
 	if inst, err := x86.XORB(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8811,7 +8811,7 @@ func XORB(imr, amr operand.Op) { ctx.XORB(imr, amr) }
 
 func (c *Context) XORL(imr, emr operand.Op) {
 	if inst, err := x86.XORL(imr, emr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8820,7 +8820,7 @@ func XORL(imr, emr operand.Op) { ctx.XORL(imr, emr) }
 
 func (c *Context) XORPD(mx, x operand.Op) {
 	if inst, err := x86.XORPD(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8829,7 +8829,7 @@ func XORPD(mx, x operand.Op) { ctx.XORPD(mx, x) }
 
 func (c *Context) XORPS(mx, x operand.Op) {
 	if inst, err := x86.XORPS(mx, x); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8838,7 +8838,7 @@ func XORPS(mx, x operand.Op) { ctx.XORPS(mx, x) }
 
 func (c *Context) XORQ(imr, mr operand.Op) {
 	if inst, err := x86.XORQ(imr, mr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
@@ -8847,7 +8847,7 @@ func XORQ(imr, mr operand.Op) { ctx.XORQ(imr, mr) }
 
 func (c *Context) XORW(imr, amr operand.Op) {
 	if inst, err := x86.XORW(imr, amr); err == nil {
-		c.Instruction(*inst)
+		c.Instruction(inst)
 	} else {
 		c.AddError(err)
 	}
diff --git a/internal/gen/build.go b/internal/gen/build.go
index 50f53f3..d77786c 100644
--- a/internal/gen/build.go
+++ b/internal/gen/build.go
@@ -33,7 +33,7 @@ func (b *build) instruction(i inst.Instruction) {
 	// Context method.
 	b.Printf("func (c *Context) %s(%s) {\n", i.Opcode, s.ParameterList())
 	b.Printf("if inst, err := x86.%s(%s); err == nil", i.Opcode, s.Arguments())
-	b.Printf(" { c.Instruction(*inst) }")
+	b.Printf(" { c.Instruction(inst) }")
 	b.Printf(" else { c.AddError(err) }\n")
 	b.Printf("}\n")
 
diff --git a/pass/reg.go b/pass/reg.go
new file mode 100644
index 0000000..4e64163
--- /dev/null
+++ b/pass/reg.go
@@ -0,0 +1,62 @@
+package pass
+
+import (
+	"github.com/mmcloughlin/avo"
+	"github.com/mmcloughlin/avo/reg"
+)
+
+// Liveness computes register liveness.
+func Liveness(fn *avo.Function) error {
+	is := fn.Instructions()
+
+	// Initialize to empty sets.
+	for _, i := range is {
+		i.LiveIn = map[reg.ID]bool{}
+		i.LiveOut = map[reg.ID]bool{}
+	}
+
+	// Iterative dataflow analysis.
+	for {
+		changes := false
+
+		for _, i := range is {
+			// in[n] = use[n] UNION (out[n] - def[n])
+			nin := len(i.LiveIn)
+			for _, r := range i.InputRegisters() {
+				i.LiveIn[r.ID()] = true
+			}
+			def := map[reg.ID]bool{}
+			for _, r := range i.OutputRegisters() {
+				def[r.ID()] = true
+			}
+			for id := range i.LiveOut {
+				if !def[id] {
+					i.LiveIn[id] = true
+				}
+			}
+			if len(i.LiveIn) != nin {
+				changes = true
+			}
+
+			// out[n] = UNION[s IN succ[n]] in[s]
+			nout := len(i.LiveOut)
+			for _, s := range i.Succ {
+				if s == nil {
+					continue
+				}
+				for id := range s.LiveIn {
+					i.LiveOut[id] = true
+				}
+			}
+			if len(i.LiveOut) != nout {
+				changes = true
+			}
+		}
+
+		if !changes {
+			break
+		}
+	}
+
+	return nil
+}
diff --git a/printer.go b/printer.go
index fa97a7d..ad9c2e4 100644
--- a/printer.go
+++ b/printer.go
@@ -73,7 +73,7 @@ func (p *GoPrinter) function(f *Function) {
 
 	for _, node := range f.Nodes {
 		switch n := node.(type) {
-		case Instruction:
+		case *Instruction:
 			p.printf("\t%s\t%s\n", n.Opcode, joinOperands(n.Operands))
 		case Label:
 			p.printf("%s:\n", n)
diff --git a/reg/reg_test.go b/reg/reg_test.go
index bc05a7a..9243039 100644
--- a/reg/reg_test.go
+++ b/reg/reg_test.go
@@ -22,3 +22,15 @@ func TestSpecBytes(t *testing.T) {
 		}
 	}
 }
+
+func TestVirtualPhysicalHaveDifferentIDs(t *testing.T) {
+	// Confirm that ID() returns different results even when virtual and physical IDs are the same.
+	var v Virtual = virtual{id: 42}
+	var p Physical = register{id: 42}
+	if uint16(v.VirtualID()) != uint16(p.PhysicalID()) {
+		t.Fatal("test assumption violated: VirtualID and PhysicalID should agree")
+	}
+	if v.ID() == p.ID() {
+		t.Errorf("virtual and physical IDs should be different")
+	}
+}
diff --git a/reg/types.go b/reg/types.go
index 792092e..1400a0c 100644
--- a/reg/types.go
+++ b/reg/types.go
@@ -1,6 +1,9 @@
 package reg
 
-import "fmt"
+import (
+	"fmt"
+	"math"
+)
 
 type Size uint
 
@@ -23,7 +26,7 @@ type Family struct {
 	registers []Physical
 }
 
-func (f *Family) define(s Spec, id uint16, name string) Physical {
+func (f *Family) define(s Spec, id PID, name string) Physical {
 	r := register{
 		id:   id,
 		kind: f.Kind,
@@ -34,7 +37,7 @@ func (f *Family) define(s Spec, id uint16, name string) Physical {
 	return r
 }
 
-func (f *Family) Virtual(id uint16, s Size) Virtual {
+func (f *Family) Virtual(id VID, s Size) Virtual {
 	return virtual{
 		id:   id,
 		kind: f.Kind,
@@ -46,7 +49,14 @@ type private interface {
 	private()
 }
 
+type (
+	ID  uint32
+	VID uint16
+	PID uint16
+)
+
 type Register interface {
+	ID() ID
 	Kind() Kind
 	Bytes() uint
 	Asm() string
@@ -54,18 +64,22 @@ type Register interface {
 }
 
 type Virtual interface {
-	VirtualID() uint16
+	VirtualID() VID
 	Register
 }
 
 type virtual struct {
-	id   uint16
+	id   VID
 	kind Kind
 	Size
 }
 
-func (v virtual) VirtualID() uint16 { return v.id }
-func (v virtual) Kind() Kind        { return v.kind }
+func (v virtual) VirtualID() VID { return v.id }
+func (v virtual) Kind() Kind     { return v.kind }
+
+func (v virtual) ID() ID {
+	return (ID(math.MaxUint16) << 16) | ID(v.VirtualID())
+}
 
 func (v virtual) Asm() string {
 	// TODO(mbm): decide on virtual register syntax
@@ -75,22 +89,23 @@ func (v virtual) Asm() string {
 func (v virtual) private() {}
 
 type Physical interface {
-	PhysicalID() uint16
+	PhysicalID() PID
 	Mask() uint16
 	Register
 }
 
 type register struct {
-	id   uint16
+	id   PID
 	kind Kind
 	name string
 	Spec
 }
 
-func (r register) PhysicalID() uint16 { return r.id }
-func (r register) Kind() Kind         { return r.kind }
-func (r register) Asm() string        { return r.name }
-func (r register) private()           {}
+func (r register) PhysicalID() PID { return r.id }
+func (r register) ID() ID          { return ID(r.id) }
+func (r register) Kind() Kind      { return r.kind }
+func (r register) Asm() string     { return r.name }
+func (r register) private()        {}
 
 type Spec uint16