cmd/compile: remove chunking of rewrite rules

We added chunking of rewrite rules to speed up compiling package SSA.
This series of changes has significantly shrunk the number of
rewrite rules, and they are no longer being added nearly as fast.
Now that we are sharing v.Args across multiple rewrite rules,
there is additional benefit to having more rules in a single function.
Removing chunking now has an incidental impact on compiling package SSA,
marginally speeds up other compilation, shrinks the cmd/compile binary,
and simplifies the code.

name        old time/op       new time/op       delta
Template          211ms ± 2%        210ms ± 2%  -0.50%  (p=0.000 n=91+97)
Unicode          81.9ms ± 3%       81.8ms ± 3%    ~     (p=0.179 n=96+91)
GoTypes           731ms ± 2%        731ms ± 1%    ~     (p=0.442 n=94+96)
Compiler          3.43s ± 2%        3.41s ± 2%  -0.36%  (p=0.001 n=98+94)
SSA               8.30s ± 2%        8.32s ± 2%  +0.19%  (p=0.034 n=94+95)
Flate             135ms ± 2%        134ms ± 1%  -0.30%  (p=0.006 n=98+94)
GoParser          167ms ± 1%        167ms ± 1%  -0.22%  (p=0.001 n=92+94)
Reflect           453ms ± 2%        453ms ± 3%    ~     (p=0.306 n=98+97)
Tar               184ms ± 2%        183ms ± 2%  -0.31%  (p=0.012 n=94+94)
XML               249ms ± 2%        248ms ± 1%  -0.26%  (p=0.002 n=96+92)
[Geo mean]        419ms             418ms       -0.21%

name        old user-time/op  new user-time/op  delta
Template          273ms ± 2%        272ms ± 2%  -0.46%  (p=0.000 n=93+96)
Unicode           116ms ± 4%        117ms ± 4%    ~     (p=0.433 n=98+98)
GoTypes           977ms ± 2%        977ms ± 1%    ~     (p=0.971 n=92+99)
Compiler          4.56s ± 6%        4.53s ± 6%    ~     (p=0.081 n=100+100)
SSA               11.1s ± 2%        11.1s ± 2%    ~     (p=0.064 n=99+96)
Flate             167ms ± 2%        167ms ± 1%  -0.24%  (p=0.004 n=95+96)
GoParser          203ms ± 1%        203ms ± 2%  -0.14%  (p=0.049 n=96+97)
Reflect           595ms ± 2%        595ms ± 2%    ~     (p=0.544 n=95+92)
Tar               225ms ± 2%        224ms ± 2%    ~     (p=0.562 n=99+99)
XML               312ms ± 2%        311ms ± 1%    ~     (p=0.050 n=97+93)
[Geo mean]        543ms             542ms       -0.13%

Change-Id: I8d34ab59f154b28f20c6f9e416b976bfce339baa
Reviewed-on: https://go-review.googlesource.com/c/go/+/216220
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

1 files changed, 516 insertions, 535 deletions

diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 47adca632e..3058ecb677 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -8,523 +8,523 @@ import "cmd/compile/internal/types"
 func rewriteValueMIPS(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValueMIPS_OpAdd16_0(v)
+		return rewriteValueMIPS_OpAdd16(v)
 	case OpAdd32:
-		return rewriteValueMIPS_OpAdd32_0(v)
+		return rewriteValueMIPS_OpAdd32(v)
 	case OpAdd32F:
-		return rewriteValueMIPS_OpAdd32F_0(v)
+		return rewriteValueMIPS_OpAdd32F(v)
 	case OpAdd32withcarry:
-		return rewriteValueMIPS_OpAdd32withcarry_0(v)
+		return rewriteValueMIPS_OpAdd32withcarry(v)
 	case OpAdd64F:
-		return rewriteValueMIPS_OpAdd64F_0(v)
+		return rewriteValueMIPS_OpAdd64F(v)
 	case OpAdd8:
-		return rewriteValueMIPS_OpAdd8_0(v)
+		return rewriteValueMIPS_OpAdd8(v)
 	case OpAddPtr:
-		return rewriteValueMIPS_OpAddPtr_0(v)
+		return rewriteValueMIPS_OpAddPtr(v)
 	case OpAddr:
-		return rewriteValueMIPS_OpAddr_0(v)
+		return rewriteValueMIPS_OpAddr(v)
 	case OpAnd16:
-		return rewriteValueMIPS_OpAnd16_0(v)
+		return rewriteValueMIPS_OpAnd16(v)
 	case OpAnd32:
-		return rewriteValueMIPS_OpAnd32_0(v)
+		return rewriteValueMIPS_OpAnd32(v)
 	case OpAnd8:
-		return rewriteValueMIPS_OpAnd8_0(v)
+		return rewriteValueMIPS_OpAnd8(v)
 	case OpAndB:
-		return rewriteValueMIPS_OpAndB_0(v)
+		return rewriteValueMIPS_OpAndB(v)
 	case OpAtomicAdd32:
-		return rewriteValueMIPS_OpAtomicAdd32_0(v)
+		return rewriteValueMIPS_OpAtomicAdd32(v)
 	case OpAtomicAnd8:
-		return rewriteValueMIPS_OpAtomicAnd8_0(v)
+		return rewriteValueMIPS_OpAtomicAnd8(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v)
+		return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
 	case OpAtomicExchange32:
-		return rewriteValueMIPS_OpAtomicExchange32_0(v)
+		return rewriteValueMIPS_OpAtomicExchange32(v)
 	case OpAtomicLoad32:
-		return rewriteValueMIPS_OpAtomicLoad32_0(v)
+		return rewriteValueMIPS_OpAtomicLoad32(v)
 	case OpAtomicLoad8:
-		return rewriteValueMIPS_OpAtomicLoad8_0(v)
+		return rewriteValueMIPS_OpAtomicLoad8(v)
 	case OpAtomicLoadPtr:
-		return rewriteValueMIPS_OpAtomicLoadPtr_0(v)
+		return rewriteValueMIPS_OpAtomicLoadPtr(v)
 	case OpAtomicOr8:
-		return rewriteValueMIPS_OpAtomicOr8_0(v)
+		return rewriteValueMIPS_OpAtomicOr8(v)
 	case OpAtomicStore32:
-		return rewriteValueMIPS_OpAtomicStore32_0(v)
+		return rewriteValueMIPS_OpAtomicStore32(v)
 	case OpAtomicStore8:
-		return rewriteValueMIPS_OpAtomicStore8_0(v)
+		return rewriteValueMIPS_OpAtomicStore8(v)
 	case OpAtomicStorePtrNoWB:
-		return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v)
+		return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
 	case OpAvg32u:
-		return rewriteValueMIPS_OpAvg32u_0(v)
+		return rewriteValueMIPS_OpAvg32u(v)
 	case OpBitLen32:
-		return rewriteValueMIPS_OpBitLen32_0(v)
+		return rewriteValueMIPS_OpBitLen32(v)
 	case OpClosureCall:
-		return rewriteValueMIPS_OpClosureCall_0(v)
+		return rewriteValueMIPS_OpClosureCall(v)
 	case OpCom16:
-		return rewriteValueMIPS_OpCom16_0(v)
+		return rewriteValueMIPS_OpCom16(v)
 	case OpCom32:
-		return rewriteValueMIPS_OpCom32_0(v)
+		return rewriteValueMIPS_OpCom32(v)
 	case OpCom8:
-		return rewriteValueMIPS_OpCom8_0(v)
+		return rewriteValueMIPS_OpCom8(v)
 	case OpConst16:
-		return rewriteValueMIPS_OpConst16_0(v)
+		return rewriteValueMIPS_OpConst16(v)
 	case OpConst32:
-		return rewriteValueMIPS_OpConst32_0(v)
+		return rewriteValueMIPS_OpConst32(v)
 	case OpConst32F:
-		return rewriteValueMIPS_OpConst32F_0(v)
+		return rewriteValueMIPS_OpConst32F(v)
 	case OpConst64F:
-		return rewriteValueMIPS_OpConst64F_0(v)
+		return rewriteValueMIPS_OpConst64F(v)
 	case OpConst8:
-		return rewriteValueMIPS_OpConst8_0(v)
+		return rewriteValueMIPS_OpConst8(v)
 	case OpConstBool:
-		return rewriteValueMIPS_OpConstBool_0(v)
+		return rewriteValueMIPS_OpConstBool(v)
 	case OpConstNil:
-		return rewriteValueMIPS_OpConstNil_0(v)
+		return rewriteValueMIPS_OpConstNil(v)
 	case OpCtz32:
-		return rewriteValueMIPS_OpCtz32_0(v)
+		return rewriteValueMIPS_OpCtz32(v)
 	case OpCtz32NonZero:
-		return rewriteValueMIPS_OpCtz32NonZero_0(v)
+		return rewriteValueMIPS_OpCtz32NonZero(v)
 	case OpCvt32Fto32:
-		return rewriteValueMIPS_OpCvt32Fto32_0(v)
+		return rewriteValueMIPS_OpCvt32Fto32(v)
 	case OpCvt32Fto64F:
-		return rewriteValueMIPS_OpCvt32Fto64F_0(v)
+		return rewriteValueMIPS_OpCvt32Fto64F(v)
 	case OpCvt32to32F:
-		return rewriteValueMIPS_OpCvt32to32F_0(v)
+		return rewriteValueMIPS_OpCvt32to32F(v)
 	case OpCvt32to64F:
-		return rewriteValueMIPS_OpCvt32to64F_0(v)
+		return rewriteValueMIPS_OpCvt32to64F(v)
 	case OpCvt64Fto32:
-		return rewriteValueMIPS_OpCvt64Fto32_0(v)
+		return rewriteValueMIPS_OpCvt64Fto32(v)
 	case OpCvt64Fto32F:
-		return rewriteValueMIPS_OpCvt64Fto32F_0(v)
+		return rewriteValueMIPS_OpCvt64Fto32F(v)
 	case OpDiv16:
-		return rewriteValueMIPS_OpDiv16_0(v)
+		return rewriteValueMIPS_OpDiv16(v)
 	case OpDiv16u:
-		return rewriteValueMIPS_OpDiv16u_0(v)
+		return rewriteValueMIPS_OpDiv16u(v)
 	case OpDiv32:
-		return rewriteValueMIPS_OpDiv32_0(v)
+		return rewriteValueMIPS_OpDiv32(v)
 	case OpDiv32F:
-		return rewriteValueMIPS_OpDiv32F_0(v)
+		return rewriteValueMIPS_OpDiv32F(v)
 	case OpDiv32u:
-		return rewriteValueMIPS_OpDiv32u_0(v)
+		return rewriteValueMIPS_OpDiv32u(v)
 	case OpDiv64F:
-		return rewriteValueMIPS_OpDiv64F_0(v)
+		return rewriteValueMIPS_OpDiv64F(v)
 	case OpDiv8:
-		return rewriteValueMIPS_OpDiv8_0(v)
+		return rewriteValueMIPS_OpDiv8(v)
 	case OpDiv8u:
-		return rewriteValueMIPS_OpDiv8u_0(v)
+		return rewriteValueMIPS_OpDiv8u(v)
 	case OpEq16:
-		return rewriteValueMIPS_OpEq16_0(v)
+		return rewriteValueMIPS_OpEq16(v)
 	case OpEq32:
-		return rewriteValueMIPS_OpEq32_0(v)
+		return rewriteValueMIPS_OpEq32(v)
 	case OpEq32F:
-		return rewriteValueMIPS_OpEq32F_0(v)
+		return rewriteValueMIPS_OpEq32F(v)
 	case OpEq64F:
-		return rewriteValueMIPS_OpEq64F_0(v)
+		return rewriteValueMIPS_OpEq64F(v)
 	case OpEq8:
-		return rewriteValueMIPS_OpEq8_0(v)
+		return rewriteValueMIPS_OpEq8(v)
 	case OpEqB:
-		return rewriteValueMIPS_OpEqB_0(v)
+		return rewriteValueMIPS_OpEqB(v)
 	case OpEqPtr:
-		return rewriteValueMIPS_OpEqPtr_0(v)
+		return rewriteValueMIPS_OpEqPtr(v)
 	case OpGeq16:
-		return rewriteValueMIPS_OpGeq16_0(v)
+		return rewriteValueMIPS_OpGeq16(v)
 	case OpGeq16U:
-		return rewriteValueMIPS_OpGeq16U_0(v)
+		return rewriteValueMIPS_OpGeq16U(v)
 	case OpGeq32:
-		return rewriteValueMIPS_OpGeq32_0(v)
+		return rewriteValueMIPS_OpGeq32(v)
 	case OpGeq32F:
-		return rewriteValueMIPS_OpGeq32F_0(v)
+		return rewriteValueMIPS_OpGeq32F(v)
 	case OpGeq32U:
-		return rewriteValueMIPS_OpGeq32U_0(v)
+		return rewriteValueMIPS_OpGeq32U(v)
 	case OpGeq64F:
-		return rewriteValueMIPS_OpGeq64F_0(v)
+		return rewriteValueMIPS_OpGeq64F(v)
 	case OpGeq8:
-		return rewriteValueMIPS_OpGeq8_0(v)
+		return rewriteValueMIPS_OpGeq8(v)
 	case OpGeq8U:
-		return rewriteValueMIPS_OpGeq8U_0(v)
+		return rewriteValueMIPS_OpGeq8U(v)
 	case OpGetCallerPC:
-		return rewriteValueMIPS_OpGetCallerPC_0(v)
+		return rewriteValueMIPS_OpGetCallerPC(v)
 	case OpGetCallerSP:
-		return rewriteValueMIPS_OpGetCallerSP_0(v)
+		return rewriteValueMIPS_OpGetCallerSP(v)
 	case OpGetClosurePtr:
-		return rewriteValueMIPS_OpGetClosurePtr_0(v)
+		return rewriteValueMIPS_OpGetClosurePtr(v)
 	case OpGreater16:
-		return rewriteValueMIPS_OpGreater16_0(v)
+		return rewriteValueMIPS_OpGreater16(v)
 	case OpGreater16U:
-		return rewriteValueMIPS_OpGreater16U_0(v)
+		return rewriteValueMIPS_OpGreater16U(v)
 	case OpGreater32:
-		return rewriteValueMIPS_OpGreater32_0(v)
+		return rewriteValueMIPS_OpGreater32(v)
 	case OpGreater32F:
-		return rewriteValueMIPS_OpGreater32F_0(v)
+		return rewriteValueMIPS_OpGreater32F(v)
 	case OpGreater32U:
-		return rewriteValueMIPS_OpGreater32U_0(v)
+		return rewriteValueMIPS_OpGreater32U(v)
 	case OpGreater64F:
-		return rewriteValueMIPS_OpGreater64F_0(v)
+		return rewriteValueMIPS_OpGreater64F(v)
 	case OpGreater8:
-		return rewriteValueMIPS_OpGreater8_0(v)
+		return rewriteValueMIPS_OpGreater8(v)
 	case OpGreater8U:
-		return rewriteValueMIPS_OpGreater8U_0(v)
+		return rewriteValueMIPS_OpGreater8U(v)
 	case OpHmul32:
-		return rewriteValueMIPS_OpHmul32_0(v)
+		return rewriteValueMIPS_OpHmul32(v)
 	case OpHmul32u:
-		return rewriteValueMIPS_OpHmul32u_0(v)
+		return rewriteValueMIPS_OpHmul32u(v)
 	case OpInterCall:
-		return rewriteValueMIPS_OpInterCall_0(v)
+		return rewriteValueMIPS_OpInterCall(v)
 	case OpIsInBounds:
-		return rewriteValueMIPS_OpIsInBounds_0(v)
+		return rewriteValueMIPS_OpIsInBounds(v)
 	case OpIsNonNil:
-		return rewriteValueMIPS_OpIsNonNil_0(v)
+		return rewriteValueMIPS_OpIsNonNil(v)
 	case OpIsSliceInBounds:
-		return rewriteValueMIPS_OpIsSliceInBounds_0(v)
+		return rewriteValueMIPS_OpIsSliceInBounds(v)
 	case OpLeq16:
-		return rewriteValueMIPS_OpLeq16_0(v)
+		return rewriteValueMIPS_OpLeq16(v)
 	case OpLeq16U:
-		return rewriteValueMIPS_OpLeq16U_0(v)
+		return rewriteValueMIPS_OpLeq16U(v)
 	case OpLeq32:
-		return rewriteValueMIPS_OpLeq32_0(v)
+		return rewriteValueMIPS_OpLeq32(v)
 	case OpLeq32F:
-		return rewriteValueMIPS_OpLeq32F_0(v)
+		return rewriteValueMIPS_OpLeq32F(v)
 	case OpLeq32U:
-		return rewriteValueMIPS_OpLeq32U_0(v)
+		return rewriteValueMIPS_OpLeq32U(v)
 	case OpLeq64F:
-		return rewriteValueMIPS_OpLeq64F_0(v)
+		return rewriteValueMIPS_OpLeq64F(v)
 	case OpLeq8:
-		return rewriteValueMIPS_OpLeq8_0(v)
+		return rewriteValueMIPS_OpLeq8(v)
 	case OpLeq8U:
-		return rewriteValueMIPS_OpLeq8U_0(v)
+		return rewriteValueMIPS_OpLeq8U(v)
 	case OpLess16:
-		return rewriteValueMIPS_OpLess16_0(v)
+		return rewriteValueMIPS_OpLess16(v)
 	case OpLess16U:
-		return rewriteValueMIPS_OpLess16U_0(v)
+		return rewriteValueMIPS_OpLess16U(v)
 	case OpLess32:
-		return rewriteValueMIPS_OpLess32_0(v)
+		return rewriteValueMIPS_OpLess32(v)
 	case OpLess32F:
-		return rewriteValueMIPS_OpLess32F_0(v)
+		return rewriteValueMIPS_OpLess32F(v)
 	case OpLess32U:
-		return rewriteValueMIPS_OpLess32U_0(v)
+		return rewriteValueMIPS_OpLess32U(v)
 	case OpLess64F:
-		return rewriteValueMIPS_OpLess64F_0(v)
+		return rewriteValueMIPS_OpLess64F(v)
 	case OpLess8:
-		return rewriteValueMIPS_OpLess8_0(v)
+		return rewriteValueMIPS_OpLess8(v)
 	case OpLess8U:
-		return rewriteValueMIPS_OpLess8U_0(v)
+		return rewriteValueMIPS_OpLess8U(v)
 	case OpLoad:
-		return rewriteValueMIPS_OpLoad_0(v)
+		return rewriteValueMIPS_OpLoad(v)
 	case OpLocalAddr:
-		return rewriteValueMIPS_OpLocalAddr_0(v)
+		return rewriteValueMIPS_OpLocalAddr(v)
 	case OpLsh16x16:
-		return rewriteValueMIPS_OpLsh16x16_0(v)
+		return rewriteValueMIPS_OpLsh16x16(v)
 	case OpLsh16x32:
-		return rewriteValueMIPS_OpLsh16x32_0(v)
+		return rewriteValueMIPS_OpLsh16x32(v)
 	case OpLsh16x64:
-		return rewriteValueMIPS_OpLsh16x64_0(v)
+		return rewriteValueMIPS_OpLsh16x64(v)
 	case OpLsh16x8:
-		return rewriteValueMIPS_OpLsh16x8_0(v)
+		return rewriteValueMIPS_OpLsh16x8(v)
 	case OpLsh32x16:
-		return rewriteValueMIPS_OpLsh32x16_0(v)
+		return rewriteValueMIPS_OpLsh32x16(v)
 	case OpLsh32x32:
-		return rewriteValueMIPS_OpLsh32x32_0(v)
+		return rewriteValueMIPS_OpLsh32x32(v)
 	case OpLsh32x64:
-		return rewriteValueMIPS_OpLsh32x64_0(v)
+		return rewriteValueMIPS_OpLsh32x64(v)
 	case OpLsh32x8:
-		return rewriteValueMIPS_OpLsh32x8_0(v)
+		return rewriteValueMIPS_OpLsh32x8(v)
 	case OpLsh8x16:
-		return rewriteValueMIPS_OpLsh8x16_0(v)
+		return rewriteValueMIPS_OpLsh8x16(v)
 	case OpLsh8x32:
-		return rewriteValueMIPS_OpLsh8x32_0(v)
+		return rewriteValueMIPS_OpLsh8x32(v)
 	case OpLsh8x64:
-		return rewriteValueMIPS_OpLsh8x64_0(v)
+		return rewriteValueMIPS_OpLsh8x64(v)
 	case OpLsh8x8:
-		return rewriteValueMIPS_OpLsh8x8_0(v)
+		return rewriteValueMIPS_OpLsh8x8(v)
 	case OpMIPSADD:
-		return rewriteValueMIPS_OpMIPSADD_0(v)
+		return rewriteValueMIPS_OpMIPSADD(v)
 	case OpMIPSADDconst:
-		return rewriteValueMIPS_OpMIPSADDconst_0(v)
+		return rewriteValueMIPS_OpMIPSADDconst(v)
 	case OpMIPSAND:
-		return rewriteValueMIPS_OpMIPSAND_0(v)
+		return rewriteValueMIPS_OpMIPSAND(v)
 	case OpMIPSANDconst:
-		return rewriteValueMIPS_OpMIPSANDconst_0(v)
+		return rewriteValueMIPS_OpMIPSANDconst(v)
 	case OpMIPSCMOVZ:
-		return rewriteValueMIPS_OpMIPSCMOVZ_0(v)
+		return rewriteValueMIPS_OpMIPSCMOVZ(v)
 	case OpMIPSCMOVZzero:
-		return rewriteValueMIPS_OpMIPSCMOVZzero_0(v)
+		return rewriteValueMIPS_OpMIPSCMOVZzero(v)
 	case OpMIPSLoweredAtomicAdd:
-		return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v)
+		return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
 	case OpMIPSLoweredAtomicStore32:
-		return rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v)
+		return rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v)
 	case OpMIPSMOVBUload:
-		return rewriteValueMIPS_OpMIPSMOVBUload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBUload(v)
 	case OpMIPSMOVBUreg:
-		return rewriteValueMIPS_OpMIPSMOVBUreg_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBUreg(v)
 	case OpMIPSMOVBload:
-		return rewriteValueMIPS_OpMIPSMOVBload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBload(v)
 	case OpMIPSMOVBreg:
-		return rewriteValueMIPS_OpMIPSMOVBreg_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBreg(v)
 	case OpMIPSMOVBstore:
-		return rewriteValueMIPS_OpMIPSMOVBstore_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBstore(v)
 	case OpMIPSMOVBstorezero:
-		return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v)
+		return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
 	case OpMIPSMOVDload:
-		return rewriteValueMIPS_OpMIPSMOVDload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVDload(v)
 	case OpMIPSMOVDstore:
-		return rewriteValueMIPS_OpMIPSMOVDstore_0(v)
+		return rewriteValueMIPS_OpMIPSMOVDstore(v)
 	case OpMIPSMOVFload:
-		return rewriteValueMIPS_OpMIPSMOVFload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVFload(v)
 	case OpMIPSMOVFstore:
-		return rewriteValueMIPS_OpMIPSMOVFstore_0(v)
+		return rewriteValueMIPS_OpMIPSMOVFstore(v)
 	case OpMIPSMOVHUload:
-		return rewriteValueMIPS_OpMIPSMOVHUload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHUload(v)
 	case OpMIPSMOVHUreg:
-		return rewriteValueMIPS_OpMIPSMOVHUreg_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHUreg(v)
 	case OpMIPSMOVHload:
-		return rewriteValueMIPS_OpMIPSMOVHload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHload(v)
 	case OpMIPSMOVHreg:
-		return rewriteValueMIPS_OpMIPSMOVHreg_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHreg(v)
 	case OpMIPSMOVHstore:
-		return rewriteValueMIPS_OpMIPSMOVHstore_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHstore(v)
 	case OpMIPSMOVHstorezero:
-		return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v)
+		return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
 	case OpMIPSMOVWload:
-		return rewriteValueMIPS_OpMIPSMOVWload_0(v)
+		return rewriteValueMIPS_OpMIPSMOVWload(v)
 	case OpMIPSMOVWreg:
-		return rewriteValueMIPS_OpMIPSMOVWreg_0(v)
+		return rewriteValueMIPS_OpMIPSMOVWreg(v)
 	case OpMIPSMOVWstore:
-		return rewriteValueMIPS_OpMIPSMOVWstore_0(v)
+		return rewriteValueMIPS_OpMIPSMOVWstore(v)
 	case OpMIPSMOVWstorezero:
-		return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v)
+		return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
 	case OpMIPSMUL:
-		return rewriteValueMIPS_OpMIPSMUL_0(v)
+		return rewriteValueMIPS_OpMIPSMUL(v)
 	case OpMIPSNEG:
-		return rewriteValueMIPS_OpMIPSNEG_0(v)
+		return rewriteValueMIPS_OpMIPSNEG(v)
 	case OpMIPSNOR:
-		return rewriteValueMIPS_OpMIPSNOR_0(v)
+		return rewriteValueMIPS_OpMIPSNOR(v)
 	case OpMIPSNORconst:
-		return rewriteValueMIPS_OpMIPSNORconst_0(v)
+		return rewriteValueMIPS_OpMIPSNORconst(v)
 	case OpMIPSOR:
-		return rewriteValueMIPS_OpMIPSOR_0(v)
+		return rewriteValueMIPS_OpMIPSOR(v)
 	case OpMIPSORconst:
-		return rewriteValueMIPS_OpMIPSORconst_0(v)
+		return rewriteValueMIPS_OpMIPSORconst(v)
 	case OpMIPSSGT:
-		return rewriteValueMIPS_OpMIPSSGT_0(v)
+		return rewriteValueMIPS_OpMIPSSGT(v)
 	case OpMIPSSGTU:
-		return rewriteValueMIPS_OpMIPSSGTU_0(v)
+		return rewriteValueMIPS_OpMIPSSGTU(v)
 	case OpMIPSSGTUconst:
-		return rewriteValueMIPS_OpMIPSSGTUconst_0(v)
+		return rewriteValueMIPS_OpMIPSSGTUconst(v)
 	case OpMIPSSGTUzero:
-		return rewriteValueMIPS_OpMIPSSGTUzero_0(v)
+		return rewriteValueMIPS_OpMIPSSGTUzero(v)
 	case OpMIPSSGTconst:
-		return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v)
+		return rewriteValueMIPS_OpMIPSSGTconst(v)
 	case OpMIPSSGTzero:
-		return rewriteValueMIPS_OpMIPSSGTzero_0(v)
+		return rewriteValueMIPS_OpMIPSSGTzero(v)
 	case OpMIPSSLL:
-		return rewriteValueMIPS_OpMIPSSLL_0(v)
+		return rewriteValueMIPS_OpMIPSSLL(v)
 	case OpMIPSSLLconst:
-		return rewriteValueMIPS_OpMIPSSLLconst_0(v)
+		return rewriteValueMIPS_OpMIPSSLLconst(v)
 	case OpMIPSSRA:
-		return rewriteValueMIPS_OpMIPSSRA_0(v)
+		return rewriteValueMIPS_OpMIPSSRA(v)
 	case OpMIPSSRAconst:
-		return rewriteValueMIPS_OpMIPSSRAconst_0(v)
+		return rewriteValueMIPS_OpMIPSSRAconst(v)
 	case OpMIPSSRL:
-		return rewriteValueMIPS_OpMIPSSRL_0(v)
+		return rewriteValueMIPS_OpMIPSSRL(v)
 	case OpMIPSSRLconst:
-		return rewriteValueMIPS_OpMIPSSRLconst_0(v)
+		return rewriteValueMIPS_OpMIPSSRLconst(v)
 	case OpMIPSSUB:
-		return rewriteValueMIPS_OpMIPSSUB_0(v)
+		return rewriteValueMIPS_OpMIPSSUB(v)
 	case OpMIPSSUBconst:
-		return rewriteValueMIPS_OpMIPSSUBconst_0(v)
+		return rewriteValueMIPS_OpMIPSSUBconst(v)
 	case OpMIPSXOR:
-		return rewriteValueMIPS_OpMIPSXOR_0(v)
+		return rewriteValueMIPS_OpMIPSXOR(v)
 	case OpMIPSXORconst:
-		return rewriteValueMIPS_OpMIPSXORconst_0(v)
+		return rewriteValueMIPS_OpMIPSXORconst(v)
 	case OpMod16:
-		return rewriteValueMIPS_OpMod16_0(v)
+		return rewriteValueMIPS_OpMod16(v)
 	case OpMod16u:
-		return rewriteValueMIPS_OpMod16u_0(v)
+		return rewriteValueMIPS_OpMod16u(v)
 	case OpMod32:
-		return rewriteValueMIPS_OpMod32_0(v)
+		return rewriteValueMIPS_OpMod32(v)
 	case OpMod32u:
-		return rewriteValueMIPS_OpMod32u_0(v)
+		return rewriteValueMIPS_OpMod32u(v)
 	case OpMod8:
-		return rewriteValueMIPS_OpMod8_0(v)
+		return rewriteValueMIPS_OpMod8(v)
 	case OpMod8u:
-		return rewriteValueMIPS_OpMod8u_0(v)
+		return rewriteValueMIPS_OpMod8u(v)
 	case OpMove:
-		return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v)
+		return rewriteValueMIPS_OpMove(v)
 	case OpMul16:
-		return rewriteValueMIPS_OpMul16_0(v)
+		return rewriteValueMIPS_OpMul16(v)
 	case OpMul32:
-		return rewriteValueMIPS_OpMul32_0(v)
+		return rewriteValueMIPS_OpMul32(v)
 	case OpMul32F:
-		return rewriteValueMIPS_OpMul32F_0(v)
+		return rewriteValueMIPS_OpMul32F(v)
 	case OpMul32uhilo:
-		return rewriteValueMIPS_OpMul32uhilo_0(v)
+		return rewriteValueMIPS_OpMul32uhilo(v)
 	case OpMul64F:
-		return rewriteValueMIPS_OpMul64F_0(v)
+		return rewriteValueMIPS_OpMul64F(v)
 	case OpMul8:
-		return rewriteValueMIPS_OpMul8_0(v)
+		return rewriteValueMIPS_OpMul8(v)
 	case OpNeg16:
-		return rewriteValueMIPS_OpNeg16_0(v)
+		return rewriteValueMIPS_OpNeg16(v)
 	case OpNeg32:
-		return rewriteValueMIPS_OpNeg32_0(v)
+		return rewriteValueMIPS_OpNeg32(v)
 	case OpNeg32F:
-		return rewriteValueMIPS_OpNeg32F_0(v)
+		return rewriteValueMIPS_OpNeg32F(v)
 	case OpNeg64F:
-		return rewriteValueMIPS_OpNeg64F_0(v)
+		return rewriteValueMIPS_OpNeg64F(v)
 	case OpNeg8:
-		return rewriteValueMIPS_OpNeg8_0(v)
+		return rewriteValueMIPS_OpNeg8(v)
 	case OpNeq16:
-		return rewriteValueMIPS_OpNeq16_0(v)
+		return rewriteValueMIPS_OpNeq16(v)
 	case OpNeq32:
-		return rewriteValueMIPS_OpNeq32_0(v)
+		return rewriteValueMIPS_OpNeq32(v)
 	case OpNeq32F:
-		return rewriteValueMIPS_OpNeq32F_0(v)
+		return rewriteValueMIPS_OpNeq32F(v)
 	case OpNeq64F:
-		return rewriteValueMIPS_OpNeq64F_0(v)
+		return rewriteValueMIPS_OpNeq64F(v)
 	case OpNeq8:
-		return rewriteValueMIPS_OpNeq8_0(v)
+		return rewriteValueMIPS_OpNeq8(v)
 	case OpNeqB:
-		return rewriteValueMIPS_OpNeqB_0(v)
+		return rewriteValueMIPS_OpNeqB(v)
 	case OpNeqPtr:
-		return rewriteValueMIPS_OpNeqPtr_0(v)
+		return rewriteValueMIPS_OpNeqPtr(v)
 	case OpNilCheck:
-		return rewriteValueMIPS_OpNilCheck_0(v)
+		return rewriteValueMIPS_OpNilCheck(v)
 	case OpNot:
-		return rewriteValueMIPS_OpNot_0(v)
+		return rewriteValueMIPS_OpNot(v)
 	case OpOffPtr:
-		return rewriteValueMIPS_OpOffPtr_0(v)
+		return rewriteValueMIPS_OpOffPtr(v)
 	case OpOr16:
-		return rewriteValueMIPS_OpOr16_0(v)
+		return rewriteValueMIPS_OpOr16(v)
 	case OpOr32:
-		return rewriteValueMIPS_OpOr32_0(v)
+		return rewriteValueMIPS_OpOr32(v)
 	case OpOr8:
-		return rewriteValueMIPS_OpOr8_0(v)
+		return rewriteValueMIPS_OpOr8(v)
 	case OpOrB:
-		return rewriteValueMIPS_OpOrB_0(v)
+		return rewriteValueMIPS_OpOrB(v)
 	case OpPanicBounds:
-		return rewriteValueMIPS_OpPanicBounds_0(v)
+		return rewriteValueMIPS_OpPanicBounds(v)
 	case OpPanicExtend:
-		return rewriteValueMIPS_OpPanicExtend_0(v)
+		return rewriteValueMIPS_OpPanicExtend(v)
 	case OpRotateLeft16:
-		return rewriteValueMIPS_OpRotateLeft16_0(v)
+		return rewriteValueMIPS_OpRotateLeft16(v)
 	case OpRotateLeft32:
-		return rewriteValueMIPS_OpRotateLeft32_0(v)
+		return rewriteValueMIPS_OpRotateLeft32(v)
 	case OpRotateLeft64:
-		return rewriteValueMIPS_OpRotateLeft64_0(v)
+		return rewriteValueMIPS_OpRotateLeft64(v)
 	case OpRotateLeft8:
-		return rewriteValueMIPS_OpRotateLeft8_0(v)
+		return rewriteValueMIPS_OpRotateLeft8(v)
 	case OpRound32F:
-		return rewriteValueMIPS_OpRound32F_0(v)
+		return rewriteValueMIPS_OpRound32F(v)
 	case OpRound64F:
-		return rewriteValueMIPS_OpRound64F_0(v)
+		return rewriteValueMIPS_OpRound64F(v)
 	case OpRsh16Ux16:
-		return rewriteValueMIPS_OpRsh16Ux16_0(v)
+		return rewriteValueMIPS_OpRsh16Ux16(v)
 	case OpRsh16Ux32:
-		return rewriteValueMIPS_OpRsh16Ux32_0(v)
+		return rewriteValueMIPS_OpRsh16Ux32(v)
 	case OpRsh16Ux64:
-		return rewriteValueMIPS_OpRsh16Ux64_0(v)
+		return rewriteValueMIPS_OpRsh16Ux64(v)
 	case OpRsh16Ux8:
-		return rewriteValueMIPS_OpRsh16Ux8_0(v)
+		return rewriteValueMIPS_OpRsh16Ux8(v)
 	case OpRsh16x16:
-		return rewriteValueMIPS_OpRsh16x16_0(v)
+		return rewriteValueMIPS_OpRsh16x16(v)
 	case OpRsh16x32:
-		return rewriteValueMIPS_OpRsh16x32_0(v)
+		return rewriteValueMIPS_OpRsh16x32(v)
 	case OpRsh16x64:
-		return rewriteValueMIPS_OpRsh16x64_0(v)
+		return rewriteValueMIPS_OpRsh16x64(v)
 	case OpRsh16x8:
-		return rewriteValueMIPS_OpRsh16x8_0(v)
+		return rewriteValueMIPS_OpRsh16x8(v)
 	case OpRsh32Ux16:
-		return rewriteValueMIPS_OpRsh32Ux16_0(v)
+		return rewriteValueMIPS_OpRsh32Ux16(v)
 	case OpRsh32Ux32:
-		return rewriteValueMIPS_OpRsh32Ux32_0(v)
+		return rewriteValueMIPS_OpRsh32Ux32(v)
 	case OpRsh32Ux64:
-		return rewriteValueMIPS_OpRsh32Ux64_0(v)
+		return rewriteValueMIPS_OpRsh32Ux64(v)
 	case OpRsh32Ux8:
-		return rewriteValueMIPS_OpRsh32Ux8_0(v)
+		return rewriteValueMIPS_OpRsh32Ux8(v)
 	case OpRsh32x16:
-		return rewriteValueMIPS_OpRsh32x16_0(v)
+		return rewriteValueMIPS_OpRsh32x16(v)
 	case OpRsh32x32:
-		return rewriteValueMIPS_OpRsh32x32_0(v)
+		return rewriteValueMIPS_OpRsh32x32(v)
 	case OpRsh32x64:
-		return rewriteValueMIPS_OpRsh32x64_0(v)
+		return rewriteValueMIPS_OpRsh32x64(v)
 	case OpRsh32x8:
-		return rewriteValueMIPS_OpRsh32x8_0(v)
+		return rewriteValueMIPS_OpRsh32x8(v)
 	case OpRsh8Ux16:
-		return rewriteValueMIPS_OpRsh8Ux16_0(v)
+		return rewriteValueMIPS_OpRsh8Ux16(v)
 	case OpRsh8Ux32:
-		return rewriteValueMIPS_OpRsh8Ux32_0(v)
+		return rewriteValueMIPS_OpRsh8Ux32(v)
 	case OpRsh8Ux64:
-		return rewriteValueMIPS_OpRsh8Ux64_0(v)
+		return rewriteValueMIPS_OpRsh8Ux64(v)
 	case OpRsh8Ux8:
-		return rewriteValueMIPS_OpRsh8Ux8_0(v)
+		return rewriteValueMIPS_OpRsh8Ux8(v)
 	case OpRsh8x16:
-		return rewriteValueMIPS_OpRsh8x16_0(v)
+		return rewriteValueMIPS_OpRsh8x16(v)
 	case OpRsh8x32:
-		return rewriteValueMIPS_OpRsh8x32_0(v)
+		return rewriteValueMIPS_OpRsh8x32(v)
 	case OpRsh8x64:
-		return rewriteValueMIPS_OpRsh8x64_0(v)
+		return rewriteValueMIPS_OpRsh8x64(v)
 	case OpRsh8x8:
-		return rewriteValueMIPS_OpRsh8x8_0(v)
+		return rewriteValueMIPS_OpRsh8x8(v)
 	case OpSelect0:
-		return rewriteValueMIPS_OpSelect0_0(v)
+		return rewriteValueMIPS_OpSelect0(v)
 	case OpSelect1:
-		return rewriteValueMIPS_OpSelect1_0(v)
+		return rewriteValueMIPS_OpSelect1(v)
 	case OpSignExt16to32:
-		return rewriteValueMIPS_OpSignExt16to32_0(v)
+		return rewriteValueMIPS_OpSignExt16to32(v)
 	case OpSignExt8to16:
-		return rewriteValueMIPS_OpSignExt8to16_0(v)
+		return rewriteValueMIPS_OpSignExt8to16(v)
 	case OpSignExt8to32:
-		return rewriteValueMIPS_OpSignExt8to32_0(v)
+		return rewriteValueMIPS_OpSignExt8to32(v)
 	case OpSignmask:
-		return rewriteValueMIPS_OpSignmask_0(v)
+		return rewriteValueMIPS_OpSignmask(v)
 	case OpSlicemask:
-		return rewriteValueMIPS_OpSlicemask_0(v)
+		return rewriteValueMIPS_OpSlicemask(v)
 	case OpSqrt:
-		return rewriteValueMIPS_OpSqrt_0(v)
+		return rewriteValueMIPS_OpSqrt(v)
 	case OpStaticCall:
-		return rewriteValueMIPS_OpStaticCall_0(v)
+		return rewriteValueMIPS_OpStaticCall(v)
 	case OpStore:
-		return rewriteValueMIPS_OpStore_0(v)
+		return rewriteValueMIPS_OpStore(v)
 	case OpSub16:
-		return rewriteValueMIPS_OpSub16_0(v)
+		return rewriteValueMIPS_OpSub16(v)
 	case OpSub32:
-		return rewriteValueMIPS_OpSub32_0(v)
+		return rewriteValueMIPS_OpSub32(v)
 	case OpSub32F:
-		return rewriteValueMIPS_OpSub32F_0(v)
+		return rewriteValueMIPS_OpSub32F(v)
 	case OpSub32withcarry:
-		return rewriteValueMIPS_OpSub32withcarry_0(v)
+		return rewriteValueMIPS_OpSub32withcarry(v)
 	case OpSub64F:
-		return rewriteValueMIPS_OpSub64F_0(v)
+		return rewriteValueMIPS_OpSub64F(v)
 	case OpSub8:
-		return rewriteValueMIPS_OpSub8_0(v)
+		return rewriteValueMIPS_OpSub8(v)
 	case OpSubPtr:
-		return rewriteValueMIPS_OpSubPtr_0(v)
+		return rewriteValueMIPS_OpSubPtr(v)
 	case OpTrunc16to8:
-		return rewriteValueMIPS_OpTrunc16to8_0(v)
+		return rewriteValueMIPS_OpTrunc16to8(v)
 	case OpTrunc32to16:
-		return rewriteValueMIPS_OpTrunc32to16_0(v)
+		return rewriteValueMIPS_OpTrunc32to16(v)
 	case OpTrunc32to8:
-		return rewriteValueMIPS_OpTrunc32to8_0(v)
+		return rewriteValueMIPS_OpTrunc32to8(v)
 	case OpWB:
-		return rewriteValueMIPS_OpWB_0(v)
+		return rewriteValueMIPS_OpWB(v)
 	case OpXor16:
-		return rewriteValueMIPS_OpXor16_0(v)
+		return rewriteValueMIPS_OpXor16(v)
 	case OpXor32:
-		return rewriteValueMIPS_OpXor32_0(v)
+		return rewriteValueMIPS_OpXor32(v)
 	case OpXor8:
-		return rewriteValueMIPS_OpXor8_0(v)
+		return rewriteValueMIPS_OpXor8(v)
 	case OpZero:
-		return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v)
+		return rewriteValueMIPS_OpZero(v)
 	case OpZeroExt16to32:
-		return rewriteValueMIPS_OpZeroExt16to32_0(v)
+		return rewriteValueMIPS_OpZeroExt16to32(v)
 	case OpZeroExt8to16:
-		return rewriteValueMIPS_OpZeroExt8to16_0(v)
+		return rewriteValueMIPS_OpZeroExt8to16(v)
 	case OpZeroExt8to32:
-		return rewriteValueMIPS_OpZeroExt8to32_0(v)
+		return rewriteValueMIPS_OpZeroExt8to32(v)
 	case OpZeromask:
-		return rewriteValueMIPS_OpZeromask_0(v)
+		return rewriteValueMIPS_OpZeromask(v)
 	}
 	return false
 }
-func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Add16 x y)
@@ -538,7 +538,7 @@ func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Add32 x y)
@@ -552,7 +552,7 @@ func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Add32F x y)
@@ -566,7 +566,7 @@ func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -587,7 +587,7 @@ func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Add64F x y)
@@ -601,7 +601,7 @@ func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Add8 x y)
@@ -615,7 +615,7 @@ func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpAddPtr(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (AddPtr x y)
@@ -629,7 +629,7 @@ func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAddr_0(v *Value) bool {
+func rewriteValueMIPS_OpAddr(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Addr {sym} base)
 	// result: (MOVWaddr {sym} base)
@@ -642,7 +642,7 @@ func rewriteValueMIPS_OpAddr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (And16 x y)
@@ -656,7 +656,7 @@ func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (And32 x y)
@@ -670,7 +670,7 @@ func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (And8 x y)
@@ -684,7 +684,7 @@ func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAndB_0(v *Value) bool {
+func rewriteValueMIPS_OpAndB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (AndB x y)
@@ -698,7 +698,7 @@ func rewriteValueMIPS_OpAndB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -715,7 +715,7 @@ func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -828,7 +828,7 @@ func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
 	v_3 := v.Args[3]
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
@@ -848,7 +848,7 @@ func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -865,7 +865,7 @@ func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (AtomicLoad32 ptr mem)
@@ -879,7 +879,7 @@ func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (AtomicLoad8 ptr mem)
@@ -893,7 +893,7 @@ func rewriteValueMIPS_OpAtomicLoad8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (AtomicLoadPtr ptr mem)
@@ -907,7 +907,7 @@ func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -983,7 +983,7 @@ func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -1000,7 +1000,7 @@ func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore8(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -1017,7 +1017,7 @@ func rewriteValueMIPS_OpAtomicStore8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -1034,7 +1034,7 @@ func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
+func rewriteValueMIPS_OpAvg32u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1056,7 +1056,7 @@ func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
+func rewriteValueMIPS_OpBitLen32(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -1075,7 +1075,7 @@ func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
+func rewriteValueMIPS_OpClosureCall(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -1094,7 +1094,7 @@ func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom16_0(v *Value) bool {
+func rewriteValueMIPS_OpCom16(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Com16 x)
 	// result: (NORconst [0] x)
@@ -1106,7 +1106,7 @@ func rewriteValueMIPS_OpCom16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom32_0(v *Value) bool {
+func rewriteValueMIPS_OpCom32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Com32 x)
 	// result: (NORconst [0] x)
@@ -1118,7 +1118,7 @@ func rewriteValueMIPS_OpCom32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom8_0(v *Value) bool {
+func rewriteValueMIPS_OpCom8(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Com8 x)
 	// result: (NORconst [0] x)
@@ -1130,7 +1130,7 @@ func rewriteValueMIPS_OpCom8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst16_0(v *Value) bool {
+func rewriteValueMIPS_OpConst16(v *Value) bool {
 	// match: (Const16 [val])
 	// result: (MOVWconst [val])
 	for {
@@ -1140,7 +1140,7 @@ func rewriteValueMIPS_OpConst16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst32_0(v *Value) bool {
+func rewriteValueMIPS_OpConst32(v *Value) bool {
 	// match: (Const32 [val])
 	// result: (MOVWconst [val])
 	for {
@@ -1150,7 +1150,7 @@ func rewriteValueMIPS_OpConst32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
+func rewriteValueMIPS_OpConst32F(v *Value) bool {
 	// match: (Const32F [val])
 	// result: (MOVFconst [val])
 	for {
@@ -1160,7 +1160,7 @@ func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
+func rewriteValueMIPS_OpConst64F(v *Value) bool {
 	// match: (Const64F [val])
 	// result: (MOVDconst [val])
 	for {
@@ -1170,7 +1170,7 @@ func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst8_0(v *Value) bool {
+func rewriteValueMIPS_OpConst8(v *Value) bool {
 	// match: (Const8 [val])
 	// result: (MOVWconst [val])
 	for {
@@ -1180,7 +1180,7 @@ func rewriteValueMIPS_OpConst8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
+func rewriteValueMIPS_OpConstBool(v *Value) bool {
 	// match: (ConstBool [b])
 	// result: (MOVWconst [b])
 	for {
@@ -1190,7 +1190,7 @@ func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
+func rewriteValueMIPS_OpConstNil(v *Value) bool {
 	// match: (ConstNil)
 	// result: (MOVWconst [0])
 	for {
@@ -1199,7 +1199,7 @@ func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
+func rewriteValueMIPS_OpCtz32(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -1226,7 +1226,7 @@ func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueMIPS_OpCtz32NonZero(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Ctz32NonZero x)
 	// result: (Ctz32 x)
@@ -1237,7 +1237,7 @@ func rewriteValueMIPS_OpCtz32NonZero_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt32Fto32 x)
 	// result: (TRUNCFW x)
@@ -1248,7 +1248,7 @@ func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt32Fto64F x)
 	// result: (MOVFD x)
@@ -1259,7 +1259,7 @@ func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt32to32F x)
 	// result: (MOVWF x)
@@ -1270,7 +1270,7 @@ func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt32to64F x)
 	// result: (MOVWD x)
@@ -1281,7 +1281,7 @@ func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt64Fto32 x)
 	// result: (TRUNCDW x)
@@ -1292,7 +1292,7 @@ func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Cvt64Fto32F x)
 	// result: (MOVDF x)
@@ -1303,7 +1303,7 @@ func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1325,7 +1325,7 @@ func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv16u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1347,7 +1347,7 @@ func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1365,7 +1365,7 @@ func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Div32F x y)
@@ -1379,7 +1379,7 @@ func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1397,7 +1397,7 @@ func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Div64F x y)
@@ -1411,7 +1411,7 @@ func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1433,7 +1433,7 @@ func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv8u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1455,7 +1455,7 @@ func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq16_0(v *Value) bool {
+func rewriteValueMIPS_OpEq16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1478,7 +1478,7 @@ func rewriteValueMIPS_OpEq16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq32_0(v *Value) bool {
+func rewriteValueMIPS_OpEq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1497,7 +1497,7 @@ func rewriteValueMIPS_OpEq32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpEq32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1514,7 +1514,7 @@ func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpEq64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1531,7 +1531,7 @@ func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq8_0(v *Value) bool {
+func rewriteValueMIPS_OpEq8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1554,7 +1554,7 @@ func rewriteValueMIPS_OpEq8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEqB_0(v *Value) bool {
+func rewriteValueMIPS_OpEqB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1573,7 +1573,7 @@ func rewriteValueMIPS_OpEqB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpEqPtr(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1592,7 +1592,7 @@ func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1615,7 +1615,7 @@ func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq16U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1638,7 +1638,7 @@ func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1657,7 +1657,7 @@ func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1674,7 +1674,7 @@ func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1693,7 +1693,7 @@ func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1710,7 +1710,7 @@ func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1733,7 +1733,7 @@ func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq8U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1756,7 +1756,7 @@ func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueMIPS_OpGetCallerPC(v *Value) bool {
 	// match: (GetCallerPC)
 	// result: (LoweredGetCallerPC)
 	for {
@@ -1764,7 +1764,7 @@ func rewriteValueMIPS_OpGetCallerPC_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueMIPS_OpGetCallerSP(v *Value) bool {
 	// match: (GetCallerSP)
 	// result: (LoweredGetCallerSP)
 	for {
@@ -1772,7 +1772,7 @@ func rewriteValueMIPS_OpGetCallerSP_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
 	// match: (GetClosurePtr)
 	// result: (LoweredGetClosurePtr)
 	for {
@@ -1780,7 +1780,7 @@ func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1800,7 +1800,7 @@ func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater16U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1820,7 +1820,7 @@ func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Greater32 x y)
@@ -1834,7 +1834,7 @@ func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1851,7 +1851,7 @@ func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Greater32U x y)
@@ -1865,7 +1865,7 @@ func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1882,7 +1882,7 @@ func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1902,7 +1902,7 @@ func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater8U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1922,7 +1922,7 @@ func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
+func rewriteValueMIPS_OpHmul32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1940,7 +1940,7 @@ func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
+func rewriteValueMIPS_OpHmul32u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -1958,7 +1958,7 @@ func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
+func rewriteValueMIPS_OpInterCall(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (InterCall [argwid] entry mem)
@@ -1974,7 +1974,7 @@ func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (IsInBounds idx len)
@@ -1988,7 +1988,7 @@ func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
+func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -2004,7 +2004,7 @@ func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2023,7 +2023,7 @@ func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2046,7 +2046,7 @@ func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq16U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2069,7 +2069,7 @@ func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2088,7 +2088,7 @@ func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2105,7 +2105,7 @@ func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2124,7 +2124,7 @@ func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2141,7 +2141,7 @@ func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2164,7 +2164,7 @@ func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq8U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2187,7 +2187,7 @@ func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess16_0(v *Value) bool {
+func rewriteValueMIPS_OpLess16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2207,7 +2207,7 @@ func rewriteValueMIPS_OpLess16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess16U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2227,7 +2227,7 @@ func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Less32 x y)
@@ -2241,7 +2241,7 @@ func rewriteValueMIPS_OpLess32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2258,7 +2258,7 @@ func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Less32U x y)
@@ -2272,7 +2272,7 @@ func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
+func rewriteValueMIPS_OpLess64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2289,7 +2289,7 @@ func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess8_0(v *Value) bool {
+func rewriteValueMIPS_OpLess8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2309,7 +2309,7 @@ func rewriteValueMIPS_OpLess8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess8U(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2329,7 +2329,7 @@ func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLoad_0(v *Value) bool {
+func rewriteValueMIPS_OpLoad(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Load <t> ptr mem)
@@ -2454,7 +2454,7 @@ func rewriteValueMIPS_OpLoad_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpLocalAddr_0(v *Value) bool {
+func rewriteValueMIPS_OpLocalAddr(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (LocalAddr {sym} base _)
 	// result: (MOVWaddr {sym} base)
@@ -2467,7 +2467,7 @@ func rewriteValueMIPS_OpLocalAddr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2497,7 +2497,7 @@ func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2523,7 +2523,7 @@ func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Lsh16x64 x (Const64 [c]))
@@ -2560,7 +2560,7 @@ func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2590,7 +2590,7 @@ func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2620,7 +2620,7 @@ func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2646,7 +2646,7 @@ func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Lsh32x64 x (Const64 [c]))
@@ -2683,7 +2683,7 @@ func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2713,7 +2713,7 @@ func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2743,7 +2743,7 @@ func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2769,7 +2769,7 @@ func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Lsh8x64 x (Const64 [c]))
@@ -2806,7 +2806,7 @@ func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -2836,7 +2836,7 @@ func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (ADD x (MOVWconst [c]))
@@ -2873,7 +2873,7 @@ func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
 	// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2945,7 +2945,7 @@ func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -3001,7 +3001,7 @@ func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ANDconst [0] _)
 	// result: (MOVWconst [0])
@@ -3053,7 +3053,7 @@ func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3101,7 +3101,7 @@ func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (CMOVZzero _ (MOVWconst [0]))
@@ -3133,7 +3133,7 @@ func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3158,7 +3158,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3177,7 +3177,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3250,7 +3250,7 @@ func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVBUreg x:(MOVBUload _ _))
@@ -3328,7 +3328,7 @@ func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3401,7 +3401,7 @@ func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVBreg x:(MOVBload _ _))
@@ -3483,7 +3483,7 @@ func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3651,7 +3651,7 @@ func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3702,7 +3702,7 @@ func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3776,7 +3776,7 @@ func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3832,7 +3832,7 @@ func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3906,7 +3906,7 @@ func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -3962,7 +3962,7 @@ func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4035,7 +4035,7 @@ func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVHUreg x:(MOVBUload _ _))
@@ -4136,7 +4136,7 @@ func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4209,7 +4209,7 @@ func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (MOVHreg x:(MOVBload _ _))
@@ -4337,7 +4337,7 @@ func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -4467,7 +4467,7 @@ func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4518,7 +4518,7 @@ func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4592,7 +4592,7 @@ func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (MOVWreg x)
 	// cond: x.Uses == 1
@@ -4619,7 +4619,7 @@ func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -4711,7 +4711,7 @@ func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4762,7 +4762,7 @@ func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (MUL (MOVWconst [0]) _ )
@@ -4847,7 +4847,7 @@ func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (NEG (MOVWconst [c]))
 	// result: (MOVWconst [int64(int32(-c))])
@@ -4862,7 +4862,7 @@ func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (NOR x (MOVWconst [c]))
@@ -4883,7 +4883,7 @@ func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (NORconst [c] (MOVWconst [d]))
 	// result: (MOVWconst [^(c|d)])
@@ -4899,7 +4899,7 @@ func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -4954,7 +4954,7 @@ func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ORconst [0] x)
 	// result: x
@@ -5006,7 +5006,7 @@ func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SGT (MOVWconst [c]) x)
@@ -5035,7 +5035,7 @@ func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SGTU (MOVWconst [c]) x)
@@ -5064,7 +5064,7 @@ func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SGTUconst [c] (MOVWconst [d]))
 	// cond: uint32(c)>uint32(d)
@@ -5156,7 +5156,7 @@ func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SGTUzero (MOVWconst [d]))
 	// cond: uint32(d) != 0
@@ -5190,7 +5190,7 @@ func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SGTconst [c] (MOVWconst [d]))
 	// cond: int32(c) > int32(d)
@@ -5320,10 +5320,6 @@ func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
 		v.AuxInt = 0
 		return true
 	}
-	return false
-}
-func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
-	v_0 := v.Args[0]
 	// match: (SGTconst [c] (ANDconst [m] _))
 	// cond: 0 <= int32(m) && int32(m) < int32(c)
 	// result: (MOVWconst [1])
@@ -5358,7 +5354,7 @@ func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SGTzero (MOVWconst [d]))
 	// cond: int32(d) > 0
@@ -5392,7 +5388,7 @@ func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SLL _ (MOVWconst [c]))
@@ -5425,7 +5421,7 @@ func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SLLconst [c] (MOVWconst [d]))
 	// result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))])
@@ -5441,7 +5437,7 @@ func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SRA x (MOVWconst [c]))
@@ -5476,7 +5472,7 @@ func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SRAconst [c] (MOVWconst [d]))
 	// result: (MOVWconst [int64(int32(d)>>uint32(c))])
@@ -5492,7 +5488,7 @@ func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SRL _ (MOVWconst [c]))
@@ -5525,7 +5521,7 @@ func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SRLconst [c] (MOVWconst [d]))
 	// result: (MOVWconst [int64(uint32(d)>>uint32(c))])
@@ -5541,7 +5537,7 @@ func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SUB x (MOVWconst [c]))
@@ -5581,7 +5577,7 @@ func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SUBconst [0] x)
 	// result: x
@@ -5637,7 +5633,7 @@ func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (XOR x (MOVWconst [c]))
@@ -5669,7 +5665,7 @@ func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (XORconst [0] x)
 	// result: x
@@ -5723,7 +5719,7 @@ func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMod16_0(v *Value) bool {
+func rewriteValueMIPS_OpMod16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5745,7 +5741,7 @@ func rewriteValueMIPS_OpMod16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod16u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5767,7 +5763,7 @@ func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod32_0(v *Value) bool {
+func rewriteValueMIPS_OpMod32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5785,7 +5781,7 @@ func rewriteValueMIPS_OpMod32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod32u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5803,7 +5799,7 @@ func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod8_0(v *Value) bool {
+func rewriteValueMIPS_OpMod8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5825,7 +5821,7 @@ func rewriteValueMIPS_OpMod8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod8u(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -5847,11 +5843,12 @@ func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMove_0(v *Value) bool {
+func rewriteValueMIPS_OpMove(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
+	config := b.Func.Config
 	typ := &b.Func.Config.Types
 	// match: (Move [0] _ _ mem)
 	// result: mem
@@ -6151,15 +6148,6 @@ func rewriteValueMIPS_OpMove_0(v *Value) bool {
 		v.AddArg(v1)
 		return true
 	}
-	return false
-}
-func rewriteValueMIPS_OpMove_10(v *Value) bool {
-	v_2 := v.Args[2]
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	b := v.Block
-	config := b.Func.Config
-	typ := &b.Func.Config.Types
 	// match: (Move [6] {t} dst src mem)
 	// cond: t.(*types.Type).Alignment()%2 == 0
 	// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
@@ -6317,7 +6305,7 @@ func rewriteValueMIPS_OpMove_10(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpMul16_0(v *Value) bool {
+func rewriteValueMIPS_OpMul16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul16 x y)
@@ -6331,7 +6319,7 @@ func rewriteValueMIPS_OpMul16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul32 x y)
@@ -6345,7 +6333,7 @@ func rewriteValueMIPS_OpMul32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul32F x y)
@@ -6359,7 +6347,7 @@ func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul32uhilo x y)
@@ -6373,7 +6361,7 @@ func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
+func rewriteValueMIPS_OpMul64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul64F x y)
@@ -6387,7 +6375,7 @@ func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul8_0(v *Value) bool {
+func rewriteValueMIPS_OpMul8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Mul8 x y)
@@ -6401,7 +6389,7 @@ func rewriteValueMIPS_OpMul8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg16(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Neg16 x)
 	// result: (NEG x)
@@ -6412,7 +6400,7 @@ func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Neg32 x)
 	// result: (NEG x)
@@ -6423,7 +6411,7 @@ func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg32F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Neg32F x)
 	// result: (NEGF x)
@@ -6434,7 +6422,7 @@ func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg64F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Neg64F x)
 	// result: (NEGD x)
@@ -6445,7 +6433,7 @@ func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg8(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Neg8 x)
 	// result: (NEG x)
@@ -6456,7 +6444,7 @@ func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6481,7 +6469,7 @@ func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6502,7 +6490,7 @@ func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6519,7 +6507,7 @@ func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6536,7 +6524,7 @@ func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6561,7 +6549,7 @@ func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
+func rewriteValueMIPS_OpNeqB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (NeqB x y)
@@ -6575,7 +6563,7 @@ func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6596,7 +6584,7 @@ func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
+func rewriteValueMIPS_OpNilCheck(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (NilCheck ptr mem)
@@ -6610,7 +6598,7 @@ func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpNot_0(v *Value) bool {
+func rewriteValueMIPS_OpNot(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Not x)
 	// result: (XORconst [1] x)
@@ -6622,7 +6610,7 @@ func rewriteValueMIPS_OpNot_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpOffPtr(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (OffPtr [off] ptr:(SP))
 	// result: (MOVWaddr [off] ptr)
@@ -6648,7 +6636,7 @@ func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr16_0(v *Value) bool {
+func rewriteValueMIPS_OpOr16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Or16 x y)
@@ -6662,7 +6650,7 @@ func rewriteValueMIPS_OpOr16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr32_0(v *Value) bool {
+func rewriteValueMIPS_OpOr32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Or32 x y)
@@ -6676,7 +6664,7 @@ func rewriteValueMIPS_OpOr32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr8_0(v *Value) bool {
+func rewriteValueMIPS_OpOr8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Or8 x y)
@@ -6690,7 +6678,7 @@ func rewriteValueMIPS_OpOr8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpOrB_0(v *Value) bool {
+func rewriteValueMIPS_OpOrB(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (OrB x y)
@@ -6704,7 +6692,7 @@ func rewriteValueMIPS_OpOrB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpPanicBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpPanicBounds(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -6764,7 +6752,7 @@ func rewriteValueMIPS_OpPanicBounds_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpPanicExtend_0(v *Value) bool {
+func rewriteValueMIPS_OpPanicExtend(v *Value) bool {
 	v_3 := v.Args[3]
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
@@ -6831,7 +6819,7 @@ func rewriteValueMIPS_OpPanicExtend_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6862,7 +6850,7 @@ func rewriteValueMIPS_OpRotateLeft16_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6893,7 +6881,7 @@ func rewriteValueMIPS_OpRotateLeft32_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6924,7 +6912,7 @@ func rewriteValueMIPS_OpRotateLeft64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -6955,7 +6943,7 @@ func rewriteValueMIPS_OpRotateLeft8_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
+func rewriteValueMIPS_OpRound32F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Round32F x)
 	// result: x
@@ -6967,7 +6955,7 @@ func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
+func rewriteValueMIPS_OpRound64F(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Round64F x)
 	// result: x
@@ -6979,7 +6967,7 @@ func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7011,7 +6999,7 @@ func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7039,7 +7027,7 @@ func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7081,7 +7069,7 @@ func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7113,7 +7101,7 @@ func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7144,7 +7132,7 @@ func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7171,7 +7159,7 @@ func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7218,7 +7206,7 @@ func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7249,7 +7237,7 @@ func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7279,7 +7267,7 @@ func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7305,7 +7293,7 @@ func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Rsh32Ux64 x (Const64 [c]))
@@ -7342,7 +7330,7 @@ func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7372,7 +7360,7 @@ func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7401,7 +7389,7 @@ func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7426,7 +7414,7 @@ func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Rsh32x64 x (Const64 [c]))
@@ -7465,7 +7453,7 @@ func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7494,7 +7482,7 @@ func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7526,7 +7514,7 @@ func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7554,7 +7542,7 @@ func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7596,7 +7584,7 @@ func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7628,7 +7616,7 @@ func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7659,7 +7647,7 @@ func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7686,7 +7674,7 @@ func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7733,7 +7721,7 @@ func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
@@ -7764,7 +7752,7 @@ func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
+func rewriteValueMIPS_OpSelect0(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -7957,7 +7945,7 @@ func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
+func rewriteValueMIPS_OpSelect1(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types
@@ -8152,7 +8140,7 @@ func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SignExt16to32 x)
 	// result: (MOVHreg x)
@@ -8163,7 +8151,7 @@ func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SignExt8to16 x)
 	// result: (MOVBreg x)
@@ -8174,7 +8162,7 @@ func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (SignExt8to32 x)
 	// result: (MOVBreg x)
@@ -8185,7 +8173,7 @@ func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
+func rewriteValueMIPS_OpSignmask(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Signmask x)
 	// result: (SRAconst x [31])
@@ -8197,7 +8185,7 @@ func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
+func rewriteValueMIPS_OpSlicemask(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	// match: (Slicemask <t> x)
@@ -8213,7 +8201,7 @@ func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
+func rewriteValueMIPS_OpSqrt(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Sqrt x)
 	// result: (SQRTD x)
@@ -8224,7 +8212,7 @@ func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
+func rewriteValueMIPS_OpStaticCall(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (StaticCall [argwid] {target} mem)
 	// result: (CALLstatic [argwid] {target} mem)
@@ -8239,7 +8227,7 @@ func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpStore_0(v *Value) bool {
+func rewriteValueMIPS_OpStore(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -8330,7 +8318,7 @@ func rewriteValueMIPS_OpStore_0(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpSub16_0(v *Value) bool {
+func rewriteValueMIPS_OpSub16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Sub16 x y)
@@ -8344,7 +8332,7 @@ func rewriteValueMIPS_OpSub16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Sub32 x y)
@@ -8358,7 +8346,7 @@ func rewriteValueMIPS_OpSub32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Sub32F x y)
@@ -8372,7 +8360,7 @@ func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -8393,7 +8381,7 @@ func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
+func rewriteValueMIPS_OpSub64F(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Sub64F x y)
@@ -8407,7 +8395,7 @@ func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub8_0(v *Value) bool {
+func rewriteValueMIPS_OpSub8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Sub8 x y)
@@ -8421,7 +8409,7 @@ func rewriteValueMIPS_OpSub8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpSubPtr(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (SubPtr x y)
@@ -8435,7 +8423,7 @@ func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Trunc16to8 x)
 	// result: x
@@ -8447,7 +8435,7 @@ func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Trunc32to16 x)
 	// result: x
@@ -8459,7 +8447,7 @@ func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (Trunc32to8 x)
 	// result: x
@@ -8471,7 +8459,7 @@ func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpWB_0(v *Value) bool {
+func rewriteValueMIPS_OpWB(v *Value) bool {
 	v_2 := v.Args[2]
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
@@ -8490,7 +8478,7 @@ func rewriteValueMIPS_OpWB_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor16_0(v *Value) bool {
+func rewriteValueMIPS_OpXor16(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Xor16 x y)
@@ -8504,7 +8492,7 @@ func rewriteValueMIPS_OpXor16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor32_0(v *Value) bool {
+func rewriteValueMIPS_OpXor32(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Xor32 x y)
@@ -8518,7 +8506,7 @@ func rewriteValueMIPS_OpXor32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor8_0(v *Value) bool {
+func rewriteValueMIPS_OpXor8(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	// match: (Xor8 x y)
@@ -8532,10 +8520,11 @@ func rewriteValueMIPS_OpXor8_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpZero_0(v *Value) bool {
+func rewriteValueMIPS_OpZero(v *Value) bool {
 	v_1 := v.Args[1]
 	v_0 := v.Args[0]
 	b := v.Block
+	config := b.Func.Config
 	typ := &b.Func.Config.Types
 	// match: (Zero [0] _ mem)
 	// result: mem
@@ -8794,14 +8783,6 @@ func rewriteValueMIPS_OpZero_0(v *Value) bool {
 		v.AddArg(v1)
 		return true
 	}
-	return false
-}
-func rewriteValueMIPS_OpZero_10(v *Value) bool {
-	v_1 := v.Args[1]
-	v_0 := v.Args[0]
-	b := v.Block
-	config := b.Func.Config
-	typ := &b.Func.Config.Types
 	// match: (Zero [12] {t} ptr mem)
 	// cond: t.(*types.Type).Alignment()%4 == 0
 	// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem)))
@@ -8904,7 +8885,7 @@ func rewriteValueMIPS_OpZero_10(v *Value) bool {
 	}
 	return false
 }
-func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ZeroExt16to32 x)
 	// result: (MOVHUreg x)
@@ -8915,7 +8896,7 @@ func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ZeroExt8to16 x)
 	// result: (MOVBUreg x)
@@ -8926,7 +8907,7 @@ func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
 	v_0 := v.Args[0]
 	// match: (ZeroExt8to32 x)
 	// result: (MOVBUreg x)
@@ -8937,7 +8918,7 @@ func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
+func rewriteValueMIPS_OpZeromask(v *Value) bool {
 	v_0 := v.Args[0]
 	b := v.Block
 	typ := &b.Func.Config.Types