diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index 94898e3..2a07d5b 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -162,12 +162,20 @@
 	fmt.Fprintln(w, "var _ = objabi.GOROOT // in case not otherwise used")
 	fmt.Fprintln(w)
 
+	const chunkSize = 10
 	// Main rewrite routine is a switch on v.Op.
 	fmt.Fprintf(w, "func rewriteValue%s(v *Value) bool {\n", arch.name)
 	fmt.Fprintf(w, "switch v.Op {\n")
 	for _, op := range ops {
 		fmt.Fprintf(w, "case %s:\n", op)
-		fmt.Fprintf(w, "return rewriteValue%s_%s(v)\n", arch.name, op)
+		fmt.Fprint(w, "return ")
+		for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
+			if chunk > 0 {
+				fmt.Fprint(w, " || ")
+			}
+			fmt.Fprintf(w, "rewriteValue%s_%s_%d(v)", arch.name, op, chunk)
+		}
+		fmt.Fprintln(w)
 	}
 	fmt.Fprintf(w, "}\n")
 	fmt.Fprintf(w, "return false\n")
@@ -176,67 +184,73 @@
 	// Generate a routine per op. Note that we don't make one giant routine
 	// because it is too big for some compilers.
 	for _, op := range ops {
-		buf := new(bytes.Buffer)
-		var canFail bool
-		for i, rule := range oprules[op] {
-			match, cond, result := rule.parse()
-			fmt.Fprintf(buf, "// match: %s\n", match)
-			fmt.Fprintf(buf, "// cond: %s\n", cond)
-			fmt.Fprintf(buf, "// result: %s\n", result)
+		for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
+			buf := new(bytes.Buffer)
+			var canFail bool
+			endchunk := chunk + chunkSize
+			if endchunk > len(oprules[op]) {
+				endchunk = len(oprules[op])
+			}
+			for i, rule := range oprules[op][chunk:endchunk] {
+				match, cond, result := rule.parse()
+				fmt.Fprintf(buf, "// match: %s\n", match)
+				fmt.Fprintf(buf, "// cond: %s\n", cond)
+				fmt.Fprintf(buf, "// result: %s\n", result)
 
-			canFail = false
-			fmt.Fprintf(buf, "for {\n")
-			if genMatch(buf, arch, match, rule.loc) {
-				canFail = true
+				canFail = false
+				fmt.Fprintf(buf, "for {\n")
+				if genMatch(buf, arch, match, rule.loc) {
+					canFail = true
+				}
+
+				if cond != "" {
+					fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
+					canFail = true
+				}
+				if !canFail && i+chunk != len(oprules[op])-1 {
+					log.Fatalf("unconditional rule %s is followed by other rules", match)
+				}
+
+				genResult(buf, arch, result, rule.loc)
+				if *genLog {
+					fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+				}
+				fmt.Fprintf(buf, "return true\n")
+
+				fmt.Fprintf(buf, "}\n")
+			}
+			if canFail {
+				fmt.Fprintf(buf, "return false\n")
 			}
 
-			if cond != "" {
-				fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
-				canFail = true
+			body := buf.String()
+			// Do a rough match to predict whether we need b, config, fe, and/or types.
+			// It's not precise--thus the blank assignments--but it's good enough
+			// to avoid generating needless code and doing pointless nil checks.
+			hasb := strings.Contains(body, "b.")
+			hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
+			hasfe := strings.Contains(body, "fe.")
+			hasts := strings.Contains(body, "types.")
+			fmt.Fprintf(w, "func rewriteValue%s_%s_%d(v *Value) bool {\n", arch.name, op, chunk)
+			if hasb || hasconfig || hasfe {
+				fmt.Fprintln(w, "b := v.Block")
+				fmt.Fprintln(w, "_ = b")
 			}
-			if !canFail && i != len(oprules[op])-1 {
-				log.Fatalf("unconditional rule %s is followed by other rules", match)
+			if hasconfig {
+				fmt.Fprintln(w, "config := b.Func.Config")
+				fmt.Fprintln(w, "_ = config")
 			}
-
-			genResult(buf, arch, result, rule.loc)
-			if *genLog {
-				fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+			if hasfe {
+				fmt.Fprintln(w, "fe := b.Func.fe")
+				fmt.Fprintln(w, "_ = fe")
 			}
-			fmt.Fprintf(buf, "return true\n")
-
-			fmt.Fprintf(buf, "}\n")
+			if hasts {
+				fmt.Fprintln(w, "types := &b.Func.Config.Types")
+				fmt.Fprintln(w, "_ = types")
+			}
+			fmt.Fprint(w, body)
+			fmt.Fprintf(w, "}\n")
 		}
-		if canFail {
-			fmt.Fprintf(buf, "return false\n")
-		}
-
-		body := buf.String()
-		// Do a rough match to predict whether we need b, config, fe, and/or types.
-		// It's not precise--thus the blank assignments--but it's good enough
-		// to avoid generating needless code and doing pointless nil checks.
-		hasb := strings.Contains(body, "b.")
-		hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
-		hasfe := strings.Contains(body, "fe.")
-		hasts := strings.Contains(body, "types.")
-		fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op)
-		if hasb || hasconfig || hasfe {
-			fmt.Fprintln(w, "b := v.Block")
-			fmt.Fprintln(w, "_ = b")
-		}
-		if hasconfig {
-			fmt.Fprintln(w, "config := b.Func.Config")
-			fmt.Fprintln(w, "_ = config")
-		}
-		if hasfe {
-			fmt.Fprintln(w, "fe := b.Func.fe")
-			fmt.Fprintln(w, "_ = fe")
-		}
-		if hasts {
-			fmt.Fprintln(w, "types := &b.Func.Config.Types")
-			fmt.Fprintln(w, "_ = types")
-		}
-		fmt.Fprint(w, body)
-		fmt.Fprintf(w, "}\n")
 	}
 
 	// Generate block rewrite function. There are only a few block types
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 58ef586..d6509ae 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -14,583 +14,583 @@
 func rewriteValue386(v *Value) bool {
 	switch v.Op {
 	case Op386ADCL:
-		return rewriteValue386_Op386ADCL(v)
+		return rewriteValue386_Op386ADCL_0(v)
 	case Op386ADDL:
-		return rewriteValue386_Op386ADDL(v)
+		return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v)
 	case Op386ADDLcarry:
-		return rewriteValue386_Op386ADDLcarry(v)
+		return rewriteValue386_Op386ADDLcarry_0(v)
 	case Op386ADDLconst:
-		return rewriteValue386_Op386ADDLconst(v)
+		return rewriteValue386_Op386ADDLconst_0(v)
 	case Op386ANDL:
-		return rewriteValue386_Op386ANDL(v)
+		return rewriteValue386_Op386ANDL_0(v)
 	case Op386ANDLconst:
-		return rewriteValue386_Op386ANDLconst(v)
+		return rewriteValue386_Op386ANDLconst_0(v)
 	case Op386CMPB:
-		return rewriteValue386_Op386CMPB(v)
+		return rewriteValue386_Op386CMPB_0(v)
 	case Op386CMPBconst:
-		return rewriteValue386_Op386CMPBconst(v)
+		return rewriteValue386_Op386CMPBconst_0(v)
 	case Op386CMPL:
-		return rewriteValue386_Op386CMPL(v)
+		return rewriteValue386_Op386CMPL_0(v)
 	case Op386CMPLconst:
-		return rewriteValue386_Op386CMPLconst(v)
+		return rewriteValue386_Op386CMPLconst_0(v)
 	case Op386CMPW:
-		return rewriteValue386_Op386CMPW(v)
+		return rewriteValue386_Op386CMPW_0(v)
 	case Op386CMPWconst:
-		return rewriteValue386_Op386CMPWconst(v)
+		return rewriteValue386_Op386CMPWconst_0(v)
 	case Op386LEAL:
-		return rewriteValue386_Op386LEAL(v)
+		return rewriteValue386_Op386LEAL_0(v)
 	case Op386LEAL1:
-		return rewriteValue386_Op386LEAL1(v)
+		return rewriteValue386_Op386LEAL1_0(v)
 	case Op386LEAL2:
-		return rewriteValue386_Op386LEAL2(v)
+		return rewriteValue386_Op386LEAL2_0(v)
 	case Op386LEAL4:
-		return rewriteValue386_Op386LEAL4(v)
+		return rewriteValue386_Op386LEAL4_0(v)
 	case Op386LEAL8:
-		return rewriteValue386_Op386LEAL8(v)
+		return rewriteValue386_Op386LEAL8_0(v)
 	case Op386MOVBLSX:
-		return rewriteValue386_Op386MOVBLSX(v)
+		return rewriteValue386_Op386MOVBLSX_0(v)
 	case Op386MOVBLSXload:
-		return rewriteValue386_Op386MOVBLSXload(v)
+		return rewriteValue386_Op386MOVBLSXload_0(v)
 	case Op386MOVBLZX:
-		return rewriteValue386_Op386MOVBLZX(v)
+		return rewriteValue386_Op386MOVBLZX_0(v)
 	case Op386MOVBload:
-		return rewriteValue386_Op386MOVBload(v)
+		return rewriteValue386_Op386MOVBload_0(v)
 	case Op386MOVBloadidx1:
-		return rewriteValue386_Op386MOVBloadidx1(v)
+		return rewriteValue386_Op386MOVBloadidx1_0(v)
 	case Op386MOVBstore:
-		return rewriteValue386_Op386MOVBstore(v)
+		return rewriteValue386_Op386MOVBstore_0(v)
 	case Op386MOVBstoreconst:
-		return rewriteValue386_Op386MOVBstoreconst(v)
+		return rewriteValue386_Op386MOVBstoreconst_0(v)
 	case Op386MOVBstoreconstidx1:
-		return rewriteValue386_Op386MOVBstoreconstidx1(v)
+		return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
 	case Op386MOVBstoreidx1:
-		return rewriteValue386_Op386MOVBstoreidx1(v)
+		return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v)
 	case Op386MOVLload:
-		return rewriteValue386_Op386MOVLload(v)
+		return rewriteValue386_Op386MOVLload_0(v)
 	case Op386MOVLloadidx1:
-		return rewriteValue386_Op386MOVLloadidx1(v)
+		return rewriteValue386_Op386MOVLloadidx1_0(v)
 	case Op386MOVLloadidx4:
-		return rewriteValue386_Op386MOVLloadidx4(v)
+		return rewriteValue386_Op386MOVLloadidx4_0(v)
 	case Op386MOVLstore:
-		return rewriteValue386_Op386MOVLstore(v)
+		return rewriteValue386_Op386MOVLstore_0(v)
 	case Op386MOVLstoreconst:
-		return rewriteValue386_Op386MOVLstoreconst(v)
+		return rewriteValue386_Op386MOVLstoreconst_0(v)
 	case Op386MOVLstoreconstidx1:
-		return rewriteValue386_Op386MOVLstoreconstidx1(v)
+		return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
 	case Op386MOVLstoreconstidx4:
-		return rewriteValue386_Op386MOVLstoreconstidx4(v)
+		return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
 	case Op386MOVLstoreidx1:
-		return rewriteValue386_Op386MOVLstoreidx1(v)
+		return rewriteValue386_Op386MOVLstoreidx1_0(v)
 	case Op386MOVLstoreidx4:
-		return rewriteValue386_Op386MOVLstoreidx4(v)
+		return rewriteValue386_Op386MOVLstoreidx4_0(v)
 	case Op386MOVSDconst:
-		return rewriteValue386_Op386MOVSDconst(v)
+		return rewriteValue386_Op386MOVSDconst_0(v)
 	case Op386MOVSDload:
-		return rewriteValue386_Op386MOVSDload(v)
+		return rewriteValue386_Op386MOVSDload_0(v)
 	case Op386MOVSDloadidx1:
-		return rewriteValue386_Op386MOVSDloadidx1(v)
+		return rewriteValue386_Op386MOVSDloadidx1_0(v)
 	case Op386MOVSDloadidx8:
-		return rewriteValue386_Op386MOVSDloadidx8(v)
+		return rewriteValue386_Op386MOVSDloadidx8_0(v)
 	case Op386MOVSDstore:
-		return rewriteValue386_Op386MOVSDstore(v)
+		return rewriteValue386_Op386MOVSDstore_0(v)
 	case Op386MOVSDstoreidx1:
-		return rewriteValue386_Op386MOVSDstoreidx1(v)
+		return rewriteValue386_Op386MOVSDstoreidx1_0(v)
 	case Op386MOVSDstoreidx8:
-		return rewriteValue386_Op386MOVSDstoreidx8(v)
+		return rewriteValue386_Op386MOVSDstoreidx8_0(v)
 	case Op386MOVSSconst:
-		return rewriteValue386_Op386MOVSSconst(v)
+		return rewriteValue386_Op386MOVSSconst_0(v)
 	case Op386MOVSSload:
-		return rewriteValue386_Op386MOVSSload(v)
+		return rewriteValue386_Op386MOVSSload_0(v)
 	case Op386MOVSSloadidx1:
-		return rewriteValue386_Op386MOVSSloadidx1(v)
+		return rewriteValue386_Op386MOVSSloadidx1_0(v)
 	case Op386MOVSSloadidx4:
-		return rewriteValue386_Op386MOVSSloadidx4(v)
+		return rewriteValue386_Op386MOVSSloadidx4_0(v)
 	case Op386MOVSSstore:
-		return rewriteValue386_Op386MOVSSstore(v)
+		return rewriteValue386_Op386MOVSSstore_0(v)
 	case Op386MOVSSstoreidx1:
-		return rewriteValue386_Op386MOVSSstoreidx1(v)
+		return rewriteValue386_Op386MOVSSstoreidx1_0(v)
 	case Op386MOVSSstoreidx4:
-		return rewriteValue386_Op386MOVSSstoreidx4(v)
+		return rewriteValue386_Op386MOVSSstoreidx4_0(v)
 	case Op386MOVWLSX:
-		return rewriteValue386_Op386MOVWLSX(v)
+		return rewriteValue386_Op386MOVWLSX_0(v)
 	case Op386MOVWLSXload:
-		return rewriteValue386_Op386MOVWLSXload(v)
+		return rewriteValue386_Op386MOVWLSXload_0(v)
 	case Op386MOVWLZX:
-		return rewriteValue386_Op386MOVWLZX(v)
+		return rewriteValue386_Op386MOVWLZX_0(v)
 	case Op386MOVWload:
-		return rewriteValue386_Op386MOVWload(v)
+		return rewriteValue386_Op386MOVWload_0(v)
 	case Op386MOVWloadidx1:
-		return rewriteValue386_Op386MOVWloadidx1(v)
+		return rewriteValue386_Op386MOVWloadidx1_0(v)
 	case Op386MOVWloadidx2:
-		return rewriteValue386_Op386MOVWloadidx2(v)
+		return rewriteValue386_Op386MOVWloadidx2_0(v)
 	case Op386MOVWstore:
-		return rewriteValue386_Op386MOVWstore(v)
+		return rewriteValue386_Op386MOVWstore_0(v)
 	case Op386MOVWstoreconst:
-		return rewriteValue386_Op386MOVWstoreconst(v)
+		return rewriteValue386_Op386MOVWstoreconst_0(v)
 	case Op386MOVWstoreconstidx1:
-		return rewriteValue386_Op386MOVWstoreconstidx1(v)
+		return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
 	case Op386MOVWstoreconstidx2:
-		return rewriteValue386_Op386MOVWstoreconstidx2(v)
+		return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
 	case Op386MOVWstoreidx1:
-		return rewriteValue386_Op386MOVWstoreidx1(v)
+		return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v)
 	case Op386MOVWstoreidx2:
-		return rewriteValue386_Op386MOVWstoreidx2(v)
+		return rewriteValue386_Op386MOVWstoreidx2_0(v)
 	case Op386MULL:
-		return rewriteValue386_Op386MULL(v)
+		return rewriteValue386_Op386MULL_0(v)
 	case Op386MULLconst:
-		return rewriteValue386_Op386MULLconst(v)
+		return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v)
 	case Op386NEGL:
-		return rewriteValue386_Op386NEGL(v)
+		return rewriteValue386_Op386NEGL_0(v)
 	case Op386NOTL:
-		return rewriteValue386_Op386NOTL(v)
+		return rewriteValue386_Op386NOTL_0(v)
 	case Op386ORL:
-		return rewriteValue386_Op386ORL(v)
+		return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v)
 	case Op386ORLconst:
-		return rewriteValue386_Op386ORLconst(v)
+		return rewriteValue386_Op386ORLconst_0(v)
 	case Op386ROLBconst:
-		return rewriteValue386_Op386ROLBconst(v)
+		return rewriteValue386_Op386ROLBconst_0(v)
 	case Op386ROLLconst:
-		return rewriteValue386_Op386ROLLconst(v)
+		return rewriteValue386_Op386ROLLconst_0(v)
 	case Op386ROLWconst:
-		return rewriteValue386_Op386ROLWconst(v)
+		return rewriteValue386_Op386ROLWconst_0(v)
 	case Op386SARB:
-		return rewriteValue386_Op386SARB(v)
+		return rewriteValue386_Op386SARB_0(v)
 	case Op386SARBconst:
-		return rewriteValue386_Op386SARBconst(v)
+		return rewriteValue386_Op386SARBconst_0(v)
 	case Op386SARL:
-		return rewriteValue386_Op386SARL(v)
+		return rewriteValue386_Op386SARL_0(v)
 	case Op386SARLconst:
-		return rewriteValue386_Op386SARLconst(v)
+		return rewriteValue386_Op386SARLconst_0(v)
 	case Op386SARW:
-		return rewriteValue386_Op386SARW(v)
+		return rewriteValue386_Op386SARW_0(v)
 	case Op386SARWconst:
-		return rewriteValue386_Op386SARWconst(v)
+		return rewriteValue386_Op386SARWconst_0(v)
 	case Op386SBBL:
-		return rewriteValue386_Op386SBBL(v)
+		return rewriteValue386_Op386SBBL_0(v)
 	case Op386SBBLcarrymask:
-		return rewriteValue386_Op386SBBLcarrymask(v)
+		return rewriteValue386_Op386SBBLcarrymask_0(v)
 	case Op386SETA:
-		return rewriteValue386_Op386SETA(v)
+		return rewriteValue386_Op386SETA_0(v)
 	case Op386SETAE:
-		return rewriteValue386_Op386SETAE(v)
+		return rewriteValue386_Op386SETAE_0(v)
 	case Op386SETB:
-		return rewriteValue386_Op386SETB(v)
+		return rewriteValue386_Op386SETB_0(v)
 	case Op386SETBE:
-		return rewriteValue386_Op386SETBE(v)
+		return rewriteValue386_Op386SETBE_0(v)
 	case Op386SETEQ:
-		return rewriteValue386_Op386SETEQ(v)
+		return rewriteValue386_Op386SETEQ_0(v)
 	case Op386SETG:
-		return rewriteValue386_Op386SETG(v)
+		return rewriteValue386_Op386SETG_0(v)
 	case Op386SETGE:
-		return rewriteValue386_Op386SETGE(v)
+		return rewriteValue386_Op386SETGE_0(v)
 	case Op386SETL:
-		return rewriteValue386_Op386SETL(v)
+		return rewriteValue386_Op386SETL_0(v)
 	case Op386SETLE:
-		return rewriteValue386_Op386SETLE(v)
+		return rewriteValue386_Op386SETLE_0(v)
 	case Op386SETNE:
-		return rewriteValue386_Op386SETNE(v)
+		return rewriteValue386_Op386SETNE_0(v)
 	case Op386SHLL:
-		return rewriteValue386_Op386SHLL(v)
+		return rewriteValue386_Op386SHLL_0(v)
 	case Op386SHLLconst:
-		return rewriteValue386_Op386SHLLconst(v)
+		return rewriteValue386_Op386SHLLconst_0(v)
 	case Op386SHRB:
-		return rewriteValue386_Op386SHRB(v)
+		return rewriteValue386_Op386SHRB_0(v)
 	case Op386SHRBconst:
-		return rewriteValue386_Op386SHRBconst(v)
+		return rewriteValue386_Op386SHRBconst_0(v)
 	case Op386SHRL:
-		return rewriteValue386_Op386SHRL(v)
+		return rewriteValue386_Op386SHRL_0(v)
 	case Op386SHRLconst:
-		return rewriteValue386_Op386SHRLconst(v)
+		return rewriteValue386_Op386SHRLconst_0(v)
 	case Op386SHRW:
-		return rewriteValue386_Op386SHRW(v)
+		return rewriteValue386_Op386SHRW_0(v)
 	case Op386SHRWconst:
-		return rewriteValue386_Op386SHRWconst(v)
+		return rewriteValue386_Op386SHRWconst_0(v)
 	case Op386SUBL:
-		return rewriteValue386_Op386SUBL(v)
+		return rewriteValue386_Op386SUBL_0(v)
 	case Op386SUBLcarry:
-		return rewriteValue386_Op386SUBLcarry(v)
+		return rewriteValue386_Op386SUBLcarry_0(v)
 	case Op386SUBLconst:
-		return rewriteValue386_Op386SUBLconst(v)
+		return rewriteValue386_Op386SUBLconst_0(v)
 	case Op386XORL:
-		return rewriteValue386_Op386XORL(v)
+		return rewriteValue386_Op386XORL_0(v)
 	case Op386XORLconst:
-		return rewriteValue386_Op386XORLconst(v)
+		return rewriteValue386_Op386XORLconst_0(v)
 	case OpAdd16:
-		return rewriteValue386_OpAdd16(v)
+		return rewriteValue386_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValue386_OpAdd32(v)
+		return rewriteValue386_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValue386_OpAdd32F(v)
+		return rewriteValue386_OpAdd32F_0(v)
 	case OpAdd32carry:
-		return rewriteValue386_OpAdd32carry(v)
+		return rewriteValue386_OpAdd32carry_0(v)
 	case OpAdd32withcarry:
-		return rewriteValue386_OpAdd32withcarry(v)
+		return rewriteValue386_OpAdd32withcarry_0(v)
 	case OpAdd64F:
-		return rewriteValue386_OpAdd64F(v)
+		return rewriteValue386_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValue386_OpAdd8(v)
+		return rewriteValue386_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValue386_OpAddPtr(v)
+		return rewriteValue386_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValue386_OpAddr(v)
+		return rewriteValue386_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValue386_OpAnd16(v)
+		return rewriteValue386_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValue386_OpAnd32(v)
+		return rewriteValue386_OpAnd32_0(v)
 	case OpAnd8:
-		return rewriteValue386_OpAnd8(v)
+		return rewriteValue386_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValue386_OpAndB(v)
+		return rewriteValue386_OpAndB_0(v)
 	case OpAvg32u:
-		return rewriteValue386_OpAvg32u(v)
+		return rewriteValue386_OpAvg32u_0(v)
 	case OpBswap32:
-		return rewriteValue386_OpBswap32(v)
+		return rewriteValue386_OpBswap32_0(v)
 	case OpClosureCall:
-		return rewriteValue386_OpClosureCall(v)
+		return rewriteValue386_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValue386_OpCom16(v)
+		return rewriteValue386_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValue386_OpCom32(v)
+		return rewriteValue386_OpCom32_0(v)
 	case OpCom8:
-		return rewriteValue386_OpCom8(v)
+		return rewriteValue386_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValue386_OpConst16(v)
+		return rewriteValue386_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValue386_OpConst32(v)
+		return rewriteValue386_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValue386_OpConst32F(v)
+		return rewriteValue386_OpConst32F_0(v)
 	case OpConst64F:
-		return rewriteValue386_OpConst64F(v)
+		return rewriteValue386_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValue386_OpConst8(v)
+		return rewriteValue386_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValue386_OpConstBool(v)
+		return rewriteValue386_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValue386_OpConstNil(v)
+		return rewriteValue386_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValue386_OpConvert(v)
+		return rewriteValue386_OpConvert_0(v)
 	case OpCvt32Fto32:
-		return rewriteValue386_OpCvt32Fto32(v)
+		return rewriteValue386_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValue386_OpCvt32Fto64F(v)
+		return rewriteValue386_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValue386_OpCvt32to32F(v)
+		return rewriteValue386_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValue386_OpCvt32to64F(v)
+		return rewriteValue386_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValue386_OpCvt64Fto32(v)
+		return rewriteValue386_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValue386_OpCvt64Fto32F(v)
+		return rewriteValue386_OpCvt64Fto32F_0(v)
 	case OpDiv16:
-		return rewriteValue386_OpDiv16(v)
+		return rewriteValue386_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValue386_OpDiv16u(v)
+		return rewriteValue386_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValue386_OpDiv32(v)
+		return rewriteValue386_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValue386_OpDiv32F(v)
+		return rewriteValue386_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValue386_OpDiv32u(v)
+		return rewriteValue386_OpDiv32u_0(v)
 	case OpDiv64F:
-		return rewriteValue386_OpDiv64F(v)
+		return rewriteValue386_OpDiv64F_0(v)
 	case OpDiv8:
-		return rewriteValue386_OpDiv8(v)
+		return rewriteValue386_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValue386_OpDiv8u(v)
+		return rewriteValue386_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValue386_OpEq16(v)
+		return rewriteValue386_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValue386_OpEq32(v)
+		return rewriteValue386_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValue386_OpEq32F(v)
+		return rewriteValue386_OpEq32F_0(v)
 	case OpEq64F:
-		return rewriteValue386_OpEq64F(v)
+		return rewriteValue386_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValue386_OpEq8(v)
+		return rewriteValue386_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValue386_OpEqB(v)
+		return rewriteValue386_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValue386_OpEqPtr(v)
+		return rewriteValue386_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValue386_OpGeq16(v)
+		return rewriteValue386_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValue386_OpGeq16U(v)
+		return rewriteValue386_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValue386_OpGeq32(v)
+		return rewriteValue386_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValue386_OpGeq32F(v)
+		return rewriteValue386_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValue386_OpGeq32U(v)
+		return rewriteValue386_OpGeq32U_0(v)
 	case OpGeq64F:
-		return rewriteValue386_OpGeq64F(v)
+		return rewriteValue386_OpGeq64F_0(v)
 	case OpGeq8:
-		return rewriteValue386_OpGeq8(v)
+		return rewriteValue386_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValue386_OpGeq8U(v)
+		return rewriteValue386_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValue386_OpGetClosurePtr(v)
+		return rewriteValue386_OpGetClosurePtr_0(v)
 	case OpGetG:
-		return rewriteValue386_OpGetG(v)
+		return rewriteValue386_OpGetG_0(v)
 	case OpGreater16:
-		return rewriteValue386_OpGreater16(v)
+		return rewriteValue386_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValue386_OpGreater16U(v)
+		return rewriteValue386_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValue386_OpGreater32(v)
+		return rewriteValue386_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValue386_OpGreater32F(v)
+		return rewriteValue386_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValue386_OpGreater32U(v)
+		return rewriteValue386_OpGreater32U_0(v)
 	case OpGreater64F:
-		return rewriteValue386_OpGreater64F(v)
+		return rewriteValue386_OpGreater64F_0(v)
 	case OpGreater8:
-		return rewriteValue386_OpGreater8(v)
+		return rewriteValue386_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValue386_OpGreater8U(v)
+		return rewriteValue386_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValue386_OpHmul32(v)
+		return rewriteValue386_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValue386_OpHmul32u(v)
+		return rewriteValue386_OpHmul32u_0(v)
 	case OpInterCall:
-		return rewriteValue386_OpInterCall(v)
+		return rewriteValue386_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValue386_OpIsInBounds(v)
+		return rewriteValue386_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValue386_OpIsNonNil(v)
+		return rewriteValue386_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValue386_OpIsSliceInBounds(v)
+		return rewriteValue386_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValue386_OpLeq16(v)
+		return rewriteValue386_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValue386_OpLeq16U(v)
+		return rewriteValue386_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValue386_OpLeq32(v)
+		return rewriteValue386_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValue386_OpLeq32F(v)
+		return rewriteValue386_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValue386_OpLeq32U(v)
+		return rewriteValue386_OpLeq32U_0(v)
 	case OpLeq64F:
-		return rewriteValue386_OpLeq64F(v)
+		return rewriteValue386_OpLeq64F_0(v)
 	case OpLeq8:
-		return rewriteValue386_OpLeq8(v)
+		return rewriteValue386_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValue386_OpLeq8U(v)
+		return rewriteValue386_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValue386_OpLess16(v)
+		return rewriteValue386_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValue386_OpLess16U(v)
+		return rewriteValue386_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValue386_OpLess32(v)
+		return rewriteValue386_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValue386_OpLess32F(v)
+		return rewriteValue386_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValue386_OpLess32U(v)
+		return rewriteValue386_OpLess32U_0(v)
 	case OpLess64F:
-		return rewriteValue386_OpLess64F(v)
+		return rewriteValue386_OpLess64F_0(v)
 	case OpLess8:
-		return rewriteValue386_OpLess8(v)
+		return rewriteValue386_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValue386_OpLess8U(v)
+		return rewriteValue386_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValue386_OpLoad(v)
+		return rewriteValue386_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValue386_OpLsh16x16(v)
+		return rewriteValue386_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValue386_OpLsh16x32(v)
+		return rewriteValue386_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValue386_OpLsh16x64(v)
+		return rewriteValue386_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValue386_OpLsh16x8(v)
+		return rewriteValue386_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValue386_OpLsh32x16(v)
+		return rewriteValue386_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValue386_OpLsh32x32(v)
+		return rewriteValue386_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValue386_OpLsh32x64(v)
+		return rewriteValue386_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValue386_OpLsh32x8(v)
+		return rewriteValue386_OpLsh32x8_0(v)
 	case OpLsh8x16:
-		return rewriteValue386_OpLsh8x16(v)
+		return rewriteValue386_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValue386_OpLsh8x32(v)
+		return rewriteValue386_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValue386_OpLsh8x64(v)
+		return rewriteValue386_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValue386_OpLsh8x8(v)
+		return rewriteValue386_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValue386_OpMod16(v)
+		return rewriteValue386_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValue386_OpMod16u(v)
+		return rewriteValue386_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValue386_OpMod32(v)
+		return rewriteValue386_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValue386_OpMod32u(v)
+		return rewriteValue386_OpMod32u_0(v)
 	case OpMod8:
-		return rewriteValue386_OpMod8(v)
+		return rewriteValue386_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValue386_OpMod8u(v)
+		return rewriteValue386_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValue386_OpMove(v)
+		return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
 	case OpMul16:
-		return rewriteValue386_OpMul16(v)
+		return rewriteValue386_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValue386_OpMul32(v)
+		return rewriteValue386_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValue386_OpMul32F(v)
+		return rewriteValue386_OpMul32F_0(v)
 	case OpMul32uhilo:
-		return rewriteValue386_OpMul32uhilo(v)
+		return rewriteValue386_OpMul32uhilo_0(v)
 	case OpMul64F:
-		return rewriteValue386_OpMul64F(v)
+		return rewriteValue386_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValue386_OpMul8(v)
+		return rewriteValue386_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValue386_OpNeg16(v)
+		return rewriteValue386_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValue386_OpNeg32(v)
+		return rewriteValue386_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValue386_OpNeg32F(v)
+		return rewriteValue386_OpNeg32F_0(v)
 	case OpNeg64F:
-		return rewriteValue386_OpNeg64F(v)
+		return rewriteValue386_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValue386_OpNeg8(v)
+		return rewriteValue386_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValue386_OpNeq16(v)
+		return rewriteValue386_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValue386_OpNeq32(v)
+		return rewriteValue386_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValue386_OpNeq32F(v)
+		return rewriteValue386_OpNeq32F_0(v)
 	case OpNeq64F:
-		return rewriteValue386_OpNeq64F(v)
+		return rewriteValue386_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValue386_OpNeq8(v)
+		return rewriteValue386_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValue386_OpNeqB(v)
+		return rewriteValue386_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValue386_OpNeqPtr(v)
+		return rewriteValue386_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValue386_OpNilCheck(v)
+		return rewriteValue386_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValue386_OpNot(v)
+		return rewriteValue386_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValue386_OpOffPtr(v)
+		return rewriteValue386_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValue386_OpOr16(v)
+		return rewriteValue386_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValue386_OpOr32(v)
+		return rewriteValue386_OpOr32_0(v)
 	case OpOr8:
-		return rewriteValue386_OpOr8(v)
+		return rewriteValue386_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValue386_OpOrB(v)
+		return rewriteValue386_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValue386_OpRound32F(v)
+		return rewriteValue386_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValue386_OpRound64F(v)
+		return rewriteValue386_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValue386_OpRsh16Ux16(v)
+		return rewriteValue386_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValue386_OpRsh16Ux32(v)
+		return rewriteValue386_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValue386_OpRsh16Ux64(v)
+		return rewriteValue386_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValue386_OpRsh16Ux8(v)
+		return rewriteValue386_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValue386_OpRsh16x16(v)
+		return rewriteValue386_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValue386_OpRsh16x32(v)
+		return rewriteValue386_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValue386_OpRsh16x64(v)
+		return rewriteValue386_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValue386_OpRsh16x8(v)
+		return rewriteValue386_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValue386_OpRsh32Ux16(v)
+		return rewriteValue386_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValue386_OpRsh32Ux32(v)
+		return rewriteValue386_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValue386_OpRsh32Ux64(v)
+		return rewriteValue386_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValue386_OpRsh32Ux8(v)
+		return rewriteValue386_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValue386_OpRsh32x16(v)
+		return rewriteValue386_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValue386_OpRsh32x32(v)
+		return rewriteValue386_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValue386_OpRsh32x64(v)
+		return rewriteValue386_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValue386_OpRsh32x8(v)
+		return rewriteValue386_OpRsh32x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValue386_OpRsh8Ux16(v)
+		return rewriteValue386_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValue386_OpRsh8Ux32(v)
+		return rewriteValue386_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValue386_OpRsh8Ux64(v)
+		return rewriteValue386_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValue386_OpRsh8Ux8(v)
+		return rewriteValue386_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValue386_OpRsh8x16(v)
+		return rewriteValue386_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValue386_OpRsh8x32(v)
+		return rewriteValue386_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValue386_OpRsh8x64(v)
+		return rewriteValue386_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValue386_OpRsh8x8(v)
+		return rewriteValue386_OpRsh8x8_0(v)
 	case OpSignExt16to32:
-		return rewriteValue386_OpSignExt16to32(v)
+		return rewriteValue386_OpSignExt16to32_0(v)
 	case OpSignExt8to16:
-		return rewriteValue386_OpSignExt8to16(v)
+		return rewriteValue386_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValue386_OpSignExt8to32(v)
+		return rewriteValue386_OpSignExt8to32_0(v)
 	case OpSignmask:
-		return rewriteValue386_OpSignmask(v)
+		return rewriteValue386_OpSignmask_0(v)
 	case OpSlicemask:
-		return rewriteValue386_OpSlicemask(v)
+		return rewriteValue386_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValue386_OpSqrt(v)
+		return rewriteValue386_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValue386_OpStaticCall(v)
+		return rewriteValue386_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValue386_OpStore(v)
+		return rewriteValue386_OpStore_0(v)
 	case OpSub16:
-		return rewriteValue386_OpSub16(v)
+		return rewriteValue386_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValue386_OpSub32(v)
+		return rewriteValue386_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValue386_OpSub32F(v)
+		return rewriteValue386_OpSub32F_0(v)
 	case OpSub32carry:
-		return rewriteValue386_OpSub32carry(v)
+		return rewriteValue386_OpSub32carry_0(v)
 	case OpSub32withcarry:
-		return rewriteValue386_OpSub32withcarry(v)
+		return rewriteValue386_OpSub32withcarry_0(v)
 	case OpSub64F:
-		return rewriteValue386_OpSub64F(v)
+		return rewriteValue386_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValue386_OpSub8(v)
+		return rewriteValue386_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValue386_OpSubPtr(v)
+		return rewriteValue386_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValue386_OpTrunc16to8(v)
+		return rewriteValue386_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValue386_OpTrunc32to16(v)
+		return rewriteValue386_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValue386_OpTrunc32to8(v)
+		return rewriteValue386_OpTrunc32to8_0(v)
 	case OpXor16:
-		return rewriteValue386_OpXor16(v)
+		return rewriteValue386_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValue386_OpXor32(v)
+		return rewriteValue386_OpXor32_0(v)
 	case OpXor8:
-		return rewriteValue386_OpXor8(v)
+		return rewriteValue386_OpXor8_0(v)
 	case OpZero:
-		return rewriteValue386_OpZero(v)
+		return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValue386_OpZeroExt16to32(v)
+		return rewriteValue386_OpZeroExt16to32_0(v)
 	case OpZeroExt8to16:
-		return rewriteValue386_OpZeroExt8to16(v)
+		return rewriteValue386_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValue386_OpZeroExt8to32(v)
+		return rewriteValue386_OpZeroExt8to32_0(v)
 	case OpZeromask:
-		return rewriteValue386_OpZeromask(v)
+		return rewriteValue386_OpZeromask_0(v)
 	}
 	return false
 }
-func rewriteValue386_Op386ADCL(v *Value) bool {
+func rewriteValue386_Op386ADCL_0(v *Value) bool {
 	// match: (ADCL x (MOVLconst [c]) f)
 	// cond:
 	// result: (ADCLconst [c] x f)
@@ -661,7 +661,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ADDL(v *Value) bool {
+func rewriteValue386_Op386ADDL_0(v *Value) bool {
 	// match: (ADDL x (MOVLconst [c]))
 	// cond:
 	// result: (ADDLconst [c] x)
@@ -888,6 +888,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ADDL_10(v *Value) bool {
 	// match: (ADDL x (SHLLconst [2] y))
 	// cond:
 	// result: (LEAL4 x y)
@@ -1068,6 +1071,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ADDL_20(v *Value) bool {
 	// match: (ADDL (ADDLconst [c] x) y)
 	// cond:
 	// result: (LEAL1 [c] x y)
@@ -1178,7 +1184,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ADDLcarry(v *Value) bool {
+func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
 	// match: (ADDLcarry x (MOVLconst [c]))
 	// cond:
 	// result: (ADDLconstcarry [c] x)
@@ -1211,7 +1217,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ADDLconst(v *Value) bool {
+func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
 	// match: (ADDLconst [c] (ADDL x y))
 	// cond:
 	// result: (LEAL1 [c] x y)
@@ -1388,7 +1394,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ANDL(v *Value) bool {
+func rewriteValue386_Op386ANDL_0(v *Value) bool {
 	// match: (ANDL x (MOVLconst [c]))
 	// cond:
 	// result: (ANDLconst [c] x)
@@ -1434,7 +1440,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ANDLconst(v *Value) bool {
+func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
 	// match: (ANDLconst [c] (ANDLconst [d] x))
 	// cond:
 	// result: (ANDLconst [c & d] x)
@@ -1493,7 +1499,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPB(v *Value) bool {
+func rewriteValue386_Op386CMPB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPB x (MOVLconst [c]))
@@ -1530,7 +1536,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPBconst(v *Value) bool {
+func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
 	// match: (CMPBconst (MOVLconst [x]) [y])
 	// cond: int8(x)==int8(y)
 	// result: (FlagEQ)
@@ -1678,7 +1684,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPL(v *Value) bool {
+func rewriteValue386_Op386CMPL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPL x (MOVLconst [c]))
@@ -1715,7 +1721,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPLconst(v *Value) bool {
+func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
 	// match: (CMPLconst (MOVLconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -1879,7 +1885,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPW(v *Value) bool {
+func rewriteValue386_Op386CMPW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPW x (MOVLconst [c]))
@@ -1916,7 +1922,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386CMPWconst(v *Value) bool {
+func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
 	// match: (CMPWconst (MOVLconst [x]) [y])
 	// cond: int16(x)==int16(y)
 	// result: (FlagEQ)
@@ -2064,7 +2070,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386LEAL(v *Value) bool {
+func rewriteValue386_Op386LEAL_0(v *Value) bool {
 	// match: (LEAL [c] {s} (ADDLconst [d] x))
 	// cond: is32Bit(c+d)
 	// result: (LEAL [c+d] {s} x)
@@ -2228,7 +2234,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386LEAL1(v *Value) bool {
+func rewriteValue386_Op386LEAL1_0(v *Value) bool {
 	// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAL1 [c+d] {s} x y)
@@ -2457,7 +2463,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386LEAL2(v *Value) bool {
+func rewriteValue386_Op386LEAL2_0(v *Value) bool {
 	// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAL2 [c+d] {s} x y)
@@ -2574,7 +2580,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386LEAL4(v *Value) bool {
+func rewriteValue386_Op386LEAL4_0(v *Value) bool {
 	// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAL4 [c+d] {s} x y)
@@ -2669,7 +2675,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386LEAL8(v *Value) bool {
+func rewriteValue386_Op386LEAL8_0(v *Value) bool {
 	// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAL8 [c+d] {s} x y)
@@ -2742,7 +2748,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBLSX(v *Value) bool {
+func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
@@ -2790,7 +2796,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -2821,7 +2827,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBLZX(v *Value) bool {
+func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
@@ -2893,7 +2899,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBload(v *Value) bool {
+func rewriteValue386_Op386MOVBload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -3020,7 +3026,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
 	// match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
@@ -3111,7 +3117,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBstore(v *Value) bool {
+func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -3379,7 +3385,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -3509,7 +3515,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
 	// match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
 	// cond:
 	// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -3590,7 +3596,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
 	// match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -3985,6 +3991,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool {
 	// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
@@ -4093,7 +4102,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLload(v *Value) bool {
+func rewriteValue386_Op386MOVLload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -4246,7 +4255,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
 	// match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
 	// cond:
 	// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
@@ -4385,7 +4394,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
 	// match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
@@ -4432,7 +4441,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstore(v *Value) bool {
+func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -4595,7 +4604,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -4722,7 +4731,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
 	// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
 	// cond:
 	// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
@@ -4793,7 +4802,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
 	// match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem)
 	// cond:
 	// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -4840,7 +4849,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
 	// match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem)
 	// cond:
 	// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
@@ -4991,7 +5000,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
 	// match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -5042,7 +5051,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDconst(v *Value) bool {
+func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5065,7 +5074,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDload(v *Value) bool {
+func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5195,7 +5204,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
 	// match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSDloadidx1 [c+d] {sym} ptr idx mem)
@@ -5242,7 +5251,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
 	// match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
@@ -5289,7 +5298,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDstore(v *Value) bool {
+func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5429,7 +5438,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
 	// match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSDstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -5480,7 +5489,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
 	// match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -5531,7 +5540,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSconst(v *Value) bool {
+func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5554,7 +5563,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSload(v *Value) bool {
+func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5684,7 +5693,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
 	// match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSSloadidx1 [c+d] {sym} ptr idx mem)
@@ -5731,7 +5740,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
 	// match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
@@ -5778,7 +5787,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSstore(v *Value) bool {
+func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5918,7 +5927,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
 	// match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSSstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -5969,7 +5978,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
 	// match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -6020,7 +6029,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWLSX(v *Value) bool {
+func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
@@ -6068,7 +6077,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6099,7 +6108,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWLZX(v *Value) bool {
+func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
@@ -6198,7 +6207,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWload(v *Value) bool {
+func rewriteValue386_Op386MOVWload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6351,7 +6360,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
 	// match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
 	// cond:
 	// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
@@ -6490,7 +6499,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWloadidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
 	// match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
@@ -6537,7 +6546,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstore(v *Value) bool {
+func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6833,7 +6842,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6989,7 +6998,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
 	// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
 	// cond:
 	// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
@@ -7094,7 +7103,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem)
@@ -7180,7 +7189,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
 	// match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem)
 	// cond:
 	// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
@@ -7521,6 +7530,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool {
 	// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
@@ -7735,7 +7747,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem)
@@ -7895,7 +7907,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MULL(v *Value) bool {
+func rewriteValue386_Op386MULL_0(v *Value) bool {
 	// match: (MULL x (MOVLconst [c]))
 	// cond:
 	// result: (MULLconst [c] x)
@@ -7928,7 +7940,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386MULLconst(v *Value) bool {
+func rewriteValue386_Op386MULLconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MULLconst [c] (MULLconst [d] x))
@@ -8069,6 +8081,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386MULLconst_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULLconst [21] x)
 	// cond:
 	// result: (LEAL4 x (LEAL4 <v.Type> x x))
@@ -8231,6 +8248,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386MULLconst_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULLconst [c] x)
 	// cond: isPowerOfTwo(c-8) && c >= 136
 	// result: (LEAL8 (SHLLconst <v.Type> [log2(c-8)] x) x)
@@ -8315,7 +8337,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386NEGL(v *Value) bool {
+func rewriteValue386_Op386NEGL_0(v *Value) bool {
 	// match: (NEGL (MOVLconst [c]))
 	// cond:
 	// result: (MOVLconst [int64(int32(-c))])
@@ -8331,7 +8353,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386NOTL(v *Value) bool {
+func rewriteValue386_Op386NOTL_0(v *Value) bool {
 	// match: (NOTL (MOVLconst [c]))
 	// cond:
 	// result: (MOVLconst [^c])
@@ -8347,7 +8369,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ORL(v *Value) bool {
+func rewriteValue386_Op386ORL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8601,6 +8623,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ORL_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
 	// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
@@ -9186,6 +9215,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ORL_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -9892,6 +9926,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ORL_30(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -10682,6 +10721,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ORL_40(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -11472,6 +11516,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValue386_Op386ORL_50(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -11869,7 +11918,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ORLconst(v *Value) bool {
+func rewriteValue386_Op386ORLconst_0(v *Value) bool {
 	// match: (ORLconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -11912,7 +11961,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ROLBconst(v *Value) bool {
+func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
 	// match: (ROLBconst [c] (ROLBconst [d] x))
 	// cond:
 	// result: (ROLBconst [(c+d)& 7] x)
@@ -11944,7 +11993,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ROLLconst(v *Value) bool {
+func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
 	// match: (ROLLconst [c] (ROLLconst [d] x))
 	// cond:
 	// result: (ROLLconst [(c+d)&31] x)
@@ -11976,7 +12025,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386ROLWconst(v *Value) bool {
+func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
 	// match: (ROLWconst [c] (ROLWconst [d] x))
 	// cond:
 	// result: (ROLWconst [(c+d)&15] x)
@@ -12008,7 +12057,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARB(v *Value) bool {
+func rewriteValue386_Op386SARB_0(v *Value) bool {
 	// match: (SARB x (MOVLconst [c]))
 	// cond:
 	// result: (SARBconst [min(c&31,7)] x)
@@ -12026,7 +12075,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARBconst(v *Value) bool {
+func rewriteValue386_Op386SARBconst_0(v *Value) bool {
 	// match: (SARBconst x [0])
 	// cond:
 	// result: x
@@ -12056,7 +12105,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARL(v *Value) bool {
+func rewriteValue386_Op386SARL_0(v *Value) bool {
 	// match: (SARL x (MOVLconst [c]))
 	// cond:
 	// result: (SARLconst [c&31] x)
@@ -12092,7 +12141,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARLconst(v *Value) bool {
+func rewriteValue386_Op386SARLconst_0(v *Value) bool {
 	// match: (SARLconst x [0])
 	// cond:
 	// result: x
@@ -12122,7 +12171,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARW(v *Value) bool {
+func rewriteValue386_Op386SARW_0(v *Value) bool {
 	// match: (SARW x (MOVLconst [c]))
 	// cond:
 	// result: (SARWconst [min(c&31,15)] x)
@@ -12140,7 +12189,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SARWconst(v *Value) bool {
+func rewriteValue386_Op386SARWconst_0(v *Value) bool {
 	// match: (SARWconst x [0])
 	// cond:
 	// result: x
@@ -12170,7 +12219,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SBBL(v *Value) bool {
+func rewriteValue386_Op386SBBL_0(v *Value) bool {
 	// match: (SBBL x (MOVLconst [c]) f)
 	// cond:
 	// result: (SBBLconst [c] x f)
@@ -12190,7 +12239,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SBBLcarrymask(v *Value) bool {
+func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
 	// match: (SBBLcarrymask (FlagEQ))
 	// cond:
 	// result: (MOVLconst [0])
@@ -12253,7 +12302,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETA(v *Value) bool {
+func rewriteValue386_Op386SETA_0(v *Value) bool {
 	// match: (SETA (InvertFlags x))
 	// cond:
 	// result: (SETB x)
@@ -12329,7 +12378,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETAE(v *Value) bool {
+func rewriteValue386_Op386SETAE_0(v *Value) bool {
 	// match: (SETAE (InvertFlags x))
 	// cond:
 	// result: (SETBE x)
@@ -12405,7 +12454,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETB(v *Value) bool {
+func rewriteValue386_Op386SETB_0(v *Value) bool {
 	// match: (SETB (InvertFlags x))
 	// cond:
 	// result: (SETA x)
@@ -12481,7 +12530,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETBE(v *Value) bool {
+func rewriteValue386_Op386SETBE_0(v *Value) bool {
 	// match: (SETBE (InvertFlags x))
 	// cond:
 	// result: (SETAE x)
@@ -12557,7 +12606,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETEQ(v *Value) bool {
+func rewriteValue386_Op386SETEQ_0(v *Value) bool {
 	// match: (SETEQ (InvertFlags x))
 	// cond:
 	// result: (SETEQ x)
@@ -12633,7 +12682,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETG(v *Value) bool {
+func rewriteValue386_Op386SETG_0(v *Value) bool {
 	// match: (SETG (InvertFlags x))
 	// cond:
 	// result: (SETL x)
@@ -12709,7 +12758,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETGE(v *Value) bool {
+func rewriteValue386_Op386SETGE_0(v *Value) bool {
 	// match: (SETGE (InvertFlags x))
 	// cond:
 	// result: (SETLE x)
@@ -12785,7 +12834,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETL(v *Value) bool {
+func rewriteValue386_Op386SETL_0(v *Value) bool {
 	// match: (SETL (InvertFlags x))
 	// cond:
 	// result: (SETG x)
@@ -12861,7 +12910,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETLE(v *Value) bool {
+func rewriteValue386_Op386SETLE_0(v *Value) bool {
 	// match: (SETLE (InvertFlags x))
 	// cond:
 	// result: (SETGE x)
@@ -12937,7 +12986,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SETNE(v *Value) bool {
+func rewriteValue386_Op386SETNE_0(v *Value) bool {
 	// match: (SETNE (InvertFlags x))
 	// cond:
 	// result: (SETNE x)
@@ -13013,7 +13062,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHLL(v *Value) bool {
+func rewriteValue386_Op386SHLL_0(v *Value) bool {
 	// match: (SHLL x (MOVLconst [c]))
 	// cond:
 	// result: (SHLLconst [c&31] x)
@@ -13049,7 +13098,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHLLconst(v *Value) bool {
+func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
 	// match: (SHLLconst x [0])
 	// cond:
 	// result: x
@@ -13065,7 +13114,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRB(v *Value) bool {
+func rewriteValue386_Op386SHRB_0(v *Value) bool {
 	// match: (SHRB x (MOVLconst [c]))
 	// cond: c&31 < 8
 	// result: (SHRBconst [c&31] x)
@@ -13102,7 +13151,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRBconst(v *Value) bool {
+func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
 	// match: (SHRBconst x [0])
 	// cond:
 	// result: x
@@ -13118,7 +13167,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRL(v *Value) bool {
+func rewriteValue386_Op386SHRL_0(v *Value) bool {
 	// match: (SHRL x (MOVLconst [c]))
 	// cond:
 	// result: (SHRLconst [c&31] x)
@@ -13154,7 +13203,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRLconst(v *Value) bool {
+func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
 	// match: (SHRLconst x [0])
 	// cond:
 	// result: x
@@ -13170,7 +13219,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRW(v *Value) bool {
+func rewriteValue386_Op386SHRW_0(v *Value) bool {
 	// match: (SHRW x (MOVLconst [c]))
 	// cond: c&31 < 16
 	// result: (SHRWconst [c&31] x)
@@ -13207,7 +13256,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SHRWconst(v *Value) bool {
+func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
 	// match: (SHRWconst x [0])
 	// cond:
 	// result: x
@@ -13223,7 +13272,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SUBL(v *Value) bool {
+func rewriteValue386_Op386SUBL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBL x (MOVLconst [c]))
@@ -13272,7 +13321,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SUBLcarry(v *Value) bool {
+func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
 	// match: (SUBLcarry x (MOVLconst [c]))
 	// cond:
 	// result: (SUBLconstcarry [c] x)
@@ -13290,7 +13339,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386SUBLconst(v *Value) bool {
+func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
 	// match: (SUBLconst [c] x)
 	// cond: int32(c) == 0
 	// result: x
@@ -13317,7 +13366,7 @@
 		return true
 	}
 }
-func rewriteValue386_Op386XORL(v *Value) bool {
+func rewriteValue386_Op386XORL_0(v *Value) bool {
 	// match: (XORL x (MOVLconst [c]))
 	// cond:
 	// result: (XORLconst [c] x)
@@ -13522,7 +13571,7 @@
 	}
 	return false
 }
-func rewriteValue386_Op386XORLconst(v *Value) bool {
+func rewriteValue386_Op386XORLconst_0(v *Value) bool {
 	// match: (XORLconst [c] (XORLconst [d] x))
 	// cond:
 	// result: (XORLconst [c ^ d] x)
@@ -13569,7 +13618,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpAdd16(v *Value) bool {
+func rewriteValue386_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -13582,7 +13631,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd32(v *Value) bool {
+func rewriteValue386_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -13595,7 +13644,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd32F(v *Value) bool {
+func rewriteValue386_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (ADDSS x y)
@@ -13608,7 +13657,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd32carry(v *Value) bool {
+func rewriteValue386_OpAdd32carry_0(v *Value) bool {
 	// match: (Add32carry x y)
 	// cond:
 	// result: (ADDLcarry x y)
@@ -13621,7 +13670,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd32withcarry(v *Value) bool {
+func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
 	// match: (Add32withcarry x y c)
 	// cond:
 	// result: (ADCL x y c)
@@ -13636,7 +13685,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd64F(v *Value) bool {
+func rewriteValue386_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (ADDSD x y)
@@ -13649,7 +13698,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAdd8(v *Value) bool {
+func rewriteValue386_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -13662,7 +13711,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAddPtr(v *Value) bool {
+func rewriteValue386_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -13675,7 +13724,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAddr(v *Value) bool {
+func rewriteValue386_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (LEAL {sym} base)
@@ -13688,7 +13737,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAnd16(v *Value) bool {
+func rewriteValue386_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -13701,7 +13750,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAnd32(v *Value) bool {
+func rewriteValue386_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -13714,7 +13763,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAnd8(v *Value) bool {
+func rewriteValue386_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -13727,7 +13776,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAndB(v *Value) bool {
+func rewriteValue386_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (ANDL x y)
@@ -13740,7 +13789,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpAvg32u(v *Value) bool {
+func rewriteValue386_OpAvg32u_0(v *Value) bool {
 	// match: (Avg32u x y)
 	// cond:
 	// result: (AVGLU x y)
@@ -13753,7 +13802,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpBswap32(v *Value) bool {
+func rewriteValue386_OpBswap32_0(v *Value) bool {
 	// match: (Bswap32 x)
 	// cond:
 	// result: (BSWAPL x)
@@ -13764,7 +13813,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpClosureCall(v *Value) bool {
+func rewriteValue386_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -13781,7 +13830,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCom16(v *Value) bool {
+func rewriteValue386_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (NOTL x)
@@ -13792,7 +13841,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCom32(v *Value) bool {
+func rewriteValue386_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (NOTL x)
@@ -13803,7 +13852,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCom8(v *Value) bool {
+func rewriteValue386_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (NOTL x)
@@ -13814,7 +13863,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConst16(v *Value) bool {
+func rewriteValue386_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -13825,7 +13874,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConst32(v *Value) bool {
+func rewriteValue386_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -13836,7 +13885,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConst32F(v *Value) bool {
+func rewriteValue386_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (MOVSSconst [val])
@@ -13847,7 +13896,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConst64F(v *Value) bool {
+func rewriteValue386_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (MOVSDconst [val])
@@ -13858,7 +13907,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConst8(v *Value) bool {
+func rewriteValue386_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -13869,7 +13918,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConstBool(v *Value) bool {
+func rewriteValue386_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVLconst [b])
@@ -13880,7 +13929,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConstNil(v *Value) bool {
+func rewriteValue386_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVLconst [0])
@@ -13890,7 +13939,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpConvert(v *Value) bool {
+func rewriteValue386_OpConvert_0(v *Value) bool {
 	// match: (Convert <t> x mem)
 	// cond:
 	// result: (MOVLconvert <t> x mem)
@@ -13905,7 +13954,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt32Fto32(v *Value) bool {
+func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (CVTTSS2SL x)
@@ -13916,7 +13965,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt32Fto64F(v *Value) bool {
+func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (CVTSS2SD x)
@@ -13927,7 +13976,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt32to32F(v *Value) bool {
+func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (CVTSL2SS x)
@@ -13938,7 +13987,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt32to64F(v *Value) bool {
+func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (CVTSL2SD x)
@@ -13949,7 +13998,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt64Fto32(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (CVTTSD2SL x)
@@ -13960,7 +14009,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpCvt64Fto32F(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (CVTSD2SS x)
@@ -13971,7 +14020,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv16(v *Value) bool {
+func rewriteValue386_OpDiv16_0(v *Value) bool {
 	// match: (Div16 x y)
 	// cond:
 	// result: (DIVW  x y)
@@ -13984,7 +14033,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv16u(v *Value) bool {
+func rewriteValue386_OpDiv16u_0(v *Value) bool {
 	// match: (Div16u x y)
 	// cond:
 	// result: (DIVWU x y)
@@ -13997,7 +14046,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv32(v *Value) bool {
+func rewriteValue386_OpDiv32_0(v *Value) bool {
 	// match: (Div32 x y)
 	// cond:
 	// result: (DIVL  x y)
@@ -14010,7 +14059,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv32F(v *Value) bool {
+func rewriteValue386_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (DIVSS x y)
@@ -14023,7 +14072,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv32u(v *Value) bool {
+func rewriteValue386_OpDiv32u_0(v *Value) bool {
 	// match: (Div32u x y)
 	// cond:
 	// result: (DIVLU x y)
@@ -14036,7 +14085,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv64F(v *Value) bool {
+func rewriteValue386_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (DIVSD x y)
@@ -14049,7 +14098,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv8(v *Value) bool {
+func rewriteValue386_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14070,7 +14119,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpDiv8u(v *Value) bool {
+func rewriteValue386_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14091,7 +14140,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEq16(v *Value) bool {
+func rewriteValue386_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq16 x y)
@@ -14108,7 +14157,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEq32(v *Value) bool {
+func rewriteValue386_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x y)
@@ -14125,7 +14174,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEq32F(v *Value) bool {
+func rewriteValue386_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -14142,7 +14191,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEq64F(v *Value) bool {
+func rewriteValue386_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -14159,7 +14208,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEq8(v *Value) bool {
+func rewriteValue386_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq8 x y)
@@ -14176,7 +14225,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEqB(v *Value) bool {
+func rewriteValue386_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqB x y)
@@ -14193,7 +14242,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpEqPtr(v *Value) bool {
+func rewriteValue386_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqPtr x y)
@@ -14210,7 +14259,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq16(v *Value) bool {
+func rewriteValue386_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq16 x y)
@@ -14227,7 +14276,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq16U(v *Value) bool {
+func rewriteValue386_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq16U x y)
@@ -14244,7 +14293,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq32(v *Value) bool {
+func rewriteValue386_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32 x y)
@@ -14261,7 +14310,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq32F(v *Value) bool {
+func rewriteValue386_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -14278,7 +14327,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq32U(v *Value) bool {
+func rewriteValue386_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32U x y)
@@ -14295,7 +14344,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq64F(v *Value) bool {
+func rewriteValue386_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -14312,7 +14361,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq8(v *Value) bool {
+func rewriteValue386_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq8 x y)
@@ -14329,7 +14378,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGeq8U(v *Value) bool {
+func rewriteValue386_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq8U x y)
@@ -14346,7 +14395,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGetClosurePtr(v *Value) bool {
+func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -14355,7 +14404,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGetG(v *Value) bool {
+func rewriteValue386_OpGetG_0(v *Value) bool {
 	// match: (GetG mem)
 	// cond:
 	// result: (LoweredGetG mem)
@@ -14366,7 +14415,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater16(v *Value) bool {
+func rewriteValue386_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater16 x y)
@@ -14383,7 +14432,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater16U(v *Value) bool {
+func rewriteValue386_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater16U x y)
@@ -14400,7 +14449,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater32(v *Value) bool {
+func rewriteValue386_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32 x y)
@@ -14417,7 +14466,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater32F(v *Value) bool {
+func rewriteValue386_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -14434,7 +14483,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater32U(v *Value) bool {
+func rewriteValue386_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32U x y)
@@ -14451,7 +14500,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater64F(v *Value) bool {
+func rewriteValue386_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -14468,7 +14517,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater8(v *Value) bool {
+func rewriteValue386_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater8 x y)
@@ -14485,7 +14534,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpGreater8U(v *Value) bool {
+func rewriteValue386_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater8U x y)
@@ -14502,7 +14551,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpHmul32(v *Value) bool {
+func rewriteValue386_OpHmul32_0(v *Value) bool {
 	// match: (Hmul32 x y)
 	// cond:
 	// result: (HMULL  x y)
@@ -14515,7 +14564,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpHmul32u(v *Value) bool {
+func rewriteValue386_OpHmul32u_0(v *Value) bool {
 	// match: (Hmul32u x y)
 	// cond:
 	// result: (HMULLU x y)
@@ -14528,7 +14577,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpInterCall(v *Value) bool {
+func rewriteValue386_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -14543,7 +14592,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpIsInBounds(v *Value) bool {
+func rewriteValue386_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsInBounds idx len)
@@ -14560,7 +14609,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpIsNonNil(v *Value) bool {
+func rewriteValue386_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsNonNil p)
@@ -14576,7 +14625,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpIsSliceInBounds(v *Value) bool {
+func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsSliceInBounds idx len)
@@ -14593,7 +14642,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq16(v *Value) bool {
+func rewriteValue386_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq16 x y)
@@ -14610,7 +14659,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq16U(v *Value) bool {
+func rewriteValue386_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq16U x y)
@@ -14627,7 +14676,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq32(v *Value) bool {
+func rewriteValue386_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32 x y)
@@ -14644,7 +14693,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq32F(v *Value) bool {
+func rewriteValue386_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -14661,7 +14710,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq32U(v *Value) bool {
+func rewriteValue386_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32U x y)
@@ -14678,7 +14727,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq64F(v *Value) bool {
+func rewriteValue386_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -14695,7 +14744,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq8(v *Value) bool {
+func rewriteValue386_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq8 x y)
@@ -14712,7 +14761,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLeq8U(v *Value) bool {
+func rewriteValue386_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq8U x y)
@@ -14729,7 +14778,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess16(v *Value) bool {
+func rewriteValue386_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less16 x y)
@@ -14746,7 +14795,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess16U(v *Value) bool {
+func rewriteValue386_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less16U x y)
@@ -14763,7 +14812,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess32(v *Value) bool {
+func rewriteValue386_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32 x y)
@@ -14780,7 +14829,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess32F(v *Value) bool {
+func rewriteValue386_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -14797,7 +14846,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess32U(v *Value) bool {
+func rewriteValue386_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32U x y)
@@ -14814,7 +14863,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess64F(v *Value) bool {
+func rewriteValue386_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -14831,7 +14880,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess8(v *Value) bool {
+func rewriteValue386_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less8 x y)
@@ -14848,7 +14897,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLess8U(v *Value) bool {
+func rewriteValue386_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less8U x y)
@@ -14865,7 +14914,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLoad(v *Value) bool {
+func rewriteValue386_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: (is32BitInt(t) || isPtr(t))
 	// result: (MOVLload ptr mem)
@@ -14943,7 +14992,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpLsh16x16(v *Value) bool {
+func rewriteValue386_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x16 <t> x y)
@@ -14967,7 +15016,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh16x32(v *Value) bool {
+func rewriteValue386_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x32 <t> x y)
@@ -14991,7 +15040,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh16x64(v *Value) bool {
+func rewriteValue386_OpLsh16x64_0(v *Value) bool {
 	// match: (Lsh16x64 x (Const64 [c]))
 	// cond: uint64(c) < 16
 	// result: (SHLLconst x [c])
@@ -15028,7 +15077,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpLsh16x8(v *Value) bool {
+func rewriteValue386_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x8 <t> x y)
@@ -15052,7 +15101,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh32x16(v *Value) bool {
+func rewriteValue386_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x16 <t> x y)
@@ -15076,7 +15125,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh32x32(v *Value) bool {
+func rewriteValue386_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x32 <t> x y)
@@ -15100,7 +15149,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh32x64(v *Value) bool {
+func rewriteValue386_OpLsh32x64_0(v *Value) bool {
 	// match: (Lsh32x64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SHLLconst x [c])
@@ -15137,7 +15186,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpLsh32x8(v *Value) bool {
+func rewriteValue386_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x8 <t> x y)
@@ -15161,7 +15210,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh8x16(v *Value) bool {
+func rewriteValue386_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x16 <t> x y)
@@ -15185,7 +15234,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh8x32(v *Value) bool {
+func rewriteValue386_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x32 <t> x y)
@@ -15209,7 +15258,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpLsh8x64(v *Value) bool {
+func rewriteValue386_OpLsh8x64_0(v *Value) bool {
 	// match: (Lsh8x64 x (Const64 [c]))
 	// cond: uint64(c) < 8
 	// result: (SHLLconst x [c])
@@ -15246,7 +15295,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpLsh8x8(v *Value) bool {
+func rewriteValue386_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x8 <t> x y)
@@ -15270,7 +15319,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod16(v *Value) bool {
+func rewriteValue386_OpMod16_0(v *Value) bool {
 	// match: (Mod16 x y)
 	// cond:
 	// result: (MODW  x y)
@@ -15283,7 +15332,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod16u(v *Value) bool {
+func rewriteValue386_OpMod16u_0(v *Value) bool {
 	// match: (Mod16u x y)
 	// cond:
 	// result: (MODWU x y)
@@ -15296,7 +15345,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod32(v *Value) bool {
+func rewriteValue386_OpMod32_0(v *Value) bool {
 	// match: (Mod32 x y)
 	// cond:
 	// result: (MODL  x y)
@@ -15309,7 +15358,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod32u(v *Value) bool {
+func rewriteValue386_OpMod32u_0(v *Value) bool {
 	// match: (Mod32u x y)
 	// cond:
 	// result: (MODLU x y)
@@ -15322,7 +15371,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod8(v *Value) bool {
+func rewriteValue386_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15343,7 +15392,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMod8u(v *Value) bool {
+func rewriteValue386_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15364,11 +15413,9 @@
 		return true
 	}
 }
-func rewriteValue386_OpMove(v *Value) bool {
+func rewriteValue386_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Move [0] _ _ mem)
@@ -15612,6 +15659,15 @@
 		v.AddArg(v2)
 		return true
 	}
+	return false
+}
+func rewriteValue386_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [s] dst src mem)
 	// cond: s > 8 && s <= 4*128 && s%4 == 0 	&& !config.noDuffDevice
 	// result: (DUFFCOPY [10*(128-s/4)] dst src mem)
@@ -15652,7 +15708,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpMul16(v *Value) bool {
+func rewriteValue386_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -15665,7 +15721,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMul32(v *Value) bool {
+func rewriteValue386_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -15678,7 +15734,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMul32F(v *Value) bool {
+func rewriteValue386_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (MULSS x y)
@@ -15691,7 +15747,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMul32uhilo(v *Value) bool {
+func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
 	// match: (Mul32uhilo x y)
 	// cond:
 	// result: (MULLQU x y)
@@ -15704,7 +15760,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMul64F(v *Value) bool {
+func rewriteValue386_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (MULSD x y)
@@ -15717,7 +15773,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpMul8(v *Value) bool {
+func rewriteValue386_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -15730,7 +15786,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeg16(v *Value) bool {
+func rewriteValue386_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEGL x)
@@ -15741,7 +15797,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeg32(v *Value) bool {
+func rewriteValue386_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEGL x)
@@ -15752,7 +15808,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeg32F(v *Value) bool {
+func rewriteValue386_OpNeg32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -15788,7 +15844,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpNeg64F(v *Value) bool {
+func rewriteValue386_OpNeg64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -15824,7 +15880,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpNeg8(v *Value) bool {
+func rewriteValue386_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEGL x)
@@ -15835,7 +15891,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeq16(v *Value) bool {
+func rewriteValue386_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq16 x y)
@@ -15852,7 +15908,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeq32(v *Value) bool {
+func rewriteValue386_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x y)
@@ -15869,7 +15925,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeq32F(v *Value) bool {
+func rewriteValue386_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -15886,7 +15942,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeq64F(v *Value) bool {
+func rewriteValue386_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -15903,7 +15959,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeq8(v *Value) bool {
+func rewriteValue386_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq8 x y)
@@ -15920,7 +15976,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeqB(v *Value) bool {
+func rewriteValue386_OpNeqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqB x y)
@@ -15937,7 +15993,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNeqPtr(v *Value) bool {
+func rewriteValue386_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqPtr x y)
@@ -15954,7 +16010,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNilCheck(v *Value) bool {
+func rewriteValue386_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -15967,7 +16023,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpNot(v *Value) bool {
+func rewriteValue386_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORLconst [1] x)
@@ -15979,7 +16035,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpOffPtr(v *Value) bool {
+func rewriteValue386_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr [off] ptr)
 	// cond:
 	// result: (ADDLconst [off] ptr)
@@ -15992,7 +16048,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpOr16(v *Value) bool {
+func rewriteValue386_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (ORL x y)
@@ -16005,7 +16061,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpOr32(v *Value) bool {
+func rewriteValue386_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (ORL x y)
@@ -16018,7 +16074,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpOr8(v *Value) bool {
+func rewriteValue386_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (ORL x y)
@@ -16031,7 +16087,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpOrB(v *Value) bool {
+func rewriteValue386_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (ORL x y)
@@ -16044,7 +16100,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRound32F(v *Value) bool {
+func rewriteValue386_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -16056,7 +16112,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRound64F(v *Value) bool {
+func rewriteValue386_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -16068,7 +16124,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16Ux16(v *Value) bool {
+func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux16 <t> x y)
@@ -16092,7 +16148,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16Ux32(v *Value) bool {
+func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux32 <t> x y)
@@ -16116,7 +16172,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16Ux64(v *Value) bool {
+func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
 	// match: (Rsh16Ux64 x (Const64 [c]))
 	// cond: uint64(c) < 16
 	// result: (SHRWconst x [c])
@@ -16153,7 +16209,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh16Ux8(v *Value) bool {
+func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux8 <t> x y)
@@ -16177,7 +16233,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16x16(v *Value) bool {
+func rewriteValue386_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x16 <t> x y)
@@ -16204,7 +16260,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16x32(v *Value) bool {
+func rewriteValue386_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x32 <t> x y)
@@ -16231,7 +16287,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh16x64(v *Value) bool {
+func rewriteValue386_OpRsh16x64_0(v *Value) bool {
 	// match: (Rsh16x64 x (Const64 [c]))
 	// cond: uint64(c) < 16
 	// result: (SARWconst x [c])
@@ -16270,7 +16326,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh16x8(v *Value) bool {
+func rewriteValue386_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x8 <t> x y)
@@ -16297,7 +16353,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32Ux16(v *Value) bool {
+func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux16 <t> x y)
@@ -16321,7 +16377,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32Ux32(v *Value) bool {
+func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux32 <t> x y)
@@ -16345,7 +16401,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32Ux64(v *Value) bool {
+func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
 	// match: (Rsh32Ux64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SHRLconst x [c])
@@ -16382,7 +16438,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh32Ux8(v *Value) bool {
+func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux8 <t> x y)
@@ -16406,7 +16462,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32x16(v *Value) bool {
+func rewriteValue386_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x16 <t> x y)
@@ -16433,7 +16489,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32x32(v *Value) bool {
+func rewriteValue386_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x32 <t> x y)
@@ -16460,7 +16516,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh32x64(v *Value) bool {
+func rewriteValue386_OpRsh32x64_0(v *Value) bool {
 	// match: (Rsh32x64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SARLconst x [c])
@@ -16499,7 +16555,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh32x8(v *Value) bool {
+func rewriteValue386_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x8 <t> x y)
@@ -16526,7 +16582,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8Ux16(v *Value) bool {
+func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux16 <t> x y)
@@ -16550,7 +16606,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8Ux32(v *Value) bool {
+func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux32 <t> x y)
@@ -16574,7 +16630,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8Ux64(v *Value) bool {
+func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
 	// match: (Rsh8Ux64 x (Const64 [c]))
 	// cond: uint64(c) < 8
 	// result: (SHRBconst x [c])
@@ -16611,7 +16667,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh8Ux8(v *Value) bool {
+func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux8 <t> x y)
@@ -16635,7 +16691,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8x16(v *Value) bool {
+func rewriteValue386_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x16 <t> x y)
@@ -16662,7 +16718,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8x32(v *Value) bool {
+func rewriteValue386_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x32 <t> x y)
@@ -16689,7 +16745,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpRsh8x64(v *Value) bool {
+func rewriteValue386_OpRsh8x64_0(v *Value) bool {
 	// match: (Rsh8x64 x (Const64 [c]))
 	// cond: uint64(c) < 8
 	// result: (SARBconst x [c])
@@ -16728,7 +16784,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpRsh8x8(v *Value) bool {
+func rewriteValue386_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x8 <t> x y)
@@ -16755,7 +16811,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSignExt16to32(v *Value) bool {
+func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVWLSX x)
@@ -16766,7 +16822,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSignExt8to16(v *Value) bool {
+func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBLSX x)
@@ -16777,7 +16833,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSignExt8to32(v *Value) bool {
+func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBLSX x)
@@ -16788,7 +16844,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSignmask(v *Value) bool {
+func rewriteValue386_OpSignmask_0(v *Value) bool {
 	// match: (Signmask x)
 	// cond:
 	// result: (SARLconst x [31])
@@ -16800,7 +16856,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSlicemask(v *Value) bool {
+func rewriteValue386_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -16817,7 +16873,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSqrt(v *Value) bool {
+func rewriteValue386_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (SQRTSD x)
@@ -16828,7 +16884,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpStaticCall(v *Value) bool {
+func rewriteValue386_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -16843,7 +16899,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpStore(v *Value) bool {
+func rewriteValue386_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
 	// result: (MOVSDstore ptr val mem)
@@ -16931,7 +16987,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpSub16(v *Value) bool {
+func rewriteValue386_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -16944,7 +17000,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub32(v *Value) bool {
+func rewriteValue386_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -16957,7 +17013,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub32F(v *Value) bool {
+func rewriteValue386_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (SUBSS x y)
@@ -16970,7 +17026,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub32carry(v *Value) bool {
+func rewriteValue386_OpSub32carry_0(v *Value) bool {
 	// match: (Sub32carry x y)
 	// cond:
 	// result: (SUBLcarry x y)
@@ -16983,7 +17039,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub32withcarry(v *Value) bool {
+func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
 	// match: (Sub32withcarry x y c)
 	// cond:
 	// result: (SBBL x y c)
@@ -16998,7 +17054,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub64F(v *Value) bool {
+func rewriteValue386_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (SUBSD x y)
@@ -17011,7 +17067,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSub8(v *Value) bool {
+func rewriteValue386_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -17024,7 +17080,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpSubPtr(v *Value) bool {
+func rewriteValue386_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -17037,7 +17093,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpTrunc16to8(v *Value) bool {
+func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -17049,7 +17105,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpTrunc32to16(v *Value) bool {
+func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -17061,7 +17117,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpTrunc32to8(v *Value) bool {
+func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -17073,7 +17129,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpXor16(v *Value) bool {
+func rewriteValue386_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XORL x y)
@@ -17086,7 +17142,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpXor32(v *Value) bool {
+func rewriteValue386_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XORL x y)
@@ -17099,7 +17155,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpXor8(v *Value) bool {
+func rewriteValue386_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XORL x y)
@@ -17112,11 +17168,9 @@
 		return true
 	}
 }
-func rewriteValue386_OpZero(v *Value) bool {
+func rewriteValue386_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Zero [0] _ mem)
@@ -17295,6 +17349,15 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValue386_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Zero [12] destptr mem)
 	// cond:
 	// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr 		(MOVLstoreconst [makeValAndOff(0,4)] destptr 			(MOVLstoreconst [0] destptr mem)))
@@ -17387,7 +17450,7 @@
 	}
 	return false
 }
-func rewriteValue386_OpZeroExt16to32(v *Value) bool {
+func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVWLZX x)
@@ -17398,7 +17461,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpZeroExt8to16(v *Value) bool {
+func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBLZX x)
@@ -17409,7 +17472,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpZeroExt8to32(v *Value) bool {
+func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBLZX x)
@@ -17420,7 +17483,7 @@
 		return true
 	}
 }
-func rewriteValue386_OpZeromask(v *Value) bool {
+func rewriteValue386_OpZeromask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Zeromask <t> x)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 9f9fe3b..4bd2a79 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -14,849 +14,849 @@
 func rewriteValueAMD64(v *Value) bool {
 	switch v.Op {
 	case OpAMD64ADDL:
-		return rewriteValueAMD64_OpAMD64ADDL(v)
+		return rewriteValueAMD64_OpAMD64ADDL_0(v) || rewriteValueAMD64_OpAMD64ADDL_10(v)
 	case OpAMD64ADDLconst:
-		return rewriteValueAMD64_OpAMD64ADDLconst(v)
+		return rewriteValueAMD64_OpAMD64ADDLconst_0(v)
 	case OpAMD64ADDQ:
-		return rewriteValueAMD64_OpAMD64ADDQ(v)
+		return rewriteValueAMD64_OpAMD64ADDQ_0(v) || rewriteValueAMD64_OpAMD64ADDQ_10(v) || rewriteValueAMD64_OpAMD64ADDQ_20(v)
 	case OpAMD64ADDQconst:
-		return rewriteValueAMD64_OpAMD64ADDQconst(v)
+		return rewriteValueAMD64_OpAMD64ADDQconst_0(v)
 	case OpAMD64ADDSD:
-		return rewriteValueAMD64_OpAMD64ADDSD(v)
+		return rewriteValueAMD64_OpAMD64ADDSD_0(v)
 	case OpAMD64ADDSS:
-		return rewriteValueAMD64_OpAMD64ADDSS(v)
+		return rewriteValueAMD64_OpAMD64ADDSS_0(v)
 	case OpAMD64ANDL:
-		return rewriteValueAMD64_OpAMD64ANDL(v)
+		return rewriteValueAMD64_OpAMD64ANDL_0(v)
 	case OpAMD64ANDLconst:
-		return rewriteValueAMD64_OpAMD64ANDLconst(v)
+		return rewriteValueAMD64_OpAMD64ANDLconst_0(v)
 	case OpAMD64ANDQ:
-		return rewriteValueAMD64_OpAMD64ANDQ(v)
+		return rewriteValueAMD64_OpAMD64ANDQ_0(v)
 	case OpAMD64ANDQconst:
-		return rewriteValueAMD64_OpAMD64ANDQconst(v)
+		return rewriteValueAMD64_OpAMD64ANDQconst_0(v)
 	case OpAMD64BSFQ:
-		return rewriteValueAMD64_OpAMD64BSFQ(v)
+		return rewriteValueAMD64_OpAMD64BSFQ_0(v)
 	case OpAMD64BTQconst:
-		return rewriteValueAMD64_OpAMD64BTQconst(v)
+		return rewriteValueAMD64_OpAMD64BTQconst_0(v)
 	case OpAMD64CMOVQEQ:
-		return rewriteValueAMD64_OpAMD64CMOVQEQ(v)
+		return rewriteValueAMD64_OpAMD64CMOVQEQ_0(v)
 	case OpAMD64CMPB:
-		return rewriteValueAMD64_OpAMD64CMPB(v)
+		return rewriteValueAMD64_OpAMD64CMPB_0(v)
 	case OpAMD64CMPBconst:
-		return rewriteValueAMD64_OpAMD64CMPBconst(v)
+		return rewriteValueAMD64_OpAMD64CMPBconst_0(v)
 	case OpAMD64CMPL:
-		return rewriteValueAMD64_OpAMD64CMPL(v)
+		return rewriteValueAMD64_OpAMD64CMPL_0(v)
 	case OpAMD64CMPLconst:
-		return rewriteValueAMD64_OpAMD64CMPLconst(v)
+		return rewriteValueAMD64_OpAMD64CMPLconst_0(v)
 	case OpAMD64CMPQ:
-		return rewriteValueAMD64_OpAMD64CMPQ(v)
+		return rewriteValueAMD64_OpAMD64CMPQ_0(v)
 	case OpAMD64CMPQconst:
-		return rewriteValueAMD64_OpAMD64CMPQconst(v)
+		return rewriteValueAMD64_OpAMD64CMPQconst_0(v) || rewriteValueAMD64_OpAMD64CMPQconst_10(v)
 	case OpAMD64CMPW:
-		return rewriteValueAMD64_OpAMD64CMPW(v)
+		return rewriteValueAMD64_OpAMD64CMPW_0(v)
 	case OpAMD64CMPWconst:
-		return rewriteValueAMD64_OpAMD64CMPWconst(v)
+		return rewriteValueAMD64_OpAMD64CMPWconst_0(v)
 	case OpAMD64CMPXCHGLlock:
-		return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v)
+		return rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v)
 	case OpAMD64CMPXCHGQlock:
-		return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v)
+		return rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v)
 	case OpAMD64LEAL:
-		return rewriteValueAMD64_OpAMD64LEAL(v)
+		return rewriteValueAMD64_OpAMD64LEAL_0(v)
 	case OpAMD64LEAQ:
-		return rewriteValueAMD64_OpAMD64LEAQ(v)
+		return rewriteValueAMD64_OpAMD64LEAQ_0(v)
 	case OpAMD64LEAQ1:
-		return rewriteValueAMD64_OpAMD64LEAQ1(v)
+		return rewriteValueAMD64_OpAMD64LEAQ1_0(v)
 	case OpAMD64LEAQ2:
-		return rewriteValueAMD64_OpAMD64LEAQ2(v)
+		return rewriteValueAMD64_OpAMD64LEAQ2_0(v)
 	case OpAMD64LEAQ4:
-		return rewriteValueAMD64_OpAMD64LEAQ4(v)
+		return rewriteValueAMD64_OpAMD64LEAQ4_0(v)
 	case OpAMD64LEAQ8:
-		return rewriteValueAMD64_OpAMD64LEAQ8(v)
+		return rewriteValueAMD64_OpAMD64LEAQ8_0(v)
 	case OpAMD64MOVBQSX:
-		return rewriteValueAMD64_OpAMD64MOVBQSX(v)
+		return rewriteValueAMD64_OpAMD64MOVBQSX_0(v)
 	case OpAMD64MOVBQSXload:
-		return rewriteValueAMD64_OpAMD64MOVBQSXload(v)
+		return rewriteValueAMD64_OpAMD64MOVBQSXload_0(v)
 	case OpAMD64MOVBQZX:
-		return rewriteValueAMD64_OpAMD64MOVBQZX(v)
+		return rewriteValueAMD64_OpAMD64MOVBQZX_0(v)
 	case OpAMD64MOVBload:
-		return rewriteValueAMD64_OpAMD64MOVBload(v)
+		return rewriteValueAMD64_OpAMD64MOVBload_0(v)
 	case OpAMD64MOVBloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVBloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v)
 	case OpAMD64MOVBstore:
-		return rewriteValueAMD64_OpAMD64MOVBstore(v)
+		return rewriteValueAMD64_OpAMD64MOVBstore_0(v) || rewriteValueAMD64_OpAMD64MOVBstore_10(v)
 	case OpAMD64MOVBstoreconst:
-		return rewriteValueAMD64_OpAMD64MOVBstoreconst(v)
+		return rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v)
 	case OpAMD64MOVBstoreconstidx1:
-		return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v)
 	case OpAMD64MOVBstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v)
 	case OpAMD64MOVLQSX:
-		return rewriteValueAMD64_OpAMD64MOVLQSX(v)
+		return rewriteValueAMD64_OpAMD64MOVLQSX_0(v)
 	case OpAMD64MOVLQSXload:
-		return rewriteValueAMD64_OpAMD64MOVLQSXload(v)
+		return rewriteValueAMD64_OpAMD64MOVLQSXload_0(v)
 	case OpAMD64MOVLQZX:
-		return rewriteValueAMD64_OpAMD64MOVLQZX(v)
+		return rewriteValueAMD64_OpAMD64MOVLQZX_0(v)
 	case OpAMD64MOVLatomicload:
-		return rewriteValueAMD64_OpAMD64MOVLatomicload(v)
+		return rewriteValueAMD64_OpAMD64MOVLatomicload_0(v)
 	case OpAMD64MOVLload:
-		return rewriteValueAMD64_OpAMD64MOVLload(v)
+		return rewriteValueAMD64_OpAMD64MOVLload_0(v)
 	case OpAMD64MOVLloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVLloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v)
 	case OpAMD64MOVLloadidx4:
-		return rewriteValueAMD64_OpAMD64MOVLloadidx4(v)
+		return rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v)
 	case OpAMD64MOVLstore:
-		return rewriteValueAMD64_OpAMD64MOVLstore(v)
+		return rewriteValueAMD64_OpAMD64MOVLstore_0(v) || rewriteValueAMD64_OpAMD64MOVLstore_10(v)
 	case OpAMD64MOVLstoreconst:
-		return rewriteValueAMD64_OpAMD64MOVLstoreconst(v)
+		return rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v)
 	case OpAMD64MOVLstoreconstidx1:
-		return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v)
 	case OpAMD64MOVLstoreconstidx4:
-		return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v)
+		return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v)
 	case OpAMD64MOVLstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v)
 	case OpAMD64MOVLstoreidx4:
-		return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v)
+		return rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v)
 	case OpAMD64MOVOload:
-		return rewriteValueAMD64_OpAMD64MOVOload(v)
+		return rewriteValueAMD64_OpAMD64MOVOload_0(v)
 	case OpAMD64MOVOstore:
-		return rewriteValueAMD64_OpAMD64MOVOstore(v)
+		return rewriteValueAMD64_OpAMD64MOVOstore_0(v)
 	case OpAMD64MOVQatomicload:
-		return rewriteValueAMD64_OpAMD64MOVQatomicload(v)
+		return rewriteValueAMD64_OpAMD64MOVQatomicload_0(v)
 	case OpAMD64MOVQload:
-		return rewriteValueAMD64_OpAMD64MOVQload(v)
+		return rewriteValueAMD64_OpAMD64MOVQload_0(v)
 	case OpAMD64MOVQloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVQloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v)
 	case OpAMD64MOVQloadidx8:
-		return rewriteValueAMD64_OpAMD64MOVQloadidx8(v)
+		return rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v)
 	case OpAMD64MOVQstore:
-		return rewriteValueAMD64_OpAMD64MOVQstore(v)
+		return rewriteValueAMD64_OpAMD64MOVQstore_0(v)
 	case OpAMD64MOVQstoreconst:
-		return rewriteValueAMD64_OpAMD64MOVQstoreconst(v)
+		return rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v)
 	case OpAMD64MOVQstoreconstidx1:
-		return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v)
 	case OpAMD64MOVQstoreconstidx8:
-		return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v)
+		return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v)
 	case OpAMD64MOVQstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v)
 	case OpAMD64MOVQstoreidx8:
-		return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v)
+		return rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v)
 	case OpAMD64MOVSDload:
-		return rewriteValueAMD64_OpAMD64MOVSDload(v)
+		return rewriteValueAMD64_OpAMD64MOVSDload_0(v)
 	case OpAMD64MOVSDloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v)
 	case OpAMD64MOVSDloadidx8:
-		return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v)
+		return rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v)
 	case OpAMD64MOVSDstore:
-		return rewriteValueAMD64_OpAMD64MOVSDstore(v)
+		return rewriteValueAMD64_OpAMD64MOVSDstore_0(v)
 	case OpAMD64MOVSDstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v)
 	case OpAMD64MOVSDstoreidx8:
-		return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v)
+		return rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v)
 	case OpAMD64MOVSSload:
-		return rewriteValueAMD64_OpAMD64MOVSSload(v)
+		return rewriteValueAMD64_OpAMD64MOVSSload_0(v)
 	case OpAMD64MOVSSloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v)
 	case OpAMD64MOVSSloadidx4:
-		return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v)
+		return rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v)
 	case OpAMD64MOVSSstore:
-		return rewriteValueAMD64_OpAMD64MOVSSstore(v)
+		return rewriteValueAMD64_OpAMD64MOVSSstore_0(v)
 	case OpAMD64MOVSSstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v)
 	case OpAMD64MOVSSstoreidx4:
-		return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v)
+		return rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v)
 	case OpAMD64MOVWQSX:
-		return rewriteValueAMD64_OpAMD64MOVWQSX(v)
+		return rewriteValueAMD64_OpAMD64MOVWQSX_0(v)
 	case OpAMD64MOVWQSXload:
-		return rewriteValueAMD64_OpAMD64MOVWQSXload(v)
+		return rewriteValueAMD64_OpAMD64MOVWQSXload_0(v)
 	case OpAMD64MOVWQZX:
-		return rewriteValueAMD64_OpAMD64MOVWQZX(v)
+		return rewriteValueAMD64_OpAMD64MOVWQZX_0(v)
 	case OpAMD64MOVWload:
-		return rewriteValueAMD64_OpAMD64MOVWload(v)
+		return rewriteValueAMD64_OpAMD64MOVWload_0(v)
 	case OpAMD64MOVWloadidx1:
-		return rewriteValueAMD64_OpAMD64MOVWloadidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v)
 	case OpAMD64MOVWloadidx2:
-		return rewriteValueAMD64_OpAMD64MOVWloadidx2(v)
+		return rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v)
 	case OpAMD64MOVWstore:
-		return rewriteValueAMD64_OpAMD64MOVWstore(v)
+		return rewriteValueAMD64_OpAMD64MOVWstore_0(v) || rewriteValueAMD64_OpAMD64MOVWstore_10(v)
 	case OpAMD64MOVWstoreconst:
-		return rewriteValueAMD64_OpAMD64MOVWstoreconst(v)
+		return rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v)
 	case OpAMD64MOVWstoreconstidx1:
-		return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v)
 	case OpAMD64MOVWstoreconstidx2:
-		return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v)
+		return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v)
 	case OpAMD64MOVWstoreidx1:
-		return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v)
+		return rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v)
 	case OpAMD64MOVWstoreidx2:
-		return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v)
+		return rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v)
 	case OpAMD64MULL:
-		return rewriteValueAMD64_OpAMD64MULL(v)
+		return rewriteValueAMD64_OpAMD64MULL_0(v)
 	case OpAMD64MULLconst:
-		return rewriteValueAMD64_OpAMD64MULLconst(v)
+		return rewriteValueAMD64_OpAMD64MULLconst_0(v)
 	case OpAMD64MULQ:
-		return rewriteValueAMD64_OpAMD64MULQ(v)
+		return rewriteValueAMD64_OpAMD64MULQ_0(v)
 	case OpAMD64MULQconst:
-		return rewriteValueAMD64_OpAMD64MULQconst(v)
+		return rewriteValueAMD64_OpAMD64MULQconst_0(v) || rewriteValueAMD64_OpAMD64MULQconst_10(v) || rewriteValueAMD64_OpAMD64MULQconst_20(v)
 	case OpAMD64MULSD:
-		return rewriteValueAMD64_OpAMD64MULSD(v)
+		return rewriteValueAMD64_OpAMD64MULSD_0(v)
 	case OpAMD64MULSS:
-		return rewriteValueAMD64_OpAMD64MULSS(v)
+		return rewriteValueAMD64_OpAMD64MULSS_0(v)
 	case OpAMD64NEGL:
-		return rewriteValueAMD64_OpAMD64NEGL(v)
+		return rewriteValueAMD64_OpAMD64NEGL_0(v)
 	case OpAMD64NEGQ:
-		return rewriteValueAMD64_OpAMD64NEGQ(v)
+		return rewriteValueAMD64_OpAMD64NEGQ_0(v)
 	case OpAMD64NOTL:
-		return rewriteValueAMD64_OpAMD64NOTL(v)
+		return rewriteValueAMD64_OpAMD64NOTL_0(v)
 	case OpAMD64NOTQ:
-		return rewriteValueAMD64_OpAMD64NOTQ(v)
+		return rewriteValueAMD64_OpAMD64NOTQ_0(v)
 	case OpAMD64ORL:
-		return rewriteValueAMD64_OpAMD64ORL(v)
+		return rewriteValueAMD64_OpAMD64ORL_0(v) || rewriteValueAMD64_OpAMD64ORL_10(v) || rewriteValueAMD64_OpAMD64ORL_20(v) || rewriteValueAMD64_OpAMD64ORL_30(v) || rewriteValueAMD64_OpAMD64ORL_40(v) || rewriteValueAMD64_OpAMD64ORL_50(v) || rewriteValueAMD64_OpAMD64ORL_60(v) || rewriteValueAMD64_OpAMD64ORL_70(v) || rewriteValueAMD64_OpAMD64ORL_80(v) || rewriteValueAMD64_OpAMD64ORL_90(v) || rewriteValueAMD64_OpAMD64ORL_100(v) || rewriteValueAMD64_OpAMD64ORL_110(v) || rewriteValueAMD64_OpAMD64ORL_120(v) || rewriteValueAMD64_OpAMD64ORL_130(v)
 	case OpAMD64ORLconst:
-		return rewriteValueAMD64_OpAMD64ORLconst(v)
+		return rewriteValueAMD64_OpAMD64ORLconst_0(v)
 	case OpAMD64ORQ:
-		return rewriteValueAMD64_OpAMD64ORQ(v)
+		return rewriteValueAMD64_OpAMD64ORQ_0(v) || rewriteValueAMD64_OpAMD64ORQ_10(v) || rewriteValueAMD64_OpAMD64ORQ_20(v) || rewriteValueAMD64_OpAMD64ORQ_30(v) || rewriteValueAMD64_OpAMD64ORQ_40(v) || rewriteValueAMD64_OpAMD64ORQ_50(v) || rewriteValueAMD64_OpAMD64ORQ_60(v) || rewriteValueAMD64_OpAMD64ORQ_70(v) || rewriteValueAMD64_OpAMD64ORQ_80(v) || rewriteValueAMD64_OpAMD64ORQ_90(v) || rewriteValueAMD64_OpAMD64ORQ_100(v) || rewriteValueAMD64_OpAMD64ORQ_110(v) || rewriteValueAMD64_OpAMD64ORQ_120(v) || rewriteValueAMD64_OpAMD64ORQ_130(v) || rewriteValueAMD64_OpAMD64ORQ_140(v) || rewriteValueAMD64_OpAMD64ORQ_150(v) || rewriteValueAMD64_OpAMD64ORQ_160(v)
 	case OpAMD64ORQconst:
-		return rewriteValueAMD64_OpAMD64ORQconst(v)
+		return rewriteValueAMD64_OpAMD64ORQconst_0(v)
 	case OpAMD64ROLB:
-		return rewriteValueAMD64_OpAMD64ROLB(v)
+		return rewriteValueAMD64_OpAMD64ROLB_0(v)
 	case OpAMD64ROLBconst:
-		return rewriteValueAMD64_OpAMD64ROLBconst(v)
+		return rewriteValueAMD64_OpAMD64ROLBconst_0(v)
 	case OpAMD64ROLL:
-		return rewriteValueAMD64_OpAMD64ROLL(v)
+		return rewriteValueAMD64_OpAMD64ROLL_0(v)
 	case OpAMD64ROLLconst:
-		return rewriteValueAMD64_OpAMD64ROLLconst(v)
+		return rewriteValueAMD64_OpAMD64ROLLconst_0(v)
 	case OpAMD64ROLQ:
-		return rewriteValueAMD64_OpAMD64ROLQ(v)
+		return rewriteValueAMD64_OpAMD64ROLQ_0(v)
 	case OpAMD64ROLQconst:
-		return rewriteValueAMD64_OpAMD64ROLQconst(v)
+		return rewriteValueAMD64_OpAMD64ROLQconst_0(v)
 	case OpAMD64ROLW:
-		return rewriteValueAMD64_OpAMD64ROLW(v)
+		return rewriteValueAMD64_OpAMD64ROLW_0(v)
 	case OpAMD64ROLWconst:
-		return rewriteValueAMD64_OpAMD64ROLWconst(v)
+		return rewriteValueAMD64_OpAMD64ROLWconst_0(v)
 	case OpAMD64RORB:
-		return rewriteValueAMD64_OpAMD64RORB(v)
+		return rewriteValueAMD64_OpAMD64RORB_0(v)
 	case OpAMD64RORL:
-		return rewriteValueAMD64_OpAMD64RORL(v)
+		return rewriteValueAMD64_OpAMD64RORL_0(v)
 	case OpAMD64RORQ:
-		return rewriteValueAMD64_OpAMD64RORQ(v)
+		return rewriteValueAMD64_OpAMD64RORQ_0(v)
 	case OpAMD64RORW:
-		return rewriteValueAMD64_OpAMD64RORW(v)
+		return rewriteValueAMD64_OpAMD64RORW_0(v)
 	case OpAMD64SARB:
-		return rewriteValueAMD64_OpAMD64SARB(v)
+		return rewriteValueAMD64_OpAMD64SARB_0(v)
 	case OpAMD64SARBconst:
-		return rewriteValueAMD64_OpAMD64SARBconst(v)
+		return rewriteValueAMD64_OpAMD64SARBconst_0(v)
 	case OpAMD64SARL:
-		return rewriteValueAMD64_OpAMD64SARL(v)
+		return rewriteValueAMD64_OpAMD64SARL_0(v)
 	case OpAMD64SARLconst:
-		return rewriteValueAMD64_OpAMD64SARLconst(v)
+		return rewriteValueAMD64_OpAMD64SARLconst_0(v)
 	case OpAMD64SARQ:
-		return rewriteValueAMD64_OpAMD64SARQ(v)
+		return rewriteValueAMD64_OpAMD64SARQ_0(v)
 	case OpAMD64SARQconst:
-		return rewriteValueAMD64_OpAMD64SARQconst(v)
+		return rewriteValueAMD64_OpAMD64SARQconst_0(v)
 	case OpAMD64SARW:
-		return rewriteValueAMD64_OpAMD64SARW(v)
+		return rewriteValueAMD64_OpAMD64SARW_0(v)
 	case OpAMD64SARWconst:
-		return rewriteValueAMD64_OpAMD64SARWconst(v)
+		return rewriteValueAMD64_OpAMD64SARWconst_0(v)
 	case OpAMD64SBBLcarrymask:
-		return rewriteValueAMD64_OpAMD64SBBLcarrymask(v)
+		return rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v)
 	case OpAMD64SBBQcarrymask:
-		return rewriteValueAMD64_OpAMD64SBBQcarrymask(v)
+		return rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v)
 	case OpAMD64SETA:
-		return rewriteValueAMD64_OpAMD64SETA(v)
+		return rewriteValueAMD64_OpAMD64SETA_0(v)
 	case OpAMD64SETAE:
-		return rewriteValueAMD64_OpAMD64SETAE(v)
+		return rewriteValueAMD64_OpAMD64SETAE_0(v)
 	case OpAMD64SETB:
-		return rewriteValueAMD64_OpAMD64SETB(v)
+		return rewriteValueAMD64_OpAMD64SETB_0(v)
 	case OpAMD64SETBE:
-		return rewriteValueAMD64_OpAMD64SETBE(v)
+		return rewriteValueAMD64_OpAMD64SETBE_0(v)
 	case OpAMD64SETEQ:
-		return rewriteValueAMD64_OpAMD64SETEQ(v)
+		return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v)
 	case OpAMD64SETG:
-		return rewriteValueAMD64_OpAMD64SETG(v)
+		return rewriteValueAMD64_OpAMD64SETG_0(v)
 	case OpAMD64SETGE:
-		return rewriteValueAMD64_OpAMD64SETGE(v)
+		return rewriteValueAMD64_OpAMD64SETGE_0(v)
 	case OpAMD64SETL:
-		return rewriteValueAMD64_OpAMD64SETL(v)
+		return rewriteValueAMD64_OpAMD64SETL_0(v)
 	case OpAMD64SETLE:
-		return rewriteValueAMD64_OpAMD64SETLE(v)
+		return rewriteValueAMD64_OpAMD64SETLE_0(v)
 	case OpAMD64SETNE:
-		return rewriteValueAMD64_OpAMD64SETNE(v)
+		return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v)
 	case OpAMD64SHLL:
-		return rewriteValueAMD64_OpAMD64SHLL(v)
+		return rewriteValueAMD64_OpAMD64SHLL_0(v)
 	case OpAMD64SHLLconst:
-		return rewriteValueAMD64_OpAMD64SHLLconst(v)
+		return rewriteValueAMD64_OpAMD64SHLLconst_0(v)
 	case OpAMD64SHLQ:
-		return rewriteValueAMD64_OpAMD64SHLQ(v)
+		return rewriteValueAMD64_OpAMD64SHLQ_0(v)
 	case OpAMD64SHLQconst:
-		return rewriteValueAMD64_OpAMD64SHLQconst(v)
+		return rewriteValueAMD64_OpAMD64SHLQconst_0(v)
 	case OpAMD64SHRB:
-		return rewriteValueAMD64_OpAMD64SHRB(v)
+		return rewriteValueAMD64_OpAMD64SHRB_0(v)
 	case OpAMD64SHRBconst:
-		return rewriteValueAMD64_OpAMD64SHRBconst(v)
+		return rewriteValueAMD64_OpAMD64SHRBconst_0(v)
 	case OpAMD64SHRL:
-		return rewriteValueAMD64_OpAMD64SHRL(v)
+		return rewriteValueAMD64_OpAMD64SHRL_0(v)
 	case OpAMD64SHRLconst:
-		return rewriteValueAMD64_OpAMD64SHRLconst(v)
+		return rewriteValueAMD64_OpAMD64SHRLconst_0(v)
 	case OpAMD64SHRQ:
-		return rewriteValueAMD64_OpAMD64SHRQ(v)
+		return rewriteValueAMD64_OpAMD64SHRQ_0(v)
 	case OpAMD64SHRQconst:
-		return rewriteValueAMD64_OpAMD64SHRQconst(v)
+		return rewriteValueAMD64_OpAMD64SHRQconst_0(v)
 	case OpAMD64SHRW:
-		return rewriteValueAMD64_OpAMD64SHRW(v)
+		return rewriteValueAMD64_OpAMD64SHRW_0(v)
 	case OpAMD64SHRWconst:
-		return rewriteValueAMD64_OpAMD64SHRWconst(v)
+		return rewriteValueAMD64_OpAMD64SHRWconst_0(v)
 	case OpAMD64SUBL:
-		return rewriteValueAMD64_OpAMD64SUBL(v)
+		return rewriteValueAMD64_OpAMD64SUBL_0(v)
 	case OpAMD64SUBLconst:
-		return rewriteValueAMD64_OpAMD64SUBLconst(v)
+		return rewriteValueAMD64_OpAMD64SUBLconst_0(v)
 	case OpAMD64SUBQ:
-		return rewriteValueAMD64_OpAMD64SUBQ(v)
+		return rewriteValueAMD64_OpAMD64SUBQ_0(v)
 	case OpAMD64SUBQconst:
-		return rewriteValueAMD64_OpAMD64SUBQconst(v)
+		return rewriteValueAMD64_OpAMD64SUBQconst_0(v)
 	case OpAMD64SUBSD:
-		return rewriteValueAMD64_OpAMD64SUBSD(v)
+		return rewriteValueAMD64_OpAMD64SUBSD_0(v)
 	case OpAMD64SUBSS:
-		return rewriteValueAMD64_OpAMD64SUBSS(v)
+		return rewriteValueAMD64_OpAMD64SUBSS_0(v)
 	case OpAMD64TESTB:
-		return rewriteValueAMD64_OpAMD64TESTB(v)
+		return rewriteValueAMD64_OpAMD64TESTB_0(v)
 	case OpAMD64TESTL:
-		return rewriteValueAMD64_OpAMD64TESTL(v)
+		return rewriteValueAMD64_OpAMD64TESTL_0(v)
 	case OpAMD64TESTQ:
-		return rewriteValueAMD64_OpAMD64TESTQ(v)
+		return rewriteValueAMD64_OpAMD64TESTQ_0(v)
 	case OpAMD64TESTW:
-		return rewriteValueAMD64_OpAMD64TESTW(v)
+		return rewriteValueAMD64_OpAMD64TESTW_0(v)
 	case OpAMD64XADDLlock:
-		return rewriteValueAMD64_OpAMD64XADDLlock(v)
+		return rewriteValueAMD64_OpAMD64XADDLlock_0(v)
 	case OpAMD64XADDQlock:
-		return rewriteValueAMD64_OpAMD64XADDQlock(v)
+		return rewriteValueAMD64_OpAMD64XADDQlock_0(v)
 	case OpAMD64XCHGL:
-		return rewriteValueAMD64_OpAMD64XCHGL(v)
+		return rewriteValueAMD64_OpAMD64XCHGL_0(v)
 	case OpAMD64XCHGQ:
-		return rewriteValueAMD64_OpAMD64XCHGQ(v)
+		return rewriteValueAMD64_OpAMD64XCHGQ_0(v)
 	case OpAMD64XORL:
-		return rewriteValueAMD64_OpAMD64XORL(v)
+		return rewriteValueAMD64_OpAMD64XORL_0(v) || rewriteValueAMD64_OpAMD64XORL_10(v)
 	case OpAMD64XORLconst:
-		return rewriteValueAMD64_OpAMD64XORLconst(v)
+		return rewriteValueAMD64_OpAMD64XORLconst_0(v)
 	case OpAMD64XORQ:
-		return rewriteValueAMD64_OpAMD64XORQ(v)
+		return rewriteValueAMD64_OpAMD64XORQ_0(v)
 	case OpAMD64XORQconst:
-		return rewriteValueAMD64_OpAMD64XORQconst(v)
+		return rewriteValueAMD64_OpAMD64XORQconst_0(v)
 	case OpAdd16:
-		return rewriteValueAMD64_OpAdd16(v)
+		return rewriteValueAMD64_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueAMD64_OpAdd32(v)
+		return rewriteValueAMD64_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueAMD64_OpAdd32F(v)
+		return rewriteValueAMD64_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValueAMD64_OpAdd64(v)
+		return rewriteValueAMD64_OpAdd64_0(v)
 	case OpAdd64F:
-		return rewriteValueAMD64_OpAdd64F(v)
+		return rewriteValueAMD64_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueAMD64_OpAdd8(v)
+		return rewriteValueAMD64_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueAMD64_OpAddPtr(v)
+		return rewriteValueAMD64_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueAMD64_OpAddr(v)
+		return rewriteValueAMD64_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueAMD64_OpAnd16(v)
+		return rewriteValueAMD64_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueAMD64_OpAnd32(v)
+		return rewriteValueAMD64_OpAnd32_0(v)
 	case OpAnd64:
-		return rewriteValueAMD64_OpAnd64(v)
+		return rewriteValueAMD64_OpAnd64_0(v)
 	case OpAnd8:
-		return rewriteValueAMD64_OpAnd8(v)
+		return rewriteValueAMD64_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueAMD64_OpAndB(v)
+		return rewriteValueAMD64_OpAndB_0(v)
 	case OpAtomicAdd32:
-		return rewriteValueAMD64_OpAtomicAdd32(v)
+		return rewriteValueAMD64_OpAtomicAdd32_0(v)
 	case OpAtomicAdd64:
-		return rewriteValueAMD64_OpAtomicAdd64(v)
+		return rewriteValueAMD64_OpAtomicAdd64_0(v)
 	case OpAtomicAnd8:
-		return rewriteValueAMD64_OpAtomicAnd8(v)
+		return rewriteValueAMD64_OpAtomicAnd8_0(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValueAMD64_OpAtomicCompareAndSwap32(v)
+		return rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v)
 	case OpAtomicCompareAndSwap64:
-		return rewriteValueAMD64_OpAtomicCompareAndSwap64(v)
+		return rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v)
 	case OpAtomicExchange32:
-		return rewriteValueAMD64_OpAtomicExchange32(v)
+		return rewriteValueAMD64_OpAtomicExchange32_0(v)
 	case OpAtomicExchange64:
-		return rewriteValueAMD64_OpAtomicExchange64(v)
+		return rewriteValueAMD64_OpAtomicExchange64_0(v)
 	case OpAtomicLoad32:
-		return rewriteValueAMD64_OpAtomicLoad32(v)
+		return rewriteValueAMD64_OpAtomicLoad32_0(v)
 	case OpAtomicLoad64:
-		return rewriteValueAMD64_OpAtomicLoad64(v)
+		return rewriteValueAMD64_OpAtomicLoad64_0(v)
 	case OpAtomicLoadPtr:
-		return rewriteValueAMD64_OpAtomicLoadPtr(v)
+		return rewriteValueAMD64_OpAtomicLoadPtr_0(v)
 	case OpAtomicOr8:
-		return rewriteValueAMD64_OpAtomicOr8(v)
+		return rewriteValueAMD64_OpAtomicOr8_0(v)
 	case OpAtomicStore32:
-		return rewriteValueAMD64_OpAtomicStore32(v)
+		return rewriteValueAMD64_OpAtomicStore32_0(v)
 	case OpAtomicStore64:
-		return rewriteValueAMD64_OpAtomicStore64(v)
+		return rewriteValueAMD64_OpAtomicStore64_0(v)
 	case OpAtomicStorePtrNoWB:
-		return rewriteValueAMD64_OpAtomicStorePtrNoWB(v)
+		return rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v)
 	case OpAvg64u:
-		return rewriteValueAMD64_OpAvg64u(v)
+		return rewriteValueAMD64_OpAvg64u_0(v)
 	case OpBitLen32:
-		return rewriteValueAMD64_OpBitLen32(v)
+		return rewriteValueAMD64_OpBitLen32_0(v)
 	case OpBitLen64:
-		return rewriteValueAMD64_OpBitLen64(v)
+		return rewriteValueAMD64_OpBitLen64_0(v)
 	case OpBswap32:
-		return rewriteValueAMD64_OpBswap32(v)
+		return rewriteValueAMD64_OpBswap32_0(v)
 	case OpBswap64:
-		return rewriteValueAMD64_OpBswap64(v)
+		return rewriteValueAMD64_OpBswap64_0(v)
 	case OpClosureCall:
-		return rewriteValueAMD64_OpClosureCall(v)
+		return rewriteValueAMD64_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueAMD64_OpCom16(v)
+		return rewriteValueAMD64_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueAMD64_OpCom32(v)
+		return rewriteValueAMD64_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValueAMD64_OpCom64(v)
+		return rewriteValueAMD64_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValueAMD64_OpCom8(v)
+		return rewriteValueAMD64_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueAMD64_OpConst16(v)
+		return rewriteValueAMD64_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueAMD64_OpConst32(v)
+		return rewriteValueAMD64_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueAMD64_OpConst32F(v)
+		return rewriteValueAMD64_OpConst32F_0(v)
 	case OpConst64:
-		return rewriteValueAMD64_OpConst64(v)
+		return rewriteValueAMD64_OpConst64_0(v)
 	case OpConst64F:
-		return rewriteValueAMD64_OpConst64F(v)
+		return rewriteValueAMD64_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueAMD64_OpConst8(v)
+		return rewriteValueAMD64_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueAMD64_OpConstBool(v)
+		return rewriteValueAMD64_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueAMD64_OpConstNil(v)
+		return rewriteValueAMD64_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueAMD64_OpConvert(v)
+		return rewriteValueAMD64_OpConvert_0(v)
 	case OpCtz32:
-		return rewriteValueAMD64_OpCtz32(v)
+		return rewriteValueAMD64_OpCtz32_0(v)
 	case OpCtz64:
-		return rewriteValueAMD64_OpCtz64(v)
+		return rewriteValueAMD64_OpCtz64_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueAMD64_OpCvt32Fto32(v)
+		return rewriteValueAMD64_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64:
-		return rewriteValueAMD64_OpCvt32Fto64(v)
+		return rewriteValueAMD64_OpCvt32Fto64_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueAMD64_OpCvt32Fto64F(v)
+		return rewriteValueAMD64_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueAMD64_OpCvt32to32F(v)
+		return rewriteValueAMD64_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueAMD64_OpCvt32to64F(v)
+		return rewriteValueAMD64_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueAMD64_OpCvt64Fto32(v)
+		return rewriteValueAMD64_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueAMD64_OpCvt64Fto32F(v)
+		return rewriteValueAMD64_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto64:
-		return rewriteValueAMD64_OpCvt64Fto64(v)
+		return rewriteValueAMD64_OpCvt64Fto64_0(v)
 	case OpCvt64to32F:
-		return rewriteValueAMD64_OpCvt64to32F(v)
+		return rewriteValueAMD64_OpCvt64to32F_0(v)
 	case OpCvt64to64F:
-		return rewriteValueAMD64_OpCvt64to64F(v)
+		return rewriteValueAMD64_OpCvt64to64F_0(v)
 	case OpDiv128u:
-		return rewriteValueAMD64_OpDiv128u(v)
+		return rewriteValueAMD64_OpDiv128u_0(v)
 	case OpDiv16:
-		return rewriteValueAMD64_OpDiv16(v)
+		return rewriteValueAMD64_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueAMD64_OpDiv16u(v)
+		return rewriteValueAMD64_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueAMD64_OpDiv32(v)
+		return rewriteValueAMD64_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueAMD64_OpDiv32F(v)
+		return rewriteValueAMD64_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueAMD64_OpDiv32u(v)
+		return rewriteValueAMD64_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValueAMD64_OpDiv64(v)
+		return rewriteValueAMD64_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValueAMD64_OpDiv64F(v)
+		return rewriteValueAMD64_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValueAMD64_OpDiv64u(v)
+		return rewriteValueAMD64_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValueAMD64_OpDiv8(v)
+		return rewriteValueAMD64_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueAMD64_OpDiv8u(v)
+		return rewriteValueAMD64_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueAMD64_OpEq16(v)
+		return rewriteValueAMD64_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueAMD64_OpEq32(v)
+		return rewriteValueAMD64_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueAMD64_OpEq32F(v)
+		return rewriteValueAMD64_OpEq32F_0(v)
 	case OpEq64:
-		return rewriteValueAMD64_OpEq64(v)
+		return rewriteValueAMD64_OpEq64_0(v)
 	case OpEq64F:
-		return rewriteValueAMD64_OpEq64F(v)
+		return rewriteValueAMD64_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueAMD64_OpEq8(v)
+		return rewriteValueAMD64_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueAMD64_OpEqB(v)
+		return rewriteValueAMD64_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueAMD64_OpEqPtr(v)
+		return rewriteValueAMD64_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueAMD64_OpGeq16(v)
+		return rewriteValueAMD64_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueAMD64_OpGeq16U(v)
+		return rewriteValueAMD64_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueAMD64_OpGeq32(v)
+		return rewriteValueAMD64_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueAMD64_OpGeq32F(v)
+		return rewriteValueAMD64_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueAMD64_OpGeq32U(v)
+		return rewriteValueAMD64_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValueAMD64_OpGeq64(v)
+		return rewriteValueAMD64_OpGeq64_0(v)
 	case OpGeq64F:
-		return rewriteValueAMD64_OpGeq64F(v)
+		return rewriteValueAMD64_OpGeq64F_0(v)
 	case OpGeq64U:
-		return rewriteValueAMD64_OpGeq64U(v)
+		return rewriteValueAMD64_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValueAMD64_OpGeq8(v)
+		return rewriteValueAMD64_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueAMD64_OpGeq8U(v)
+		return rewriteValueAMD64_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueAMD64_OpGetClosurePtr(v)
+		return rewriteValueAMD64_OpGetClosurePtr_0(v)
 	case OpGetG:
-		return rewriteValueAMD64_OpGetG(v)
+		return rewriteValueAMD64_OpGetG_0(v)
 	case OpGreater16:
-		return rewriteValueAMD64_OpGreater16(v)
+		return rewriteValueAMD64_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueAMD64_OpGreater16U(v)
+		return rewriteValueAMD64_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueAMD64_OpGreater32(v)
+		return rewriteValueAMD64_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueAMD64_OpGreater32F(v)
+		return rewriteValueAMD64_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueAMD64_OpGreater32U(v)
+		return rewriteValueAMD64_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValueAMD64_OpGreater64(v)
+		return rewriteValueAMD64_OpGreater64_0(v)
 	case OpGreater64F:
-		return rewriteValueAMD64_OpGreater64F(v)
+		return rewriteValueAMD64_OpGreater64F_0(v)
 	case OpGreater64U:
-		return rewriteValueAMD64_OpGreater64U(v)
+		return rewriteValueAMD64_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValueAMD64_OpGreater8(v)
+		return rewriteValueAMD64_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueAMD64_OpGreater8U(v)
+		return rewriteValueAMD64_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueAMD64_OpHmul32(v)
+		return rewriteValueAMD64_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueAMD64_OpHmul32u(v)
+		return rewriteValueAMD64_OpHmul32u_0(v)
 	case OpHmul64:
-		return rewriteValueAMD64_OpHmul64(v)
+		return rewriteValueAMD64_OpHmul64_0(v)
 	case OpHmul64u:
-		return rewriteValueAMD64_OpHmul64u(v)
+		return rewriteValueAMD64_OpHmul64u_0(v)
 	case OpInt64Hi:
-		return rewriteValueAMD64_OpInt64Hi(v)
+		return rewriteValueAMD64_OpInt64Hi_0(v)
 	case OpInterCall:
-		return rewriteValueAMD64_OpInterCall(v)
+		return rewriteValueAMD64_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueAMD64_OpIsInBounds(v)
+		return rewriteValueAMD64_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueAMD64_OpIsNonNil(v)
+		return rewriteValueAMD64_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueAMD64_OpIsSliceInBounds(v)
+		return rewriteValueAMD64_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueAMD64_OpLeq16(v)
+		return rewriteValueAMD64_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueAMD64_OpLeq16U(v)
+		return rewriteValueAMD64_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueAMD64_OpLeq32(v)
+		return rewriteValueAMD64_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueAMD64_OpLeq32F(v)
+		return rewriteValueAMD64_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueAMD64_OpLeq32U(v)
+		return rewriteValueAMD64_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValueAMD64_OpLeq64(v)
+		return rewriteValueAMD64_OpLeq64_0(v)
 	case OpLeq64F:
-		return rewriteValueAMD64_OpLeq64F(v)
+		return rewriteValueAMD64_OpLeq64F_0(v)
 	case OpLeq64U:
-		return rewriteValueAMD64_OpLeq64U(v)
+		return rewriteValueAMD64_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValueAMD64_OpLeq8(v)
+		return rewriteValueAMD64_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueAMD64_OpLeq8U(v)
+		return rewriteValueAMD64_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueAMD64_OpLess16(v)
+		return rewriteValueAMD64_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueAMD64_OpLess16U(v)
+		return rewriteValueAMD64_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueAMD64_OpLess32(v)
+		return rewriteValueAMD64_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueAMD64_OpLess32F(v)
+		return rewriteValueAMD64_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueAMD64_OpLess32U(v)
+		return rewriteValueAMD64_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValueAMD64_OpLess64(v)
+		return rewriteValueAMD64_OpLess64_0(v)
 	case OpLess64F:
-		return rewriteValueAMD64_OpLess64F(v)
+		return rewriteValueAMD64_OpLess64F_0(v)
 	case OpLess64U:
-		return rewriteValueAMD64_OpLess64U(v)
+		return rewriteValueAMD64_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValueAMD64_OpLess8(v)
+		return rewriteValueAMD64_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueAMD64_OpLess8U(v)
+		return rewriteValueAMD64_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueAMD64_OpLoad(v)
+		return rewriteValueAMD64_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueAMD64_OpLsh16x16(v)
+		return rewriteValueAMD64_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueAMD64_OpLsh16x32(v)
+		return rewriteValueAMD64_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueAMD64_OpLsh16x64(v)
+		return rewriteValueAMD64_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueAMD64_OpLsh16x8(v)
+		return rewriteValueAMD64_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueAMD64_OpLsh32x16(v)
+		return rewriteValueAMD64_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueAMD64_OpLsh32x32(v)
+		return rewriteValueAMD64_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueAMD64_OpLsh32x64(v)
+		return rewriteValueAMD64_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueAMD64_OpLsh32x8(v)
+		return rewriteValueAMD64_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValueAMD64_OpLsh64x16(v)
+		return rewriteValueAMD64_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValueAMD64_OpLsh64x32(v)
+		return rewriteValueAMD64_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValueAMD64_OpLsh64x64(v)
+		return rewriteValueAMD64_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValueAMD64_OpLsh64x8(v)
+		return rewriteValueAMD64_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueAMD64_OpLsh8x16(v)
+		return rewriteValueAMD64_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueAMD64_OpLsh8x32(v)
+		return rewriteValueAMD64_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueAMD64_OpLsh8x64(v)
+		return rewriteValueAMD64_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueAMD64_OpLsh8x8(v)
+		return rewriteValueAMD64_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValueAMD64_OpMod16(v)
+		return rewriteValueAMD64_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueAMD64_OpMod16u(v)
+		return rewriteValueAMD64_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueAMD64_OpMod32(v)
+		return rewriteValueAMD64_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueAMD64_OpMod32u(v)
+		return rewriteValueAMD64_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValueAMD64_OpMod64(v)
+		return rewriteValueAMD64_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValueAMD64_OpMod64u(v)
+		return rewriteValueAMD64_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValueAMD64_OpMod8(v)
+		return rewriteValueAMD64_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueAMD64_OpMod8u(v)
+		return rewriteValueAMD64_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueAMD64_OpMove(v)
+		return rewriteValueAMD64_OpMove_0(v) || rewriteValueAMD64_OpMove_10(v)
 	case OpMul16:
-		return rewriteValueAMD64_OpMul16(v)
+		return rewriteValueAMD64_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueAMD64_OpMul32(v)
+		return rewriteValueAMD64_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueAMD64_OpMul32F(v)
+		return rewriteValueAMD64_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValueAMD64_OpMul64(v)
+		return rewriteValueAMD64_OpMul64_0(v)
 	case OpMul64F:
-		return rewriteValueAMD64_OpMul64F(v)
+		return rewriteValueAMD64_OpMul64F_0(v)
 	case OpMul64uhilo:
-		return rewriteValueAMD64_OpMul64uhilo(v)
+		return rewriteValueAMD64_OpMul64uhilo_0(v)
 	case OpMul8:
-		return rewriteValueAMD64_OpMul8(v)
+		return rewriteValueAMD64_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueAMD64_OpNeg16(v)
+		return rewriteValueAMD64_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueAMD64_OpNeg32(v)
+		return rewriteValueAMD64_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueAMD64_OpNeg32F(v)
+		return rewriteValueAMD64_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValueAMD64_OpNeg64(v)
+		return rewriteValueAMD64_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValueAMD64_OpNeg64F(v)
+		return rewriteValueAMD64_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueAMD64_OpNeg8(v)
+		return rewriteValueAMD64_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueAMD64_OpNeq16(v)
+		return rewriteValueAMD64_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueAMD64_OpNeq32(v)
+		return rewriteValueAMD64_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueAMD64_OpNeq32F(v)
+		return rewriteValueAMD64_OpNeq32F_0(v)
 	case OpNeq64:
-		return rewriteValueAMD64_OpNeq64(v)
+		return rewriteValueAMD64_OpNeq64_0(v)
 	case OpNeq64F:
-		return rewriteValueAMD64_OpNeq64F(v)
+		return rewriteValueAMD64_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueAMD64_OpNeq8(v)
+		return rewriteValueAMD64_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueAMD64_OpNeqB(v)
+		return rewriteValueAMD64_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueAMD64_OpNeqPtr(v)
+		return rewriteValueAMD64_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueAMD64_OpNilCheck(v)
+		return rewriteValueAMD64_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueAMD64_OpNot(v)
+		return rewriteValueAMD64_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueAMD64_OpOffPtr(v)
+		return rewriteValueAMD64_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueAMD64_OpOr16(v)
+		return rewriteValueAMD64_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueAMD64_OpOr32(v)
+		return rewriteValueAMD64_OpOr32_0(v)
 	case OpOr64:
-		return rewriteValueAMD64_OpOr64(v)
+		return rewriteValueAMD64_OpOr64_0(v)
 	case OpOr8:
-		return rewriteValueAMD64_OpOr8(v)
+		return rewriteValueAMD64_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueAMD64_OpOrB(v)
+		return rewriteValueAMD64_OpOrB_0(v)
 	case OpPopCount16:
-		return rewriteValueAMD64_OpPopCount16(v)
+		return rewriteValueAMD64_OpPopCount16_0(v)
 	case OpPopCount32:
-		return rewriteValueAMD64_OpPopCount32(v)
+		return rewriteValueAMD64_OpPopCount32_0(v)
 	case OpPopCount64:
-		return rewriteValueAMD64_OpPopCount64(v)
+		return rewriteValueAMD64_OpPopCount64_0(v)
 	case OpPopCount8:
-		return rewriteValueAMD64_OpPopCount8(v)
+		return rewriteValueAMD64_OpPopCount8_0(v)
 	case OpRound32F:
-		return rewriteValueAMD64_OpRound32F(v)
+		return rewriteValueAMD64_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueAMD64_OpRound64F(v)
+		return rewriteValueAMD64_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueAMD64_OpRsh16Ux16(v)
+		return rewriteValueAMD64_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueAMD64_OpRsh16Ux32(v)
+		return rewriteValueAMD64_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueAMD64_OpRsh16Ux64(v)
+		return rewriteValueAMD64_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueAMD64_OpRsh16Ux8(v)
+		return rewriteValueAMD64_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueAMD64_OpRsh16x16(v)
+		return rewriteValueAMD64_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueAMD64_OpRsh16x32(v)
+		return rewriteValueAMD64_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueAMD64_OpRsh16x64(v)
+		return rewriteValueAMD64_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueAMD64_OpRsh16x8(v)
+		return rewriteValueAMD64_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueAMD64_OpRsh32Ux16(v)
+		return rewriteValueAMD64_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueAMD64_OpRsh32Ux32(v)
+		return rewriteValueAMD64_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueAMD64_OpRsh32Ux64(v)
+		return rewriteValueAMD64_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueAMD64_OpRsh32Ux8(v)
+		return rewriteValueAMD64_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueAMD64_OpRsh32x16(v)
+		return rewriteValueAMD64_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueAMD64_OpRsh32x32(v)
+		return rewriteValueAMD64_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueAMD64_OpRsh32x64(v)
+		return rewriteValueAMD64_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueAMD64_OpRsh32x8(v)
+		return rewriteValueAMD64_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValueAMD64_OpRsh64Ux16(v)
+		return rewriteValueAMD64_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValueAMD64_OpRsh64Ux32(v)
+		return rewriteValueAMD64_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValueAMD64_OpRsh64Ux64(v)
+		return rewriteValueAMD64_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValueAMD64_OpRsh64Ux8(v)
+		return rewriteValueAMD64_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValueAMD64_OpRsh64x16(v)
+		return rewriteValueAMD64_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValueAMD64_OpRsh64x32(v)
+		return rewriteValueAMD64_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValueAMD64_OpRsh64x64(v)
+		return rewriteValueAMD64_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValueAMD64_OpRsh64x8(v)
+		return rewriteValueAMD64_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueAMD64_OpRsh8Ux16(v)
+		return rewriteValueAMD64_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueAMD64_OpRsh8Ux32(v)
+		return rewriteValueAMD64_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueAMD64_OpRsh8Ux64(v)
+		return rewriteValueAMD64_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueAMD64_OpRsh8Ux8(v)
+		return rewriteValueAMD64_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueAMD64_OpRsh8x16(v)
+		return rewriteValueAMD64_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueAMD64_OpRsh8x32(v)
+		return rewriteValueAMD64_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueAMD64_OpRsh8x64(v)
+		return rewriteValueAMD64_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueAMD64_OpRsh8x8(v)
+		return rewriteValueAMD64_OpRsh8x8_0(v)
 	case OpSelect0:
-		return rewriteValueAMD64_OpSelect0(v)
+		return rewriteValueAMD64_OpSelect0_0(v)
 	case OpSelect1:
-		return rewriteValueAMD64_OpSelect1(v)
+		return rewriteValueAMD64_OpSelect1_0(v)
 	case OpSignExt16to32:
-		return rewriteValueAMD64_OpSignExt16to32(v)
+		return rewriteValueAMD64_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValueAMD64_OpSignExt16to64(v)
+		return rewriteValueAMD64_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValueAMD64_OpSignExt32to64(v)
+		return rewriteValueAMD64_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValueAMD64_OpSignExt8to16(v)
+		return rewriteValueAMD64_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueAMD64_OpSignExt8to32(v)
+		return rewriteValueAMD64_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValueAMD64_OpSignExt8to64(v)
+		return rewriteValueAMD64_OpSignExt8to64_0(v)
 	case OpSlicemask:
-		return rewriteValueAMD64_OpSlicemask(v)
+		return rewriteValueAMD64_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValueAMD64_OpSqrt(v)
+		return rewriteValueAMD64_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValueAMD64_OpStaticCall(v)
+		return rewriteValueAMD64_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueAMD64_OpStore(v)
+		return rewriteValueAMD64_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueAMD64_OpSub16(v)
+		return rewriteValueAMD64_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueAMD64_OpSub32(v)
+		return rewriteValueAMD64_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueAMD64_OpSub32F(v)
+		return rewriteValueAMD64_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValueAMD64_OpSub64(v)
+		return rewriteValueAMD64_OpSub64_0(v)
 	case OpSub64F:
-		return rewriteValueAMD64_OpSub64F(v)
+		return rewriteValueAMD64_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueAMD64_OpSub8(v)
+		return rewriteValueAMD64_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueAMD64_OpSubPtr(v)
+		return rewriteValueAMD64_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueAMD64_OpTrunc16to8(v)
+		return rewriteValueAMD64_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueAMD64_OpTrunc32to16(v)
+		return rewriteValueAMD64_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueAMD64_OpTrunc32to8(v)
+		return rewriteValueAMD64_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValueAMD64_OpTrunc64to16(v)
+		return rewriteValueAMD64_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValueAMD64_OpTrunc64to32(v)
+		return rewriteValueAMD64_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValueAMD64_OpTrunc64to8(v)
+		return rewriteValueAMD64_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValueAMD64_OpXor16(v)
+		return rewriteValueAMD64_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueAMD64_OpXor32(v)
+		return rewriteValueAMD64_OpXor32_0(v)
 	case OpXor64:
-		return rewriteValueAMD64_OpXor64(v)
+		return rewriteValueAMD64_OpXor64_0(v)
 	case OpXor8:
-		return rewriteValueAMD64_OpXor8(v)
+		return rewriteValueAMD64_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueAMD64_OpZero(v)
+		return rewriteValueAMD64_OpZero_0(v) || rewriteValueAMD64_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValueAMD64_OpZeroExt16to32(v)
+		return rewriteValueAMD64_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValueAMD64_OpZeroExt16to64(v)
+		return rewriteValueAMD64_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValueAMD64_OpZeroExt32to64(v)
+		return rewriteValueAMD64_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueAMD64_OpZeroExt8to16(v)
+		return rewriteValueAMD64_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueAMD64_OpZeroExt8to32(v)
+		return rewriteValueAMD64_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValueAMD64_OpZeroExt8to64(v)
+		return rewriteValueAMD64_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool {
 	// match: (ADDL x (MOVLconst [c]))
 	// cond:
 	// result: (ADDLconst [c] x)
@@ -1077,6 +1077,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool {
 	// match: (ADDL x l:(MOVLload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (ADDLmem x [off] {sym} ptr mem)
@@ -1127,7 +1130,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool {
 	// match: (ADDLconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -1195,7 +1198,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool {
 	// match: (ADDQ x (MOVQconst [c]))
 	// cond: is32Bit(c)
 	// result: (ADDQconst [c] x)
@@ -1392,6 +1395,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool {
 	// match: (ADDQ x (ADDQ y y))
 	// cond:
 	// result: (LEAQ2 x y)
@@ -1578,6 +1584,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_20(v *Value) bool {
 	// match: (ADDQ x (NEGQ y))
 	// cond:
 	// result: (SUBQ x y)
@@ -1658,7 +1667,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool {
 	// match: (ADDQconst [c] (ADDQ x y))
 	// cond:
 	// result: (LEAQ1 [c] x y)
@@ -1837,7 +1846,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool {
 	// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (ADDSDmem x [off] {sym} ptr mem)
@@ -1888,7 +1897,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool {
 	// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (ADDSSmem x [off] {sym} ptr mem)
@@ -1939,7 +1948,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool {
 	// match: (ANDL x (MOVLconst [c]))
 	// cond:
 	// result: (ANDLconst [c] x)
@@ -2033,7 +2042,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool {
 	// match: (ANDLconst [c] (ANDLconst [d] x))
 	// cond:
 	// result: (ANDLconst [c & d] x)
@@ -2116,7 +2125,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool {
 	// match: (ANDQ x (MOVQconst [c]))
 	// cond: is32Bit(c)
 	// result: (ANDQconst [c] x)
@@ -2216,7 +2225,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool {
 	// match: (ANDQconst [c] (ANDQconst [d] x))
 	// cond:
 	// result: (ANDQconst [c & d] x)
@@ -2309,7 +2318,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x)))
@@ -2362,7 +2371,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTQconst_0(v *Value) bool {
 	// match: (BTQconst [c] x)
 	// cond: c < 32
 	// result: (BTLconst [c] x)
@@ -2379,7 +2388,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQEQ_0(v *Value) bool {
 	// match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _))))
 	// cond: c != 0
 	// result: x
@@ -2408,7 +2417,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPB x (MOVLconst [c]))
@@ -2445,7 +2454,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBconst_0(v *Value) bool {
 	// match: (CMPBconst (MOVLconst [x]) [y])
 	// cond: int8(x)==int8(y)
 	// result: (FlagEQ)
@@ -2593,7 +2602,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPL x (MOVLconst [c]))
@@ -2630,7 +2639,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLconst_0(v *Value) bool {
 	// match: (CMPLconst (MOVLconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -2794,7 +2803,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPQ x (MOVQconst [c]))
@@ -2837,7 +2846,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQconst_0(v *Value) bool {
 	// match: (CMPQconst (NEGQ (ADDQconst [-16] (ANDQconst [15] _))) [32])
 	// cond:
 	// result: (FlagLT_ULT)
@@ -3019,6 +3028,9 @@
 		v.reset(OpAMD64FlagLT_ULT)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64CMPQconst_10(v *Value) bool {
 	// match: (CMPQconst (SHRQconst _ [c]) [n])
 	// cond: 0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)
 	// result: (FlagLT_ULT)
@@ -3118,7 +3130,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPW x (MOVLconst [c]))
@@ -3155,7 +3167,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWconst_0(v *Value) bool {
 	// match: (CMPWconst (MOVLconst [x]) [y])
 	// cond: int16(x)==int16(y)
 	// result: (FlagEQ)
@@ -3303,7 +3315,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v *Value) bool {
 	// match: (CMPXCHGLlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
 	// cond: is32Bit(off1+off2)
 	// result: (CMPXCHGLlock [off1+off2] {sym} ptr old new_ mem)
@@ -3333,7 +3345,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v *Value) bool {
 	// match: (CMPXCHGQlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
 	// cond: is32Bit(off1+off2)
 	// result: (CMPXCHGQlock [off1+off2] {sym} ptr old new_ mem)
@@ -3363,7 +3375,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL_0(v *Value) bool {
 	// match: (LEAL [c] {s} (ADDLconst [d] x))
 	// cond: is32Bit(c+d)
 	// result: (LEAL [c+d] {s} x)
@@ -3387,7 +3399,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ_0(v *Value) bool {
 	// match: (LEAQ [c] {s} (ADDQconst [d] x))
 	// cond: is32Bit(c+d)
 	// result: (LEAQ [c+d] {s} x)
@@ -3551,7 +3563,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ1_0(v *Value) bool {
 	// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAQ1 [c+d] {s} x y)
@@ -3780,7 +3792,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ2_0(v *Value) bool {
 	// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAQ2 [c+d] {s} x y)
@@ -3897,7 +3909,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ4_0(v *Value) bool {
 	// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAQ4 [c+d] {s} x y)
@@ -3992,7 +4004,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ8_0(v *Value) bool {
 	// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
 	// cond: is32Bit(c+d)   && x.Op != OpSB
 	// result: (LEAQ8 [c+d] {s} x y)
@@ -4065,7 +4077,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem))
@@ -4201,7 +4213,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSXload_0(v *Value) bool {
 	// match: (MOVBQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 	// result: (MOVBQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -4228,7 +4240,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQZX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem))
@@ -4388,7 +4400,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBload_0(v *Value) bool {
 	// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: x
@@ -4558,7 +4570,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v *Value) bool {
 	// match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
@@ -4649,7 +4661,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
@@ -5142,6 +5154,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstore_10(v *Value) bool {
 	// match: (MOVBstore [i] {s} p (SHRQconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWstore [i-1] {s} p w mem)
@@ -5286,7 +5301,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v *Value) bool {
 	// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -5459,7 +5474,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v *Value) bool {
 	// match: (MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem)
 	// cond:
 	// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -5540,7 +5555,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -6053,7 +6068,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem))
@@ -6165,7 +6180,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSXload_0(v *Value) bool {
 	// match: (MOVLQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 	// result: (MOVLQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -6192,7 +6207,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem))
@@ -6355,7 +6370,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLatomicload_0(v *Value) bool {
 	// match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVLatomicload [off1+off2] {sym} ptr mem)
@@ -6405,7 +6420,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLload_0(v *Value) bool {
 	// match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: x
@@ -6601,7 +6616,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v *Value) bool {
 	// match: (MOVLloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
 	// cond:
 	// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
@@ -6740,7 +6755,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v *Value) bool {
 	// match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
@@ -6787,7 +6802,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstore_0(v *Value) bool {
 	// match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
 	// cond:
 	// result: (MOVLstore [off] {sym} ptr x mem)
@@ -7077,6 +7092,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstore_10(v *Value) bool {
 	// match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
 	// cond: canMergeSym(sym1, sym2)
 	// result: (MOVLstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
@@ -7130,7 +7148,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7336,7 +7354,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7448,7 +7466,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7539,7 +7557,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v *Value) bool {
 	// match: (MOVLstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
 	// cond:
 	// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
@@ -7717,7 +7735,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -7877,7 +7895,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOload_0(v *Value) bool {
 	// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVOload  [off1+off2] {sym} ptr mem)
@@ -7927,7 +7945,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOstore_0(v *Value) bool {
 	// match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVOstore  [off1+off2] {sym} ptr val mem)
@@ -7981,7 +7999,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQatomicload_0(v *Value) bool {
 	// match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVQatomicload [off1+off2] {sym} ptr mem)
@@ -8031,7 +8049,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQload_0(v *Value) bool {
 	// match: (MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: x
@@ -8227,7 +8245,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v *Value) bool {
 	// match: (MOVQloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
 	// cond:
 	// result: (MOVQloadidx8 [c] {sym} ptr idx mem)
@@ -8366,7 +8384,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v *Value) bool {
 	// match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVQloadidx8 [c+d] {sym} ptr idx mem)
@@ -8413,7 +8431,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstore_0(v *Value) bool {
 	// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVQstore  [off1+off2] {sym} ptr val mem)
@@ -8623,7 +8641,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v *Value) bool {
 	// match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -8793,7 +8811,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v *Value) bool {
 	// match: (MOVQstoreconstidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
 	// cond:
 	// result: (MOVQstoreconstidx8 [c] {sym} ptr idx mem)
@@ -8864,7 +8882,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v *Value) bool {
 	// match: (MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem)
 	// cond:
 	// result: (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -8911,7 +8929,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v *Value) bool {
 	// match: (MOVQstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
 	// cond:
 	// result: (MOVQstoreidx8 [c] {sym} ptr idx val mem)
@@ -8988,7 +9006,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v *Value) bool {
 	// match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -9039,7 +9057,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDload_0(v *Value) bool {
 	// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVSDload [off1+off2] {sym} ptr mem)
@@ -9165,7 +9183,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v *Value) bool {
 	// match: (MOVSDloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
 	// cond:
 	// result: (MOVSDloadidx8 [c] {sym} ptr idx mem)
@@ -9236,7 +9254,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v *Value) bool {
 	// match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
@@ -9283,7 +9301,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstore_0(v *Value) bool {
 	// match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVSDstore [off1+off2] {sym} ptr val mem)
@@ -9419,7 +9437,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v *Value) bool {
 	// match: (MOVSDstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
 	// cond:
 	// result: (MOVSDstoreidx8 [c] {sym} ptr idx val mem)
@@ -9496,7 +9514,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v *Value) bool {
 	// match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -9547,7 +9565,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSload_0(v *Value) bool {
 	// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVSSload [off1+off2] {sym} ptr mem)
@@ -9673,7 +9691,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v *Value) bool {
 	// match: (MOVSSloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
 	// cond:
 	// result: (MOVSSloadidx4 [c] {sym} ptr idx mem)
@@ -9744,7 +9762,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v *Value) bool {
 	// match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
@@ -9791,7 +9809,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstore_0(v *Value) bool {
 	// match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVSSstore [off1+off2] {sym} ptr val mem)
@@ -9927,7 +9945,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v *Value) bool {
 	// match: (MOVSSstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
 	// cond:
 	// result: (MOVSSstoreidx4 [c] {sym} ptr idx val mem)
@@ -10004,7 +10022,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v *Value) bool {
 	// match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -10055,7 +10073,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem))
@@ -10179,7 +10197,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSXload_0(v *Value) bool {
 	// match: (MOVWQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 	// result: (MOVWQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -10206,7 +10224,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem))
@@ -10381,7 +10399,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWload_0(v *Value) bool {
 	// match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: x
@@ -10577,7 +10595,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v *Value) bool {
 	// match: (MOVWloadidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
 	// cond:
 	// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
@@ -10716,7 +10734,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v *Value) bool {
 	// match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
@@ -10763,7 +10781,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
 	// cond:
 	// result: (MOVWstore [off] {sym} ptr x mem)
@@ -11053,6 +11071,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstore_10(v *Value) bool {
 	// match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
 	// cond: canMergeSym(sym1, sym2)
 	// result: (MOVWstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
@@ -11106,7 +11127,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v *Value) bool {
 	// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -11305,7 +11326,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v *Value) bool {
 	// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
 	// cond:
 	// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
@@ -11410,7 +11431,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem)
@@ -11496,7 +11517,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v *Value) bool {
 	// match: (MOVWstoreidx1 [c] {sym} ptr (SHLQconst [1] idx) val mem)
 	// cond:
 	// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
@@ -11674,7 +11695,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -11834,7 +11855,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULL_0(v *Value) bool {
 	// match: (MULL x (MOVLconst [c]))
 	// cond:
 	// result: (MULLconst [c] x)
@@ -11867,7 +11888,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULLconst_0(v *Value) bool {
 	// match: (MULLconst [c] (MULLconst [d] x))
 	// cond:
 	// result: (MULLconst [int64(int32(c * d))] x)
@@ -11900,7 +11921,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQ_0(v *Value) bool {
 	// match: (MULQ x (MOVQconst [c]))
 	// cond: is32Bit(c)
 	// result: (MULQconst [c] x)
@@ -11939,7 +11960,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MULQconst [c] (MULQconst [d] x))
@@ -12083,6 +12104,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULQconst [21] x)
 	// cond:
 	// result: (LEAQ4 x (LEAQ4 <v.Type> x x))
@@ -12245,6 +12271,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULQconst [c] x)
 	// cond: isPowerOfTwo(c-8) && c >= 136
 	// result: (LEAQ8 (SHLQconst <v.Type> [log2(c-8)] x) x)
@@ -12329,7 +12360,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool {
 	// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (MULSDmem x [off] {sym} ptr mem)
@@ -12380,7 +12411,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool {
 	// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (MULSSmem x [off] {sym} ptr mem)
@@ -12431,7 +12462,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool {
 	// match: (NEGL (MOVLconst [c]))
 	// cond:
 	// result: (MOVLconst [int64(int32(-c))])
@@ -12447,7 +12478,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool {
 	// match: (NEGQ (MOVQconst [c]))
 	// cond:
 	// result: (MOVQconst [-c])
@@ -12485,7 +12516,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool {
 	// match: (NOTL (MOVLconst [c]))
 	// cond:
 	// result: (MOVLconst [^c])
@@ -12501,7 +12532,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool {
 	// match: (NOTQ (MOVQconst [c]))
 	// cond:
 	// result: (MOVQconst [^c])
@@ -12517,11 +12548,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
-	b := v.Block
-	_ = b
-	types := &b.Func.Config.Types
-	_ = types
+func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool {
 	// match: (ORL x (MOVLconst [c]))
 	// cond:
 	// result: (ORLconst [c] x)
@@ -12842,6 +12869,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool {
 	// match: (ORL (ANDL (SHRL x (NEGQ y)) (SBBLcarrymask (CMPQconst (NEGQ (ADDQconst (ANDQconst y [31]) [-32])) [32]))) (SHLL x y))
 	// cond:
 	// result: (ROLL x y)
@@ -13492,6 +13522,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool {
 	// match: (ORL (SHRL x y) (ANDL (SHLL x (NEGL y)) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [31]) [-32])) [32]))))
 	// cond:
 	// result: (RORL x y)
@@ -14286,6 +14319,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool {
 	// match: (ORL (ANDL (SHRW x (NEGL (ADDLconst (ANDLconst y [15]) [-16]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [15]) [-16])) [16]))) (SHLL x (ANDLconst y [15])))
 	// cond: v.Type.Size() == 2
 	// result: (ROLW x y)
@@ -15032,6 +15068,13 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_40(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL (SHLL x (ANDLconst y [ 7])) (ANDL (SHRB x (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8])) [ 8]))))
 	// cond: v.Type.Size() == 1
 	// result: (ROLB x y)
@@ -15659,6 +15702,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_50(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL sh:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
@@ -16190,6 +16240,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_60(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) sh:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -16700,6 +16757,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_70(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL sh:(SHLLconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
@@ -17308,6 +17372,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_80(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORL y s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))))
 	// cond: i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -17942,6 +18013,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_90(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL sh:(SHLLconst [8] x0:(MOVBload [i0] {s} p mem)) x1:(MOVBload [i1] {s} p mem))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWload [i0] {s} p mem))
@@ -18529,6 +18607,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_100(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL x1:(MOVBloadidx1 [i1] {s} idx p mem) sh:(SHLLconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
@@ -19134,6 +19219,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_110(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL sh:(SHLLconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
@@ -19811,6 +19903,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_120(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORL s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORL y s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -20447,6 +20546,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORL_130(v *Value) bool {
 	// match: (ORL l:(MOVLload [off] {sym} ptr mem) x)
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (ORLmem x [off] {sym} ptr mem)
@@ -20473,7 +20575,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool {
 	// match: (ORLconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -20516,11 +20618,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
-	b := v.Block
-	_ = b
-	types := &b.Func.Config.Types
-	_ = types
+func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool {
 	// match: (ORQ x (MOVQconst [c]))
 	// cond: is32Bit(c)
 	// result: (ORQconst [c] x)
@@ -20999,6 +21097,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool {
 	// match: (ORQ (ANDQ (SHRQ x (NEGL y)) (SBBQcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [63]) [-64])) [64]))) (SHLQ x y))
 	// cond:
 	// result: (ROLQ x y)
@@ -21649,6 +21750,13 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ x x)
 	// cond:
 	// result: x
@@ -22118,6 +22226,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_30(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem))) s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem)))
 	// cond: i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWload [i0] {s} p mem)) y)
@@ -22673,6 +22788,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_40(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ sh:(SHLQconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -23183,6 +23305,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_50(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ sh:(SHLQconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
@@ -23707,6 +23836,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_60(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)) y))
 	// cond: i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -24357,6 +24493,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_70(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)))
 	// cond: i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -25007,6 +25150,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_80(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)) or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} p idx mem))))
 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
@@ -25657,6 +25807,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_90(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
@@ -26245,6 +26402,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_100(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem))) s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWload [i0] {s} p mem))) y)
@@ -26882,6 +27046,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_110(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ sh:(SHLQconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)) x1:(MOVBloadidx1 [i1] {s} p idx mem))
 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
@@ -27513,6 +27684,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_120(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ sh:(SHLQconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
@@ -28136,6 +28314,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_130(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)) y))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -28816,6 +29001,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_140(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))) s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -29561,6 +29753,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_150(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))))
 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
@@ -30371,6 +30570,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_160(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))) s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))))
 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
@@ -30502,7 +30708,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool {
 	// match: (ORQconst [0] x)
 	// cond:
 	// result: x
@@ -30543,7 +30749,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool {
 	// match: (ROLB x (NEGQ y))
 	// cond:
 	// result: (RORB x y)
@@ -30606,7 +30812,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool {
 	// match: (ROLBconst [c] (ROLBconst [d] x))
 	// cond:
 	// result: (ROLBconst [(c+d)& 7] x)
@@ -30638,7 +30844,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool {
 	// match: (ROLL x (NEGQ y))
 	// cond:
 	// result: (RORL x y)
@@ -30701,7 +30907,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool {
 	// match: (ROLLconst [c] (ROLLconst [d] x))
 	// cond:
 	// result: (ROLLconst [(c+d)&31] x)
@@ -30733,7 +30939,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool {
 	// match: (ROLQ x (NEGQ y))
 	// cond:
 	// result: (RORQ x y)
@@ -30796,7 +31002,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool {
 	// match: (ROLQconst [c] (ROLQconst [d] x))
 	// cond:
 	// result: (ROLQconst [(c+d)&63] x)
@@ -30828,7 +31034,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool {
 	// match: (ROLW x (NEGQ y))
 	// cond:
 	// result: (RORW x y)
@@ -30891,7 +31097,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool {
 	// match: (ROLWconst [c] (ROLWconst [d] x))
 	// cond:
 	// result: (ROLWconst [(c+d)&15] x)
@@ -30923,7 +31129,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64RORB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool {
 	// match: (RORB x (NEGQ y))
 	// cond:
 	// result: (ROLB x y)
@@ -30986,7 +31192,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64RORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool {
 	// match: (RORL x (NEGQ y))
 	// cond:
 	// result: (ROLL x y)
@@ -31049,7 +31255,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool {
 	// match: (RORQ x (NEGQ y))
 	// cond:
 	// result: (ROLQ x y)
@@ -31112,7 +31318,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64RORW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool {
 	// match: (RORW x (NEGQ y))
 	// cond:
 	// result: (ROLW x y)
@@ -31175,7 +31381,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool {
 	// match: (SARB x (MOVQconst [c]))
 	// cond:
 	// result: (SARBconst [min(c&31,7)] x)
@@ -31208,7 +31414,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool {
 	// match: (SARBconst x [0])
 	// cond:
 	// result: x
@@ -31238,7 +31444,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SARL x (MOVQconst [c]))
@@ -31453,7 +31659,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool {
 	// match: (SARLconst x [0])
 	// cond:
 	// result: x
@@ -31483,7 +31689,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SARQ x (MOVQconst [c]))
@@ -31698,7 +31904,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool {
 	// match: (SARQconst x [0])
 	// cond:
 	// result: x
@@ -31728,7 +31934,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool {
 	// match: (SARW x (MOVQconst [c]))
 	// cond:
 	// result: (SARWconst [min(c&31,15)] x)
@@ -31761,7 +31967,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool {
 	// match: (SARWconst x [0])
 	// cond:
 	// result: x
@@ -31791,7 +31997,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool {
 	// match: (SBBLcarrymask (FlagEQ))
 	// cond:
 	// result: (MOVLconst [0])
@@ -31854,7 +32060,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool {
 	// match: (SBBQcarrymask (FlagEQ))
 	// cond:
 	// result: (MOVQconst [0])
@@ -31917,7 +32123,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETA(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool {
 	// match: (SETA (InvertFlags x))
 	// cond:
 	// result: (SETB x)
@@ -31993,7 +32199,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool {
 	// match: (SETAE (InvertFlags x))
 	// cond:
 	// result: (SETBE x)
@@ -32069,7 +32275,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool {
 	// match: (SETB (InvertFlags x))
 	// cond:
 	// result: (SETA x)
@@ -32145,7 +32351,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool {
 	// match: (SETBE (InvertFlags x))
 	// cond:
 	// result: (SETAE x)
@@ -32221,7 +32427,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -32463,6 +32669,9 @@
 		v.AuxInt = 1
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool {
 	// match: (SETEQ (FlagLT_ULT))
 	// cond:
 	// result: (MOVLconst [0])
@@ -32513,7 +32722,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETG(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool {
 	// match: (SETG (InvertFlags x))
 	// cond:
 	// result: (SETL x)
@@ -32589,7 +32798,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool {
 	// match: (SETGE (InvertFlags x))
 	// cond:
 	// result: (SETLE x)
@@ -32665,7 +32874,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool {
 	// match: (SETL (InvertFlags x))
 	// cond:
 	// result: (SETG x)
@@ -32741,7 +32950,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool {
 	// match: (SETLE (InvertFlags x))
 	// cond:
 	// result: (SETGE x)
@@ -32817,7 +33026,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -33059,6 +33268,9 @@
 		v.AuxInt = 0
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool {
 	// match: (SETNE (FlagLT_ULT))
 	// cond:
 	// result: (MOVLconst [1])
@@ -33109,7 +33321,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SHLL x (MOVQconst [c]))
@@ -33324,7 +33536,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool {
 	// match: (SHLLconst x [0])
 	// cond:
 	// result: x
@@ -33340,7 +33552,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SHLQ x (MOVQconst [c]))
@@ -33555,7 +33767,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool {
 	// match: (SHLQconst x [0])
 	// cond:
 	// result: x
@@ -33571,7 +33783,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool {
 	// match: (SHRB x (MOVQconst [c]))
 	// cond: c&31 < 8
 	// result: (SHRBconst [c&31] x)
@@ -33642,7 +33854,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool {
 	// match: (SHRBconst x [0])
 	// cond:
 	// result: x
@@ -33658,7 +33870,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SHRL x (MOVQconst [c]))
@@ -33873,7 +34085,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool {
 	// match: (SHRLconst x [0])
 	// cond:
 	// result: x
@@ -33889,7 +34101,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SHRQ x (MOVQconst [c]))
@@ -34104,7 +34316,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool {
 	// match: (SHRQconst x [0])
 	// cond:
 	// result: x
@@ -34120,7 +34332,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool {
 	// match: (SHRW x (MOVQconst [c]))
 	// cond: c&31 < 16
 	// result: (SHRWconst [c&31] x)
@@ -34191,7 +34403,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool {
 	// match: (SHRWconst x [0])
 	// cond:
 	// result: x
@@ -34207,7 +34419,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBL x (MOVLconst [c]))
@@ -34280,7 +34492,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool {
 	// match: (SUBLconst [c] x)
 	// cond: int32(c) == 0
 	// result: x
@@ -34307,7 +34519,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBQ x (MOVQconst [c]))
@@ -34386,7 +34598,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool {
 	// match: (SUBQconst [0] x)
 	// cond:
 	// result: x
@@ -34449,7 +34661,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool {
 	// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (SUBSDmem x [off] {sym} ptr mem)
@@ -34476,7 +34688,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool {
 	// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (SUBSSmem x [off] {sym} ptr mem)
@@ -34503,7 +34715,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool {
 	// match: (TESTB (MOVLconst [c]) x)
 	// cond:
 	// result: (TESTBconst [c] x)
@@ -34536,7 +34748,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool {
 	// match: (TESTL (MOVLconst [c]) x)
 	// cond:
 	// result: (TESTLconst [c] x)
@@ -34569,7 +34781,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool {
 	// match: (TESTQ (MOVQconst [c]) x)
 	// cond: is32Bit(c)
 	// result: (TESTQconst [c] x)
@@ -34608,7 +34820,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool {
 	// match: (TESTW (MOVLconst [c]) x)
 	// cond:
 	// result: (TESTWconst [c] x)
@@ -34641,7 +34853,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool {
 	// match: (XADDLlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (XADDLlock [off1+off2] {sym} val ptr mem)
@@ -34669,7 +34881,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool {
 	// match: (XADDQlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (XADDQlock [off1+off2] {sym} val ptr mem)
@@ -34697,7 +34909,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool {
 	// match: (XCHGL [off1] {sym} val (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (XCHGL [off1+off2] {sym} val ptr mem)
@@ -34751,7 +34963,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool {
 	// match: (XCHGQ [off1] {sym} val (ADDQconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (XCHGQ [off1+off2] {sym} val ptr mem)
@@ -34805,7 +35017,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool {
 	// match: (XORL x (MOVLconst [c]))
 	// cond:
 	// result: (XORLconst [c] x)
@@ -35032,6 +35244,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpAMD64XORL_10(v *Value) bool {
 	// match: (XORL l:(MOVLload [off] {sym} ptr mem) x)
 	// cond: canMergeLoad(v, l, x) && clobber(l)
 	// result: (XORLmem x [off] {sym} ptr mem)
@@ -35058,7 +35273,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool {
 	// match: (XORLconst [c] (XORLconst [d] x))
 	// cond:
 	// result: (XORLconst [c ^ d] x)
@@ -35105,7 +35320,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool {
 	// match: (XORQ x (MOVQconst [c]))
 	// cond: is32Bit(c)
 	// result: (XORQconst [c] x)
@@ -35256,7 +35471,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool {
 	// match: (XORQconst [c] (XORQconst [d] x))
 	// cond:
 	// result: (XORQconst [c ^ d] x)
@@ -35302,7 +35517,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAdd16(v *Value) bool {
+func rewriteValueAMD64_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -35315,7 +35530,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -35328,7 +35543,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAdd32F(v *Value) bool {
+func rewriteValueAMD64_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (ADDSS x y)
@@ -35341,7 +35556,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAdd64_0(v *Value) bool {
 	// match: (Add64 x y)
 	// cond:
 	// result: (ADDQ  x y)
@@ -35354,7 +35569,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAdd64F(v *Value) bool {
+func rewriteValueAMD64_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (ADDSD x y)
@@ -35367,7 +35582,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAdd8(v *Value) bool {
+func rewriteValueAMD64_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADDL  x y)
@@ -35380,7 +35595,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAddPtr(v *Value) bool {
+func rewriteValueAMD64_OpAddPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -35415,7 +35630,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAddr(v *Value) bool {
+func rewriteValueAMD64_OpAddr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -35450,7 +35665,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAnd16(v *Value) bool {
+func rewriteValueAMD64_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -35463,7 +35678,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAnd32(v *Value) bool {
+func rewriteValueAMD64_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -35476,7 +35691,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAnd64(v *Value) bool {
+func rewriteValueAMD64_OpAnd64_0(v *Value) bool {
 	// match: (And64 x y)
 	// cond:
 	// result: (ANDQ x y)
@@ -35489,7 +35704,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (ANDL x y)
@@ -35502,7 +35717,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAndB(v *Value) bool {
+func rewriteValueAMD64_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (ANDL x y)
@@ -35515,7 +35730,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35537,7 +35752,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35559,7 +35774,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAnd8_0(v *Value) bool {
 	// match: (AtomicAnd8 ptr val mem)
 	// cond:
 	// result: (ANDBlock ptr val mem)
@@ -35574,7 +35789,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
 	// cond:
 	// result: (CMPXCHGLlock ptr old new_ mem)
@@ -35591,7 +35806,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
 	// cond:
 	// result: (CMPXCHGQlock ptr old new_ mem)
@@ -35608,7 +35823,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool {
 	// match: (AtomicExchange32 ptr val mem)
 	// cond:
 	// result: (XCHGL val ptr mem)
@@ -35623,7 +35838,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool {
 	// match: (AtomicExchange64 ptr val mem)
 	// cond:
 	// result: (XCHGQ val ptr mem)
@@ -35638,7 +35853,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad32_0(v *Value) bool {
 	// match: (AtomicLoad32 ptr mem)
 	// cond:
 	// result: (MOVLatomicload ptr mem)
@@ -35651,7 +35866,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad64_0(v *Value) bool {
 	// match: (AtomicLoad64 ptr mem)
 	// cond:
 	// result: (MOVQatomicload ptr mem)
@@ -35664,7 +35879,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoadPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -35699,7 +35914,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAtomicOr8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicOr8_0(v *Value) bool {
 	// match: (AtomicOr8 ptr val mem)
 	// cond:
 	// result: (ORBlock ptr val mem)
@@ -35714,7 +35929,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35735,7 +35950,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35756,7 +35971,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -35801,7 +36016,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpAvg64u(v *Value) bool {
+func rewriteValueAMD64_OpAvg64u_0(v *Value) bool {
 	// match: (Avg64u x y)
 	// cond:
 	// result: (AVGQU x y)
@@ -35814,7 +36029,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpBitLen32(v *Value) bool {
+func rewriteValueAMD64_OpBitLen32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35831,7 +36046,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpBitLen64(v *Value) bool {
+func rewriteValueAMD64_OpBitLen64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -35862,7 +36077,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpBswap32(v *Value) bool {
+func rewriteValueAMD64_OpBswap32_0(v *Value) bool {
 	// match: (Bswap32 x)
 	// cond:
 	// result: (BSWAPL x)
@@ -35873,7 +36088,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpBswap64(v *Value) bool {
+func rewriteValueAMD64_OpBswap64_0(v *Value) bool {
 	// match: (Bswap64 x)
 	// cond:
 	// result: (BSWAPQ x)
@@ -35884,7 +36099,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpClosureCall(v *Value) bool {
+func rewriteValueAMD64_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -35901,7 +36116,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCom16(v *Value) bool {
+func rewriteValueAMD64_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (NOTL x)
@@ -35912,7 +36127,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCom32(v *Value) bool {
+func rewriteValueAMD64_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (NOTL x)
@@ -35923,7 +36138,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCom64(v *Value) bool {
+func rewriteValueAMD64_OpCom64_0(v *Value) bool {
 	// match: (Com64 x)
 	// cond:
 	// result: (NOTQ x)
@@ -35934,7 +36149,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCom8(v *Value) bool {
+func rewriteValueAMD64_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (NOTL x)
@@ -35945,7 +36160,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst16(v *Value) bool {
+func rewriteValueAMD64_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -35956,7 +36171,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst32(v *Value) bool {
+func rewriteValueAMD64_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -35967,7 +36182,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst32F(v *Value) bool {
+func rewriteValueAMD64_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (MOVSSconst [val])
@@ -35978,7 +36193,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst64(v *Value) bool {
+func rewriteValueAMD64_OpConst64_0(v *Value) bool {
 	// match: (Const64 [val])
 	// cond:
 	// result: (MOVQconst [val])
@@ -35989,7 +36204,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst64F(v *Value) bool {
+func rewriteValueAMD64_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (MOVSDconst [val])
@@ -36000,7 +36215,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConst8(v *Value) bool {
+func rewriteValueAMD64_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVLconst [val])
@@ -36011,7 +36226,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConstBool(v *Value) bool {
+func rewriteValueAMD64_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVLconst [b])
@@ -36022,7 +36237,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpConstNil(v *Value) bool {
+func rewriteValueAMD64_OpConstNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -36051,7 +36266,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpConvert(v *Value) bool {
+func rewriteValueAMD64_OpConvert_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -36090,7 +36305,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpCtz32(v *Value) bool {
+func rewriteValueAMD64_OpCtz32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36112,7 +36327,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCtz64(v *Value) bool {
+func rewriteValueAMD64_OpCtz64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36140,7 +36355,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (CVTTSS2SL x)
@@ -36151,7 +36366,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64_0(v *Value) bool {
 	// match: (Cvt32Fto64 x)
 	// cond:
 	// result: (CVTTSS2SQ x)
@@ -36162,7 +36377,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (CVTSS2SD x)
@@ -36173,7 +36388,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt32to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (CVTSL2SS x)
@@ -36184,7 +36399,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt32to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (CVTSL2SD x)
@@ -36195,7 +36410,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (CVTTSD2SL x)
@@ -36206,7 +36421,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (CVTSD2SS x)
@@ -36217,7 +36432,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto64_0(v *Value) bool {
 	// match: (Cvt64Fto64 x)
 	// cond:
 	// result: (CVTTSD2SQ x)
@@ -36228,7 +36443,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt64to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to32F_0(v *Value) bool {
 	// match: (Cvt64to32F x)
 	// cond:
 	// result: (CVTSQ2SS x)
@@ -36239,7 +36454,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpCvt64to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to64F_0(v *Value) bool {
 	// match: (Cvt64to64F x)
 	// cond:
 	// result: (CVTSQ2SD x)
@@ -36250,7 +36465,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv128u(v *Value) bool {
+func rewriteValueAMD64_OpDiv128u_0(v *Value) bool {
 	// match: (Div128u xhi xlo y)
 	// cond:
 	// result: (DIVQU2 xhi xlo y)
@@ -36265,7 +36480,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv16(v *Value) bool {
+func rewriteValueAMD64_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36284,7 +36499,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv16u(v *Value) bool {
+func rewriteValueAMD64_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36303,7 +36518,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv32(v *Value) bool {
+func rewriteValueAMD64_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36322,7 +36537,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv32F(v *Value) bool {
+func rewriteValueAMD64_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (DIVSS x y)
@@ -36335,7 +36550,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv32u(v *Value) bool {
+func rewriteValueAMD64_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36354,7 +36569,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv64(v *Value) bool {
+func rewriteValueAMD64_OpDiv64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36373,7 +36588,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv64F(v *Value) bool {
+func rewriteValueAMD64_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (DIVSD x y)
@@ -36386,7 +36601,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv64u(v *Value) bool {
+func rewriteValueAMD64_OpDiv64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36405,7 +36620,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv8(v *Value) bool {
+func rewriteValueAMD64_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36428,7 +36643,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpDiv8u(v *Value) bool {
+func rewriteValueAMD64_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -36451,7 +36666,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq16(v *Value) bool {
+func rewriteValueAMD64_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq16 x y)
@@ -36468,7 +36683,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq32(v *Value) bool {
+func rewriteValueAMD64_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x y)
@@ -36485,7 +36700,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq32F(v *Value) bool {
+func rewriteValueAMD64_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -36502,7 +36717,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq64(v *Value) bool {
+func rewriteValueAMD64_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64 x y)
@@ -36519,7 +36734,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq64F(v *Value) bool {
+func rewriteValueAMD64_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -36536,7 +36751,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEq8(v *Value) bool {
+func rewriteValueAMD64_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq8 x y)
@@ -36553,7 +36768,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEqB(v *Value) bool {
+func rewriteValueAMD64_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqB x y)
@@ -36570,7 +36785,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpEqPtr(v *Value) bool {
+func rewriteValueAMD64_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -36609,7 +36824,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpGeq16(v *Value) bool {
+func rewriteValueAMD64_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq16 x y)
@@ -36626,7 +36841,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq16U(v *Value) bool {
+func rewriteValueAMD64_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq16U x y)
@@ -36643,7 +36858,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq32(v *Value) bool {
+func rewriteValueAMD64_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32 x y)
@@ -36660,7 +36875,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq32F(v *Value) bool {
+func rewriteValueAMD64_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -36677,7 +36892,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq32U(v *Value) bool {
+func rewriteValueAMD64_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32U x y)
@@ -36694,7 +36909,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq64(v *Value) bool {
+func rewriteValueAMD64_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64 x y)
@@ -36711,7 +36926,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq64F(v *Value) bool {
+func rewriteValueAMD64_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -36728,7 +36943,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq64U(v *Value) bool {
+func rewriteValueAMD64_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64U x y)
@@ -36745,7 +36960,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq8(v *Value) bool {
+func rewriteValueAMD64_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq8 x y)
@@ -36762,7 +36977,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGeq8U(v *Value) bool {
+func rewriteValueAMD64_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq8U x y)
@@ -36779,7 +36994,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueAMD64_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -36788,7 +37003,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGetG(v *Value) bool {
+func rewriteValueAMD64_OpGetG_0(v *Value) bool {
 	// match: (GetG mem)
 	// cond:
 	// result: (LoweredGetG mem)
@@ -36799,7 +37014,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater16(v *Value) bool {
+func rewriteValueAMD64_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater16 x y)
@@ -36816,7 +37031,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater16U(v *Value) bool {
+func rewriteValueAMD64_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater16U x y)
@@ -36833,7 +37048,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater32(v *Value) bool {
+func rewriteValueAMD64_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32 x y)
@@ -36850,7 +37065,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater32F(v *Value) bool {
+func rewriteValueAMD64_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -36867,7 +37082,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater32U(v *Value) bool {
+func rewriteValueAMD64_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32U x y)
@@ -36884,7 +37099,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater64(v *Value) bool {
+func rewriteValueAMD64_OpGreater64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64 x y)
@@ -36901,7 +37116,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater64F(v *Value) bool {
+func rewriteValueAMD64_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -36918,7 +37133,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater64U(v *Value) bool {
+func rewriteValueAMD64_OpGreater64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64U x y)
@@ -36935,7 +37150,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater8(v *Value) bool {
+func rewriteValueAMD64_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater8 x y)
@@ -36952,7 +37167,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpGreater8U(v *Value) bool {
+func rewriteValueAMD64_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater8U x y)
@@ -36969,7 +37184,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpHmul32(v *Value) bool {
+func rewriteValueAMD64_OpHmul32_0(v *Value) bool {
 	// match: (Hmul32 x y)
 	// cond:
 	// result: (HMULL  x y)
@@ -36982,7 +37197,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpHmul32u(v *Value) bool {
+func rewriteValueAMD64_OpHmul32u_0(v *Value) bool {
 	// match: (Hmul32u x y)
 	// cond:
 	// result: (HMULLU x y)
@@ -36995,7 +37210,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpHmul64(v *Value) bool {
+func rewriteValueAMD64_OpHmul64_0(v *Value) bool {
 	// match: (Hmul64 x y)
 	// cond:
 	// result: (HMULQ  x y)
@@ -37008,7 +37223,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpHmul64u(v *Value) bool {
+func rewriteValueAMD64_OpHmul64u_0(v *Value) bool {
 	// match: (Hmul64u x y)
 	// cond:
 	// result: (HMULQU x y)
@@ -37021,7 +37236,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpInt64Hi(v *Value) bool {
+func rewriteValueAMD64_OpInt64Hi_0(v *Value) bool {
 	// match: (Int64Hi x)
 	// cond:
 	// result: (SHRQconst [32] x)
@@ -37033,7 +37248,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpInterCall(v *Value) bool {
+func rewriteValueAMD64_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -37048,7 +37263,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpIsInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsInBounds idx len)
@@ -37065,7 +37280,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpIsNonNil(v *Value) bool {
+func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -37102,7 +37317,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsSliceInBounds idx len)
@@ -37119,7 +37334,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq16(v *Value) bool {
+func rewriteValueAMD64_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq16 x y)
@@ -37136,7 +37351,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq16U(v *Value) bool {
+func rewriteValueAMD64_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq16U x y)
@@ -37153,7 +37368,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq32(v *Value) bool {
+func rewriteValueAMD64_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32 x y)
@@ -37170,7 +37385,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq32F(v *Value) bool {
+func rewriteValueAMD64_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -37187,7 +37402,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq32U(v *Value) bool {
+func rewriteValueAMD64_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32U x y)
@@ -37204,7 +37419,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq64(v *Value) bool {
+func rewriteValueAMD64_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64 x y)
@@ -37221,7 +37436,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq64F(v *Value) bool {
+func rewriteValueAMD64_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -37238,7 +37453,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq64U(v *Value) bool {
+func rewriteValueAMD64_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64U x y)
@@ -37255,7 +37470,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq8(v *Value) bool {
+func rewriteValueAMD64_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq8 x y)
@@ -37272,7 +37487,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLeq8U(v *Value) bool {
+func rewriteValueAMD64_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq8U x y)
@@ -37289,7 +37504,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess16(v *Value) bool {
+func rewriteValueAMD64_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less16 x y)
@@ -37306,7 +37521,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess16U(v *Value) bool {
+func rewriteValueAMD64_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less16U x y)
@@ -37323,7 +37538,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess32(v *Value) bool {
+func rewriteValueAMD64_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32 x y)
@@ -37340,7 +37555,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess32F(v *Value) bool {
+func rewriteValueAMD64_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -37357,7 +37572,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess32U(v *Value) bool {
+func rewriteValueAMD64_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32U x y)
@@ -37374,7 +37589,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess64(v *Value) bool {
+func rewriteValueAMD64_OpLess64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64 x y)
@@ -37391,7 +37606,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess64F(v *Value) bool {
+func rewriteValueAMD64_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -37408,7 +37623,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess64U(v *Value) bool {
+func rewriteValueAMD64_OpLess64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64U x y)
@@ -37425,7 +37640,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess8(v *Value) bool {
+func rewriteValueAMD64_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less8 x y)
@@ -37442,7 +37657,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLess8U(v *Value) bool {
+func rewriteValueAMD64_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less8U x y)
@@ -37459,7 +37674,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLoad(v *Value) bool {
+func rewriteValueAMD64_OpLoad_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -37556,7 +37771,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpLsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x16 <t> x y)
@@ -37580,7 +37795,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x32 <t> x y)
@@ -37604,7 +37819,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x64 <t> x y)
@@ -37628,7 +37843,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x8 <t> x y)
@@ -37652,7 +37867,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x16 <t> x y)
@@ -37676,7 +37891,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x32 <t> x y)
@@ -37700,7 +37915,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x64 <t> x y)
@@ -37724,7 +37939,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x8 <t> x y)
@@ -37748,7 +37963,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x16 <t> x y)
@@ -37772,7 +37987,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x32 <t> x y)
@@ -37796,7 +38011,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x64 <t> x y)
@@ -37820,7 +38035,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x8 <t> x y)
@@ -37844,7 +38059,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x16 <t> x y)
@@ -37868,7 +38083,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x32 <t> x y)
@@ -37892,7 +38107,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x64 <t> x y)
@@ -37916,7 +38131,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpLsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x8 <t> x y)
@@ -37940,7 +38155,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod16(v *Value) bool {
+func rewriteValueAMD64_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -37959,7 +38174,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod16u(v *Value) bool {
+func rewriteValueAMD64_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -37978,7 +38193,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod32(v *Value) bool {
+func rewriteValueAMD64_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -37997,7 +38212,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod32u(v *Value) bool {
+func rewriteValueAMD64_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38016,7 +38231,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod64(v *Value) bool {
+func rewriteValueAMD64_OpMod64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38035,7 +38250,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod64u(v *Value) bool {
+func rewriteValueAMD64_OpMod64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38054,7 +38269,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod8(v *Value) bool {
+func rewriteValueAMD64_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38077,7 +38292,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMod8u(v *Value) bool {
+func rewriteValueAMD64_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38100,11 +38315,9 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMove(v *Value) bool {
+func rewriteValueAMD64_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Move [0] _ _ mem)
@@ -38327,6 +38540,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [s] dst src mem)
 	// cond: s > 8 && s < 16
 	// result: (MOVQstore [s-8] dst (MOVQload [s-8] src mem) 		(MOVQstore dst (MOVQload src mem) mem))
@@ -38458,7 +38680,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpMul16(v *Value) bool {
+func rewriteValueAMD64_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -38471,7 +38693,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul32(v *Value) bool {
+func rewriteValueAMD64_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -38484,7 +38706,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul32F(v *Value) bool {
+func rewriteValueAMD64_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (MULSS x y)
@@ -38497,7 +38719,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul64(v *Value) bool {
+func rewriteValueAMD64_OpMul64_0(v *Value) bool {
 	// match: (Mul64 x y)
 	// cond:
 	// result: (MULQ  x y)
@@ -38510,7 +38732,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul64F(v *Value) bool {
+func rewriteValueAMD64_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (MULSD x y)
@@ -38523,7 +38745,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul64uhilo(v *Value) bool {
+func rewriteValueAMD64_OpMul64uhilo_0(v *Value) bool {
 	// match: (Mul64uhilo x y)
 	// cond:
 	// result: (MULQU2 x y)
@@ -38536,7 +38758,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpMul8(v *Value) bool {
+func rewriteValueAMD64_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MULL  x y)
@@ -38549,7 +38771,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg16(v *Value) bool {
+func rewriteValueAMD64_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEGL x)
@@ -38560,7 +38782,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg32(v *Value) bool {
+func rewriteValueAMD64_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEGL x)
@@ -38571,7 +38793,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg32F(v *Value) bool {
+func rewriteValueAMD64_OpNeg32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38589,7 +38811,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg64(v *Value) bool {
+func rewriteValueAMD64_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 x)
 	// cond:
 	// result: (NEGQ x)
@@ -38600,7 +38822,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg64F(v *Value) bool {
+func rewriteValueAMD64_OpNeg64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38618,7 +38840,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeg8(v *Value) bool {
+func rewriteValueAMD64_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEGL x)
@@ -38629,7 +38851,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq16(v *Value) bool {
+func rewriteValueAMD64_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq16 x y)
@@ -38646,7 +38868,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq32(v *Value) bool {
+func rewriteValueAMD64_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x y)
@@ -38663,7 +38885,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq32F(v *Value) bool {
+func rewriteValueAMD64_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -38680,7 +38902,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq64(v *Value) bool {
+func rewriteValueAMD64_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64 x y)
@@ -38697,7 +38919,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq64F(v *Value) bool {
+func rewriteValueAMD64_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -38714,7 +38936,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeq8(v *Value) bool {
+func rewriteValueAMD64_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq8 x y)
@@ -38731,7 +38953,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeqB(v *Value) bool {
+func rewriteValueAMD64_OpNeqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqB x y)
@@ -38748,7 +38970,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNeqPtr(v *Value) bool {
+func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -38787,7 +39009,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpNilCheck(v *Value) bool {
+func rewriteValueAMD64_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -38800,7 +39022,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpNot(v *Value) bool {
+func rewriteValueAMD64_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORLconst [1] x)
@@ -38812,7 +39034,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpOffPtr(v *Value) bool {
+func rewriteValueAMD64_OpOffPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -38865,7 +39087,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpOr16(v *Value) bool {
+func rewriteValueAMD64_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (ORL x y)
@@ -38878,7 +39100,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpOr32(v *Value) bool {
+func rewriteValueAMD64_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (ORL x y)
@@ -38891,7 +39113,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpOr64(v *Value) bool {
+func rewriteValueAMD64_OpOr64_0(v *Value) bool {
 	// match: (Or64 x y)
 	// cond:
 	// result: (ORQ x y)
@@ -38904,7 +39126,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpOr8(v *Value) bool {
+func rewriteValueAMD64_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (ORL x y)
@@ -38917,7 +39139,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpOrB(v *Value) bool {
+func rewriteValueAMD64_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (ORL x y)
@@ -38930,7 +39152,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpPopCount16(v *Value) bool {
+func rewriteValueAMD64_OpPopCount16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38947,7 +39169,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpPopCount32(v *Value) bool {
+func rewriteValueAMD64_OpPopCount32_0(v *Value) bool {
 	// match: (PopCount32 x)
 	// cond:
 	// result: (POPCNTL x)
@@ -38958,7 +39180,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpPopCount64(v *Value) bool {
+func rewriteValueAMD64_OpPopCount64_0(v *Value) bool {
 	// match: (PopCount64 x)
 	// cond:
 	// result: (POPCNTQ x)
@@ -38969,7 +39191,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpPopCount8(v *Value) bool {
+func rewriteValueAMD64_OpPopCount8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -38986,7 +39208,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRound32F(v *Value) bool {
+func rewriteValueAMD64_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -38998,7 +39220,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRound64F(v *Value) bool {
+func rewriteValueAMD64_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -39010,7 +39232,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux16 <t> x y)
@@ -39034,7 +39256,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux32 <t> x y)
@@ -39058,7 +39280,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux64 <t> x y)
@@ -39082,7 +39304,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux8 <t> x y)
@@ -39106,7 +39328,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x16 <t> x y)
@@ -39133,7 +39355,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x32 <t> x y)
@@ -39160,7 +39382,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x64 <t> x y)
@@ -39187,7 +39409,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x8 <t> x y)
@@ -39214,7 +39436,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux16 <t> x y)
@@ -39238,7 +39460,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux32 <t> x y)
@@ -39262,7 +39484,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux64 <t> x y)
@@ -39286,7 +39508,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux8 <t> x y)
@@ -39310,7 +39532,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x16 <t> x y)
@@ -39337,7 +39559,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x32 <t> x y)
@@ -39364,7 +39586,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x64 <t> x y)
@@ -39391,7 +39613,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x8 <t> x y)
@@ -39418,7 +39640,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux16 <t> x y)
@@ -39442,7 +39664,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux32 <t> x y)
@@ -39466,7 +39688,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux64 <t> x y)
@@ -39490,7 +39712,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux8 <t> x y)
@@ -39514,7 +39736,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x16 <t> x y)
@@ -39541,7 +39763,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x32 <t> x y)
@@ -39568,7 +39790,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x64 <t> x y)
@@ -39595,7 +39817,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x8 <t> x y)
@@ -39622,7 +39844,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux16 <t> x y)
@@ -39646,7 +39868,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux32 <t> x y)
@@ -39670,7 +39892,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux64 <t> x y)
@@ -39694,7 +39916,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux8 <t> x y)
@@ -39718,7 +39940,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x16 <t> x y)
@@ -39745,7 +39967,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x32 <t> x y)
@@ -39772,7 +39994,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x64 <t> x y)
@@ -39799,7 +40021,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpRsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x8 <t> x y)
@@ -39826,7 +40048,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSelect0(v *Value) bool {
+func rewriteValueAMD64_OpSelect0_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Select0 <t> (AddTupleFirst32 tuple val))
@@ -39867,7 +40089,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpSelect1(v *Value) bool {
+func rewriteValueAMD64_OpSelect1_0(v *Value) bool {
 	// match: (Select1 (AddTupleFirst32 tuple _))
 	// cond:
 	// result: (Select1 tuple)
@@ -39896,7 +40118,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpSignExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVWQSX x)
@@ -39907,7 +40129,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSignExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 x)
 	// cond:
 	// result: (MOVWQSX x)
@@ -39918,7 +40140,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSignExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 x)
 	// cond:
 	// result: (MOVLQSX x)
@@ -39929,7 +40151,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSignExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBQSX x)
@@ -39940,7 +40162,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSignExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBQSX x)
@@ -39951,7 +40173,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSignExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 x)
 	// cond:
 	// result: (MOVBQSX x)
@@ -39962,7 +40184,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSlicemask(v *Value) bool {
+func rewriteValueAMD64_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -39979,7 +40201,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSqrt(v *Value) bool {
+func rewriteValueAMD64_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (SQRTSD x)
@@ -39990,7 +40212,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpStaticCall(v *Value) bool {
+func rewriteValueAMD64_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -40005,7 +40227,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpStore(v *Value) bool {
+func rewriteValueAMD64_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
 	// result: (MOVSDstore ptr val mem)
@@ -40110,7 +40332,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpSub16(v *Value) bool {
+func rewriteValueAMD64_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -40123,7 +40345,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSub32(v *Value) bool {
+func rewriteValueAMD64_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -40136,7 +40358,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSub32F(v *Value) bool {
+func rewriteValueAMD64_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (SUBSS x y)
@@ -40149,7 +40371,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSub64(v *Value) bool {
+func rewriteValueAMD64_OpSub64_0(v *Value) bool {
 	// match: (Sub64 x y)
 	// cond:
 	// result: (SUBQ  x y)
@@ -40162,7 +40384,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSub64F(v *Value) bool {
+func rewriteValueAMD64_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (SUBSD x y)
@@ -40175,7 +40397,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSub8(v *Value) bool {
+func rewriteValueAMD64_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUBL  x y)
@@ -40188,7 +40410,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpSubPtr(v *Value) bool {
+func rewriteValueAMD64_OpSubPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -40223,7 +40445,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpTrunc16to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -40235,7 +40457,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpTrunc32to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -40247,7 +40469,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpTrunc32to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -40259,7 +40481,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpTrunc64to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 x)
 	// cond:
 	// result: x
@@ -40271,7 +40493,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpTrunc64to32(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 x)
 	// cond:
 	// result: x
@@ -40283,7 +40505,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpTrunc64to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 x)
 	// cond:
 	// result: x
@@ -40295,7 +40517,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpXor16(v *Value) bool {
+func rewriteValueAMD64_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XORL x y)
@@ -40308,7 +40530,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpXor32(v *Value) bool {
+func rewriteValueAMD64_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XORL x y)
@@ -40321,7 +40543,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpXor64(v *Value) bool {
+func rewriteValueAMD64_OpXor64_0(v *Value) bool {
 	// match: (Xor64 x y)
 	// cond:
 	// result: (XORQ x y)
@@ -40334,7 +40556,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpXor8(v *Value) bool {
+func rewriteValueAMD64_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XORL x y)
@@ -40347,13 +40569,9 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZero(v *Value) bool {
+func rewriteValueAMD64_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
-	types := &b.Func.Config.Types
-	_ = types
 	// match: (Zero [0] _ mem)
 	// cond:
 	// result: mem
@@ -40526,6 +40744,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueAMD64_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Zero [16] destptr mem)
 	// cond:
 	// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr 		(MOVQstoreconst [0] destptr mem))
@@ -40662,7 +40889,7 @@
 	}
 	return false
 }
-func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVWQZX x)
@@ -40673,7 +40900,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 x)
 	// cond:
 	// result: (MOVWQZX x)
@@ -40684,7 +40911,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 x)
 	// cond:
 	// result: (MOVLQZX x)
@@ -40695,7 +40922,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBQZX x)
@@ -40706,7 +40933,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBQZX x)
@@ -40717,7 +40944,7 @@
 		return true
 	}
 }
-func rewriteValueAMD64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 x)
 	// cond:
 	// result: (MOVBQZX x)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 944093a..1176969 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -14,721 +14,721 @@
 func rewriteValueARM(v *Value) bool {
 	switch v.Op {
 	case OpARMADC:
-		return rewriteValueARM_OpARMADC(v)
+		return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v)
 	case OpARMADCconst:
-		return rewriteValueARM_OpARMADCconst(v)
+		return rewriteValueARM_OpARMADCconst_0(v)
 	case OpARMADCshiftLL:
-		return rewriteValueARM_OpARMADCshiftLL(v)
+		return rewriteValueARM_OpARMADCshiftLL_0(v)
 	case OpARMADCshiftLLreg:
-		return rewriteValueARM_OpARMADCshiftLLreg(v)
+		return rewriteValueARM_OpARMADCshiftLLreg_0(v)
 	case OpARMADCshiftRA:
-		return rewriteValueARM_OpARMADCshiftRA(v)
+		return rewriteValueARM_OpARMADCshiftRA_0(v)
 	case OpARMADCshiftRAreg:
-		return rewriteValueARM_OpARMADCshiftRAreg(v)
+		return rewriteValueARM_OpARMADCshiftRAreg_0(v)
 	case OpARMADCshiftRL:
-		return rewriteValueARM_OpARMADCshiftRL(v)
+		return rewriteValueARM_OpARMADCshiftRL_0(v)
 	case OpARMADCshiftRLreg:
-		return rewriteValueARM_OpARMADCshiftRLreg(v)
+		return rewriteValueARM_OpARMADCshiftRLreg_0(v)
 	case OpARMADD:
-		return rewriteValueARM_OpARMADD(v)
+		return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v)
 	case OpARMADDS:
-		return rewriteValueARM_OpARMADDS(v)
+		return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v)
 	case OpARMADDSshiftLL:
-		return rewriteValueARM_OpARMADDSshiftLL(v)
+		return rewriteValueARM_OpARMADDSshiftLL_0(v)
 	case OpARMADDSshiftLLreg:
-		return rewriteValueARM_OpARMADDSshiftLLreg(v)
+		return rewriteValueARM_OpARMADDSshiftLLreg_0(v)
 	case OpARMADDSshiftRA:
-		return rewriteValueARM_OpARMADDSshiftRA(v)
+		return rewriteValueARM_OpARMADDSshiftRA_0(v)
 	case OpARMADDSshiftRAreg:
-		return rewriteValueARM_OpARMADDSshiftRAreg(v)
+		return rewriteValueARM_OpARMADDSshiftRAreg_0(v)
 	case OpARMADDSshiftRL:
-		return rewriteValueARM_OpARMADDSshiftRL(v)
+		return rewriteValueARM_OpARMADDSshiftRL_0(v)
 	case OpARMADDSshiftRLreg:
-		return rewriteValueARM_OpARMADDSshiftRLreg(v)
+		return rewriteValueARM_OpARMADDSshiftRLreg_0(v)
 	case OpARMADDconst:
-		return rewriteValueARM_OpARMADDconst(v)
+		return rewriteValueARM_OpARMADDconst_0(v)
 	case OpARMADDshiftLL:
-		return rewriteValueARM_OpARMADDshiftLL(v)
+		return rewriteValueARM_OpARMADDshiftLL_0(v)
 	case OpARMADDshiftLLreg:
-		return rewriteValueARM_OpARMADDshiftLLreg(v)
+		return rewriteValueARM_OpARMADDshiftLLreg_0(v)
 	case OpARMADDshiftRA:
-		return rewriteValueARM_OpARMADDshiftRA(v)
+		return rewriteValueARM_OpARMADDshiftRA_0(v)
 	case OpARMADDshiftRAreg:
-		return rewriteValueARM_OpARMADDshiftRAreg(v)
+		return rewriteValueARM_OpARMADDshiftRAreg_0(v)
 	case OpARMADDshiftRL:
-		return rewriteValueARM_OpARMADDshiftRL(v)
+		return rewriteValueARM_OpARMADDshiftRL_0(v)
 	case OpARMADDshiftRLreg:
-		return rewriteValueARM_OpARMADDshiftRLreg(v)
+		return rewriteValueARM_OpARMADDshiftRLreg_0(v)
 	case OpARMAND:
-		return rewriteValueARM_OpARMAND(v)
+		return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v)
 	case OpARMANDconst:
-		return rewriteValueARM_OpARMANDconst(v)
+		return rewriteValueARM_OpARMANDconst_0(v)
 	case OpARMANDshiftLL:
-		return rewriteValueARM_OpARMANDshiftLL(v)
+		return rewriteValueARM_OpARMANDshiftLL_0(v)
 	case OpARMANDshiftLLreg:
-		return rewriteValueARM_OpARMANDshiftLLreg(v)
+		return rewriteValueARM_OpARMANDshiftLLreg_0(v)
 	case OpARMANDshiftRA:
-		return rewriteValueARM_OpARMANDshiftRA(v)
+		return rewriteValueARM_OpARMANDshiftRA_0(v)
 	case OpARMANDshiftRAreg:
-		return rewriteValueARM_OpARMANDshiftRAreg(v)
+		return rewriteValueARM_OpARMANDshiftRAreg_0(v)
 	case OpARMANDshiftRL:
-		return rewriteValueARM_OpARMANDshiftRL(v)
+		return rewriteValueARM_OpARMANDshiftRL_0(v)
 	case OpARMANDshiftRLreg:
-		return rewriteValueARM_OpARMANDshiftRLreg(v)
+		return rewriteValueARM_OpARMANDshiftRLreg_0(v)
 	case OpARMBIC:
-		return rewriteValueARM_OpARMBIC(v)
+		return rewriteValueARM_OpARMBIC_0(v)
 	case OpARMBICconst:
-		return rewriteValueARM_OpARMBICconst(v)
+		return rewriteValueARM_OpARMBICconst_0(v)
 	case OpARMBICshiftLL:
-		return rewriteValueARM_OpARMBICshiftLL(v)
+		return rewriteValueARM_OpARMBICshiftLL_0(v)
 	case OpARMBICshiftLLreg:
-		return rewriteValueARM_OpARMBICshiftLLreg(v)
+		return rewriteValueARM_OpARMBICshiftLLreg_0(v)
 	case OpARMBICshiftRA:
-		return rewriteValueARM_OpARMBICshiftRA(v)
+		return rewriteValueARM_OpARMBICshiftRA_0(v)
 	case OpARMBICshiftRAreg:
-		return rewriteValueARM_OpARMBICshiftRAreg(v)
+		return rewriteValueARM_OpARMBICshiftRAreg_0(v)
 	case OpARMBICshiftRL:
-		return rewriteValueARM_OpARMBICshiftRL(v)
+		return rewriteValueARM_OpARMBICshiftRL_0(v)
 	case OpARMBICshiftRLreg:
-		return rewriteValueARM_OpARMBICshiftRLreg(v)
+		return rewriteValueARM_OpARMBICshiftRLreg_0(v)
 	case OpARMCMOVWHSconst:
-		return rewriteValueARM_OpARMCMOVWHSconst(v)
+		return rewriteValueARM_OpARMCMOVWHSconst_0(v)
 	case OpARMCMOVWLSconst:
-		return rewriteValueARM_OpARMCMOVWLSconst(v)
+		return rewriteValueARM_OpARMCMOVWLSconst_0(v)
 	case OpARMCMP:
-		return rewriteValueARM_OpARMCMP(v)
+		return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v)
 	case OpARMCMPD:
-		return rewriteValueARM_OpARMCMPD(v)
+		return rewriteValueARM_OpARMCMPD_0(v)
 	case OpARMCMPF:
-		return rewriteValueARM_OpARMCMPF(v)
+		return rewriteValueARM_OpARMCMPF_0(v)
 	case OpARMCMPconst:
-		return rewriteValueARM_OpARMCMPconst(v)
+		return rewriteValueARM_OpARMCMPconst_0(v)
 	case OpARMCMPshiftLL:
-		return rewriteValueARM_OpARMCMPshiftLL(v)
+		return rewriteValueARM_OpARMCMPshiftLL_0(v)
 	case OpARMCMPshiftLLreg:
-		return rewriteValueARM_OpARMCMPshiftLLreg(v)
+		return rewriteValueARM_OpARMCMPshiftLLreg_0(v)
 	case OpARMCMPshiftRA:
-		return rewriteValueARM_OpARMCMPshiftRA(v)
+		return rewriteValueARM_OpARMCMPshiftRA_0(v)
 	case OpARMCMPshiftRAreg:
-		return rewriteValueARM_OpARMCMPshiftRAreg(v)
+		return rewriteValueARM_OpARMCMPshiftRAreg_0(v)
 	case OpARMCMPshiftRL:
-		return rewriteValueARM_OpARMCMPshiftRL(v)
+		return rewriteValueARM_OpARMCMPshiftRL_0(v)
 	case OpARMCMPshiftRLreg:
-		return rewriteValueARM_OpARMCMPshiftRLreg(v)
+		return rewriteValueARM_OpARMCMPshiftRLreg_0(v)
 	case OpARMEqual:
-		return rewriteValueARM_OpARMEqual(v)
+		return rewriteValueARM_OpARMEqual_0(v)
 	case OpARMGreaterEqual:
-		return rewriteValueARM_OpARMGreaterEqual(v)
+		return rewriteValueARM_OpARMGreaterEqual_0(v)
 	case OpARMGreaterEqualU:
-		return rewriteValueARM_OpARMGreaterEqualU(v)
+		return rewriteValueARM_OpARMGreaterEqualU_0(v)
 	case OpARMGreaterThan:
-		return rewriteValueARM_OpARMGreaterThan(v)
+		return rewriteValueARM_OpARMGreaterThan_0(v)
 	case OpARMGreaterThanU:
-		return rewriteValueARM_OpARMGreaterThanU(v)
+		return rewriteValueARM_OpARMGreaterThanU_0(v)
 	case OpARMLessEqual:
-		return rewriteValueARM_OpARMLessEqual(v)
+		return rewriteValueARM_OpARMLessEqual_0(v)
 	case OpARMLessEqualU:
-		return rewriteValueARM_OpARMLessEqualU(v)
+		return rewriteValueARM_OpARMLessEqualU_0(v)
 	case OpARMLessThan:
-		return rewriteValueARM_OpARMLessThan(v)
+		return rewriteValueARM_OpARMLessThan_0(v)
 	case OpARMLessThanU:
-		return rewriteValueARM_OpARMLessThanU(v)
+		return rewriteValueARM_OpARMLessThanU_0(v)
 	case OpARMMOVBUload:
-		return rewriteValueARM_OpARMMOVBUload(v)
+		return rewriteValueARM_OpARMMOVBUload_0(v)
 	case OpARMMOVBUreg:
-		return rewriteValueARM_OpARMMOVBUreg(v)
+		return rewriteValueARM_OpARMMOVBUreg_0(v)
 	case OpARMMOVBload:
-		return rewriteValueARM_OpARMMOVBload(v)
+		return rewriteValueARM_OpARMMOVBload_0(v)
 	case OpARMMOVBreg:
-		return rewriteValueARM_OpARMMOVBreg(v)
+		return rewriteValueARM_OpARMMOVBreg_0(v)
 	case OpARMMOVBstore:
-		return rewriteValueARM_OpARMMOVBstore(v)
+		return rewriteValueARM_OpARMMOVBstore_0(v)
 	case OpARMMOVDload:
-		return rewriteValueARM_OpARMMOVDload(v)
+		return rewriteValueARM_OpARMMOVDload_0(v)
 	case OpARMMOVDstore:
-		return rewriteValueARM_OpARMMOVDstore(v)
+		return rewriteValueARM_OpARMMOVDstore_0(v)
 	case OpARMMOVFload:
-		return rewriteValueARM_OpARMMOVFload(v)
+		return rewriteValueARM_OpARMMOVFload_0(v)
 	case OpARMMOVFstore:
-		return rewriteValueARM_OpARMMOVFstore(v)
+		return rewriteValueARM_OpARMMOVFstore_0(v)
 	case OpARMMOVHUload:
-		return rewriteValueARM_OpARMMOVHUload(v)
+		return rewriteValueARM_OpARMMOVHUload_0(v)
 	case OpARMMOVHUreg:
-		return rewriteValueARM_OpARMMOVHUreg(v)
+		return rewriteValueARM_OpARMMOVHUreg_0(v)
 	case OpARMMOVHload:
-		return rewriteValueARM_OpARMMOVHload(v)
+		return rewriteValueARM_OpARMMOVHload_0(v)
 	case OpARMMOVHreg:
-		return rewriteValueARM_OpARMMOVHreg(v)
+		return rewriteValueARM_OpARMMOVHreg_0(v)
 	case OpARMMOVHstore:
-		return rewriteValueARM_OpARMMOVHstore(v)
+		return rewriteValueARM_OpARMMOVHstore_0(v)
 	case OpARMMOVWload:
-		return rewriteValueARM_OpARMMOVWload(v)
+		return rewriteValueARM_OpARMMOVWload_0(v)
 	case OpARMMOVWloadidx:
-		return rewriteValueARM_OpARMMOVWloadidx(v)
+		return rewriteValueARM_OpARMMOVWloadidx_0(v)
 	case OpARMMOVWloadshiftLL:
-		return rewriteValueARM_OpARMMOVWloadshiftLL(v)
+		return rewriteValueARM_OpARMMOVWloadshiftLL_0(v)
 	case OpARMMOVWloadshiftRA:
-		return rewriteValueARM_OpARMMOVWloadshiftRA(v)
+		return rewriteValueARM_OpARMMOVWloadshiftRA_0(v)
 	case OpARMMOVWloadshiftRL:
-		return rewriteValueARM_OpARMMOVWloadshiftRL(v)
+		return rewriteValueARM_OpARMMOVWloadshiftRL_0(v)
 	case OpARMMOVWreg:
-		return rewriteValueARM_OpARMMOVWreg(v)
+		return rewriteValueARM_OpARMMOVWreg_0(v)
 	case OpARMMOVWstore:
-		return rewriteValueARM_OpARMMOVWstore(v)
+		return rewriteValueARM_OpARMMOVWstore_0(v)
 	case OpARMMOVWstoreidx:
-		return rewriteValueARM_OpARMMOVWstoreidx(v)
+		return rewriteValueARM_OpARMMOVWstoreidx_0(v)
 	case OpARMMOVWstoreshiftLL:
-		return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
+		return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v)
 	case OpARMMOVWstoreshiftRA:
-		return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
+		return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v)
 	case OpARMMOVWstoreshiftRL:
-		return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
+		return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v)
 	case OpARMMUL:
-		return rewriteValueARM_OpARMMUL(v)
+		return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v)
 	case OpARMMULA:
-		return rewriteValueARM_OpARMMULA(v)
+		return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v)
 	case OpARMMVN:
-		return rewriteValueARM_OpARMMVN(v)
+		return rewriteValueARM_OpARMMVN_0(v)
 	case OpARMMVNshiftLL:
-		return rewriteValueARM_OpARMMVNshiftLL(v)
+		return rewriteValueARM_OpARMMVNshiftLL_0(v)
 	case OpARMMVNshiftLLreg:
-		return rewriteValueARM_OpARMMVNshiftLLreg(v)
+		return rewriteValueARM_OpARMMVNshiftLLreg_0(v)
 	case OpARMMVNshiftRA:
-		return rewriteValueARM_OpARMMVNshiftRA(v)
+		return rewriteValueARM_OpARMMVNshiftRA_0(v)
 	case OpARMMVNshiftRAreg:
-		return rewriteValueARM_OpARMMVNshiftRAreg(v)
+		return rewriteValueARM_OpARMMVNshiftRAreg_0(v)
 	case OpARMMVNshiftRL:
-		return rewriteValueARM_OpARMMVNshiftRL(v)
+		return rewriteValueARM_OpARMMVNshiftRL_0(v)
 	case OpARMMVNshiftRLreg:
-		return rewriteValueARM_OpARMMVNshiftRLreg(v)
+		return rewriteValueARM_OpARMMVNshiftRLreg_0(v)
 	case OpARMNotEqual:
-		return rewriteValueARM_OpARMNotEqual(v)
+		return rewriteValueARM_OpARMNotEqual_0(v)
 	case OpARMOR:
-		return rewriteValueARM_OpARMOR(v)
+		return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v)
 	case OpARMORconst:
-		return rewriteValueARM_OpARMORconst(v)
+		return rewriteValueARM_OpARMORconst_0(v)
 	case OpARMORshiftLL:
-		return rewriteValueARM_OpARMORshiftLL(v)
+		return rewriteValueARM_OpARMORshiftLL_0(v)
 	case OpARMORshiftLLreg:
-		return rewriteValueARM_OpARMORshiftLLreg(v)
+		return rewriteValueARM_OpARMORshiftLLreg_0(v)
 	case OpARMORshiftRA:
-		return rewriteValueARM_OpARMORshiftRA(v)
+		return rewriteValueARM_OpARMORshiftRA_0(v)
 	case OpARMORshiftRAreg:
-		return rewriteValueARM_OpARMORshiftRAreg(v)
+		return rewriteValueARM_OpARMORshiftRAreg_0(v)
 	case OpARMORshiftRL:
-		return rewriteValueARM_OpARMORshiftRL(v)
+		return rewriteValueARM_OpARMORshiftRL_0(v)
 	case OpARMORshiftRLreg:
-		return rewriteValueARM_OpARMORshiftRLreg(v)
+		return rewriteValueARM_OpARMORshiftRLreg_0(v)
 	case OpARMRSB:
-		return rewriteValueARM_OpARMRSB(v)
+		return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v)
 	case OpARMRSBSshiftLL:
-		return rewriteValueARM_OpARMRSBSshiftLL(v)
+		return rewriteValueARM_OpARMRSBSshiftLL_0(v)
 	case OpARMRSBSshiftLLreg:
-		return rewriteValueARM_OpARMRSBSshiftLLreg(v)
+		return rewriteValueARM_OpARMRSBSshiftLLreg_0(v)
 	case OpARMRSBSshiftRA:
-		return rewriteValueARM_OpARMRSBSshiftRA(v)
+		return rewriteValueARM_OpARMRSBSshiftRA_0(v)
 	case OpARMRSBSshiftRAreg:
-		return rewriteValueARM_OpARMRSBSshiftRAreg(v)
+		return rewriteValueARM_OpARMRSBSshiftRAreg_0(v)
 	case OpARMRSBSshiftRL:
-		return rewriteValueARM_OpARMRSBSshiftRL(v)
+		return rewriteValueARM_OpARMRSBSshiftRL_0(v)
 	case OpARMRSBSshiftRLreg:
-		return rewriteValueARM_OpARMRSBSshiftRLreg(v)
+		return rewriteValueARM_OpARMRSBSshiftRLreg_0(v)
 	case OpARMRSBconst:
-		return rewriteValueARM_OpARMRSBconst(v)
+		return rewriteValueARM_OpARMRSBconst_0(v)
 	case OpARMRSBshiftLL:
-		return rewriteValueARM_OpARMRSBshiftLL(v)
+		return rewriteValueARM_OpARMRSBshiftLL_0(v)
 	case OpARMRSBshiftLLreg:
-		return rewriteValueARM_OpARMRSBshiftLLreg(v)
+		return rewriteValueARM_OpARMRSBshiftLLreg_0(v)
 	case OpARMRSBshiftRA:
-		return rewriteValueARM_OpARMRSBshiftRA(v)
+		return rewriteValueARM_OpARMRSBshiftRA_0(v)
 	case OpARMRSBshiftRAreg:
-		return rewriteValueARM_OpARMRSBshiftRAreg(v)
+		return rewriteValueARM_OpARMRSBshiftRAreg_0(v)
 	case OpARMRSBshiftRL:
-		return rewriteValueARM_OpARMRSBshiftRL(v)
+		return rewriteValueARM_OpARMRSBshiftRL_0(v)
 	case OpARMRSBshiftRLreg:
-		return rewriteValueARM_OpARMRSBshiftRLreg(v)
+		return rewriteValueARM_OpARMRSBshiftRLreg_0(v)
 	case OpARMRSCconst:
-		return rewriteValueARM_OpARMRSCconst(v)
+		return rewriteValueARM_OpARMRSCconst_0(v)
 	case OpARMRSCshiftLL:
-		return rewriteValueARM_OpARMRSCshiftLL(v)
+		return rewriteValueARM_OpARMRSCshiftLL_0(v)
 	case OpARMRSCshiftLLreg:
-		return rewriteValueARM_OpARMRSCshiftLLreg(v)
+		return rewriteValueARM_OpARMRSCshiftLLreg_0(v)
 	case OpARMRSCshiftRA:
-		return rewriteValueARM_OpARMRSCshiftRA(v)
+		return rewriteValueARM_OpARMRSCshiftRA_0(v)
 	case OpARMRSCshiftRAreg:
-		return rewriteValueARM_OpARMRSCshiftRAreg(v)
+		return rewriteValueARM_OpARMRSCshiftRAreg_0(v)
 	case OpARMRSCshiftRL:
-		return rewriteValueARM_OpARMRSCshiftRL(v)
+		return rewriteValueARM_OpARMRSCshiftRL_0(v)
 	case OpARMRSCshiftRLreg:
-		return rewriteValueARM_OpARMRSCshiftRLreg(v)
+		return rewriteValueARM_OpARMRSCshiftRLreg_0(v)
 	case OpARMSBC:
-		return rewriteValueARM_OpARMSBC(v)
+		return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v)
 	case OpARMSBCconst:
-		return rewriteValueARM_OpARMSBCconst(v)
+		return rewriteValueARM_OpARMSBCconst_0(v)
 	case OpARMSBCshiftLL:
-		return rewriteValueARM_OpARMSBCshiftLL(v)
+		return rewriteValueARM_OpARMSBCshiftLL_0(v)
 	case OpARMSBCshiftLLreg:
-		return rewriteValueARM_OpARMSBCshiftLLreg(v)
+		return rewriteValueARM_OpARMSBCshiftLLreg_0(v)
 	case OpARMSBCshiftRA:
-		return rewriteValueARM_OpARMSBCshiftRA(v)
+		return rewriteValueARM_OpARMSBCshiftRA_0(v)
 	case OpARMSBCshiftRAreg:
-		return rewriteValueARM_OpARMSBCshiftRAreg(v)
+		return rewriteValueARM_OpARMSBCshiftRAreg_0(v)
 	case OpARMSBCshiftRL:
-		return rewriteValueARM_OpARMSBCshiftRL(v)
+		return rewriteValueARM_OpARMSBCshiftRL_0(v)
 	case OpARMSBCshiftRLreg:
-		return rewriteValueARM_OpARMSBCshiftRLreg(v)
+		return rewriteValueARM_OpARMSBCshiftRLreg_0(v)
 	case OpARMSLL:
-		return rewriteValueARM_OpARMSLL(v)
+		return rewriteValueARM_OpARMSLL_0(v)
 	case OpARMSLLconst:
-		return rewriteValueARM_OpARMSLLconst(v)
+		return rewriteValueARM_OpARMSLLconst_0(v)
 	case OpARMSRA:
-		return rewriteValueARM_OpARMSRA(v)
+		return rewriteValueARM_OpARMSRA_0(v)
 	case OpARMSRAcond:
-		return rewriteValueARM_OpARMSRAcond(v)
+		return rewriteValueARM_OpARMSRAcond_0(v)
 	case OpARMSRAconst:
-		return rewriteValueARM_OpARMSRAconst(v)
+		return rewriteValueARM_OpARMSRAconst_0(v)
 	case OpARMSRL:
-		return rewriteValueARM_OpARMSRL(v)
+		return rewriteValueARM_OpARMSRL_0(v)
 	case OpARMSRLconst:
-		return rewriteValueARM_OpARMSRLconst(v)
+		return rewriteValueARM_OpARMSRLconst_0(v)
 	case OpARMSUB:
-		return rewriteValueARM_OpARMSUB(v)
+		return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v)
 	case OpARMSUBS:
-		return rewriteValueARM_OpARMSUBS(v)
+		return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v)
 	case OpARMSUBSshiftLL:
-		return rewriteValueARM_OpARMSUBSshiftLL(v)
+		return rewriteValueARM_OpARMSUBSshiftLL_0(v)
 	case OpARMSUBSshiftLLreg:
-		return rewriteValueARM_OpARMSUBSshiftLLreg(v)
+		return rewriteValueARM_OpARMSUBSshiftLLreg_0(v)
 	case OpARMSUBSshiftRA:
-		return rewriteValueARM_OpARMSUBSshiftRA(v)
+		return rewriteValueARM_OpARMSUBSshiftRA_0(v)
 	case OpARMSUBSshiftRAreg:
-		return rewriteValueARM_OpARMSUBSshiftRAreg(v)
+		return rewriteValueARM_OpARMSUBSshiftRAreg_0(v)
 	case OpARMSUBSshiftRL:
-		return rewriteValueARM_OpARMSUBSshiftRL(v)
+		return rewriteValueARM_OpARMSUBSshiftRL_0(v)
 	case OpARMSUBSshiftRLreg:
-		return rewriteValueARM_OpARMSUBSshiftRLreg(v)
+		return rewriteValueARM_OpARMSUBSshiftRLreg_0(v)
 	case OpARMSUBconst:
-		return rewriteValueARM_OpARMSUBconst(v)
+		return rewriteValueARM_OpARMSUBconst_0(v)
 	case OpARMSUBshiftLL:
-		return rewriteValueARM_OpARMSUBshiftLL(v)
+		return rewriteValueARM_OpARMSUBshiftLL_0(v)
 	case OpARMSUBshiftLLreg:
-		return rewriteValueARM_OpARMSUBshiftLLreg(v)
+		return rewriteValueARM_OpARMSUBshiftLLreg_0(v)
 	case OpARMSUBshiftRA:
-		return rewriteValueARM_OpARMSUBshiftRA(v)
+		return rewriteValueARM_OpARMSUBshiftRA_0(v)
 	case OpARMSUBshiftRAreg:
-		return rewriteValueARM_OpARMSUBshiftRAreg(v)
+		return rewriteValueARM_OpARMSUBshiftRAreg_0(v)
 	case OpARMSUBshiftRL:
-		return rewriteValueARM_OpARMSUBshiftRL(v)
+		return rewriteValueARM_OpARMSUBshiftRL_0(v)
 	case OpARMSUBshiftRLreg:
-		return rewriteValueARM_OpARMSUBshiftRLreg(v)
+		return rewriteValueARM_OpARMSUBshiftRLreg_0(v)
 	case OpARMXOR:
-		return rewriteValueARM_OpARMXOR(v)
+		return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v)
 	case OpARMXORconst:
-		return rewriteValueARM_OpARMXORconst(v)
+		return rewriteValueARM_OpARMXORconst_0(v)
 	case OpARMXORshiftLL:
-		return rewriteValueARM_OpARMXORshiftLL(v)
+		return rewriteValueARM_OpARMXORshiftLL_0(v)
 	case OpARMXORshiftLLreg:
-		return rewriteValueARM_OpARMXORshiftLLreg(v)
+		return rewriteValueARM_OpARMXORshiftLLreg_0(v)
 	case OpARMXORshiftRA:
-		return rewriteValueARM_OpARMXORshiftRA(v)
+		return rewriteValueARM_OpARMXORshiftRA_0(v)
 	case OpARMXORshiftRAreg:
-		return rewriteValueARM_OpARMXORshiftRAreg(v)
+		return rewriteValueARM_OpARMXORshiftRAreg_0(v)
 	case OpARMXORshiftRL:
-		return rewriteValueARM_OpARMXORshiftRL(v)
+		return rewriteValueARM_OpARMXORshiftRL_0(v)
 	case OpARMXORshiftRLreg:
-		return rewriteValueARM_OpARMXORshiftRLreg(v)
+		return rewriteValueARM_OpARMXORshiftRLreg_0(v)
 	case OpARMXORshiftRR:
-		return rewriteValueARM_OpARMXORshiftRR(v)
+		return rewriteValueARM_OpARMXORshiftRR_0(v)
 	case OpAdd16:
-		return rewriteValueARM_OpAdd16(v)
+		return rewriteValueARM_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueARM_OpAdd32(v)
+		return rewriteValueARM_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueARM_OpAdd32F(v)
+		return rewriteValueARM_OpAdd32F_0(v)
 	case OpAdd32carry:
-		return rewriteValueARM_OpAdd32carry(v)
+		return rewriteValueARM_OpAdd32carry_0(v)
 	case OpAdd32withcarry:
-		return rewriteValueARM_OpAdd32withcarry(v)
+		return rewriteValueARM_OpAdd32withcarry_0(v)
 	case OpAdd64F:
-		return rewriteValueARM_OpAdd64F(v)
+		return rewriteValueARM_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueARM_OpAdd8(v)
+		return rewriteValueARM_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueARM_OpAddPtr(v)
+		return rewriteValueARM_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueARM_OpAddr(v)
+		return rewriteValueARM_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueARM_OpAnd16(v)
+		return rewriteValueARM_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueARM_OpAnd32(v)
+		return rewriteValueARM_OpAnd32_0(v)
 	case OpAnd8:
-		return rewriteValueARM_OpAnd8(v)
+		return rewriteValueARM_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueARM_OpAndB(v)
+		return rewriteValueARM_OpAndB_0(v)
 	case OpAvg32u:
-		return rewriteValueARM_OpAvg32u(v)
+		return rewriteValueARM_OpAvg32u_0(v)
 	case OpBitLen32:
-		return rewriteValueARM_OpBitLen32(v)
+		return rewriteValueARM_OpBitLen32_0(v)
 	case OpBswap32:
-		return rewriteValueARM_OpBswap32(v)
+		return rewriteValueARM_OpBswap32_0(v)
 	case OpClosureCall:
-		return rewriteValueARM_OpClosureCall(v)
+		return rewriteValueARM_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueARM_OpCom16(v)
+		return rewriteValueARM_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueARM_OpCom32(v)
+		return rewriteValueARM_OpCom32_0(v)
 	case OpCom8:
-		return rewriteValueARM_OpCom8(v)
+		return rewriteValueARM_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueARM_OpConst16(v)
+		return rewriteValueARM_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueARM_OpConst32(v)
+		return rewriteValueARM_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueARM_OpConst32F(v)
+		return rewriteValueARM_OpConst32F_0(v)
 	case OpConst64F:
-		return rewriteValueARM_OpConst64F(v)
+		return rewriteValueARM_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueARM_OpConst8(v)
+		return rewriteValueARM_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueARM_OpConstBool(v)
+		return rewriteValueARM_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueARM_OpConstNil(v)
+		return rewriteValueARM_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueARM_OpConvert(v)
+		return rewriteValueARM_OpConvert_0(v)
 	case OpCtz32:
-		return rewriteValueARM_OpCtz32(v)
+		return rewriteValueARM_OpCtz32_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueARM_OpCvt32Fto32(v)
+		return rewriteValueARM_OpCvt32Fto32_0(v)
 	case OpCvt32Fto32U:
-		return rewriteValueARM_OpCvt32Fto32U(v)
+		return rewriteValueARM_OpCvt32Fto32U_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueARM_OpCvt32Fto64F(v)
+		return rewriteValueARM_OpCvt32Fto64F_0(v)
 	case OpCvt32Uto32F:
-		return rewriteValueARM_OpCvt32Uto32F(v)
+		return rewriteValueARM_OpCvt32Uto32F_0(v)
 	case OpCvt32Uto64F:
-		return rewriteValueARM_OpCvt32Uto64F(v)
+		return rewriteValueARM_OpCvt32Uto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueARM_OpCvt32to32F(v)
+		return rewriteValueARM_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueARM_OpCvt32to64F(v)
+		return rewriteValueARM_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueARM_OpCvt64Fto32(v)
+		return rewriteValueARM_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueARM_OpCvt64Fto32F(v)
+		return rewriteValueARM_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto32U:
-		return rewriteValueARM_OpCvt64Fto32U(v)
+		return rewriteValueARM_OpCvt64Fto32U_0(v)
 	case OpDiv16:
-		return rewriteValueARM_OpDiv16(v)
+		return rewriteValueARM_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueARM_OpDiv16u(v)
+		return rewriteValueARM_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueARM_OpDiv32(v)
+		return rewriteValueARM_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueARM_OpDiv32F(v)
+		return rewriteValueARM_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueARM_OpDiv32u(v)
+		return rewriteValueARM_OpDiv32u_0(v)
 	case OpDiv64F:
-		return rewriteValueARM_OpDiv64F(v)
+		return rewriteValueARM_OpDiv64F_0(v)
 	case OpDiv8:
-		return rewriteValueARM_OpDiv8(v)
+		return rewriteValueARM_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueARM_OpDiv8u(v)
+		return rewriteValueARM_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueARM_OpEq16(v)
+		return rewriteValueARM_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueARM_OpEq32(v)
+		return rewriteValueARM_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueARM_OpEq32F(v)
+		return rewriteValueARM_OpEq32F_0(v)
 	case OpEq64F:
-		return rewriteValueARM_OpEq64F(v)
+		return rewriteValueARM_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueARM_OpEq8(v)
+		return rewriteValueARM_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueARM_OpEqB(v)
+		return rewriteValueARM_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueARM_OpEqPtr(v)
+		return rewriteValueARM_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueARM_OpGeq16(v)
+		return rewriteValueARM_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueARM_OpGeq16U(v)
+		return rewriteValueARM_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueARM_OpGeq32(v)
+		return rewriteValueARM_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueARM_OpGeq32F(v)
+		return rewriteValueARM_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueARM_OpGeq32U(v)
+		return rewriteValueARM_OpGeq32U_0(v)
 	case OpGeq64F:
-		return rewriteValueARM_OpGeq64F(v)
+		return rewriteValueARM_OpGeq64F_0(v)
 	case OpGeq8:
-		return rewriteValueARM_OpGeq8(v)
+		return rewriteValueARM_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueARM_OpGeq8U(v)
+		return rewriteValueARM_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueARM_OpGetClosurePtr(v)
+		return rewriteValueARM_OpGetClosurePtr_0(v)
 	case OpGreater16:
-		return rewriteValueARM_OpGreater16(v)
+		return rewriteValueARM_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueARM_OpGreater16U(v)
+		return rewriteValueARM_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueARM_OpGreater32(v)
+		return rewriteValueARM_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueARM_OpGreater32F(v)
+		return rewriteValueARM_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueARM_OpGreater32U(v)
+		return rewriteValueARM_OpGreater32U_0(v)
 	case OpGreater64F:
-		return rewriteValueARM_OpGreater64F(v)
+		return rewriteValueARM_OpGreater64F_0(v)
 	case OpGreater8:
-		return rewriteValueARM_OpGreater8(v)
+		return rewriteValueARM_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueARM_OpGreater8U(v)
+		return rewriteValueARM_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueARM_OpHmul32(v)
+		return rewriteValueARM_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueARM_OpHmul32u(v)
+		return rewriteValueARM_OpHmul32u_0(v)
 	case OpInterCall:
-		return rewriteValueARM_OpInterCall(v)
+		return rewriteValueARM_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueARM_OpIsInBounds(v)
+		return rewriteValueARM_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueARM_OpIsNonNil(v)
+		return rewriteValueARM_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueARM_OpIsSliceInBounds(v)
+		return rewriteValueARM_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueARM_OpLeq16(v)
+		return rewriteValueARM_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueARM_OpLeq16U(v)
+		return rewriteValueARM_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueARM_OpLeq32(v)
+		return rewriteValueARM_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueARM_OpLeq32F(v)
+		return rewriteValueARM_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueARM_OpLeq32U(v)
+		return rewriteValueARM_OpLeq32U_0(v)
 	case OpLeq64F:
-		return rewriteValueARM_OpLeq64F(v)
+		return rewriteValueARM_OpLeq64F_0(v)
 	case OpLeq8:
-		return rewriteValueARM_OpLeq8(v)
+		return rewriteValueARM_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueARM_OpLeq8U(v)
+		return rewriteValueARM_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueARM_OpLess16(v)
+		return rewriteValueARM_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueARM_OpLess16U(v)
+		return rewriteValueARM_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueARM_OpLess32(v)
+		return rewriteValueARM_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueARM_OpLess32F(v)
+		return rewriteValueARM_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueARM_OpLess32U(v)
+		return rewriteValueARM_OpLess32U_0(v)
 	case OpLess64F:
-		return rewriteValueARM_OpLess64F(v)
+		return rewriteValueARM_OpLess64F_0(v)
 	case OpLess8:
-		return rewriteValueARM_OpLess8(v)
+		return rewriteValueARM_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueARM_OpLess8U(v)
+		return rewriteValueARM_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueARM_OpLoad(v)
+		return rewriteValueARM_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueARM_OpLsh16x16(v)
+		return rewriteValueARM_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueARM_OpLsh16x32(v)
+		return rewriteValueARM_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueARM_OpLsh16x64(v)
+		return rewriteValueARM_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueARM_OpLsh16x8(v)
+		return rewriteValueARM_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueARM_OpLsh32x16(v)
+		return rewriteValueARM_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueARM_OpLsh32x32(v)
+		return rewriteValueARM_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueARM_OpLsh32x64(v)
+		return rewriteValueARM_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueARM_OpLsh32x8(v)
+		return rewriteValueARM_OpLsh32x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueARM_OpLsh8x16(v)
+		return rewriteValueARM_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueARM_OpLsh8x32(v)
+		return rewriteValueARM_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueARM_OpLsh8x64(v)
+		return rewriteValueARM_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueARM_OpLsh8x8(v)
+		return rewriteValueARM_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValueARM_OpMod16(v)
+		return rewriteValueARM_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueARM_OpMod16u(v)
+		return rewriteValueARM_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueARM_OpMod32(v)
+		return rewriteValueARM_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueARM_OpMod32u(v)
+		return rewriteValueARM_OpMod32u_0(v)
 	case OpMod8:
-		return rewriteValueARM_OpMod8(v)
+		return rewriteValueARM_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueARM_OpMod8u(v)
+		return rewriteValueARM_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueARM_OpMove(v)
+		return rewriteValueARM_OpMove_0(v)
 	case OpMul16:
-		return rewriteValueARM_OpMul16(v)
+		return rewriteValueARM_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueARM_OpMul32(v)
+		return rewriteValueARM_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueARM_OpMul32F(v)
+		return rewriteValueARM_OpMul32F_0(v)
 	case OpMul32uhilo:
-		return rewriteValueARM_OpMul32uhilo(v)
+		return rewriteValueARM_OpMul32uhilo_0(v)
 	case OpMul64F:
-		return rewriteValueARM_OpMul64F(v)
+		return rewriteValueARM_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValueARM_OpMul8(v)
+		return rewriteValueARM_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueARM_OpNeg16(v)
+		return rewriteValueARM_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueARM_OpNeg32(v)
+		return rewriteValueARM_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueARM_OpNeg32F(v)
+		return rewriteValueARM_OpNeg32F_0(v)
 	case OpNeg64F:
-		return rewriteValueARM_OpNeg64F(v)
+		return rewriteValueARM_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueARM_OpNeg8(v)
+		return rewriteValueARM_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueARM_OpNeq16(v)
+		return rewriteValueARM_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueARM_OpNeq32(v)
+		return rewriteValueARM_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueARM_OpNeq32F(v)
+		return rewriteValueARM_OpNeq32F_0(v)
 	case OpNeq64F:
-		return rewriteValueARM_OpNeq64F(v)
+		return rewriteValueARM_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueARM_OpNeq8(v)
+		return rewriteValueARM_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueARM_OpNeqB(v)
+		return rewriteValueARM_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueARM_OpNeqPtr(v)
+		return rewriteValueARM_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueARM_OpNilCheck(v)
+		return rewriteValueARM_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueARM_OpNot(v)
+		return rewriteValueARM_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueARM_OpOffPtr(v)
+		return rewriteValueARM_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueARM_OpOr16(v)
+		return rewriteValueARM_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueARM_OpOr32(v)
+		return rewriteValueARM_OpOr32_0(v)
 	case OpOr8:
-		return rewriteValueARM_OpOr8(v)
+		return rewriteValueARM_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueARM_OpOrB(v)
+		return rewriteValueARM_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValueARM_OpRound32F(v)
+		return rewriteValueARM_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueARM_OpRound64F(v)
+		return rewriteValueARM_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueARM_OpRsh16Ux16(v)
+		return rewriteValueARM_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueARM_OpRsh16Ux32(v)
+		return rewriteValueARM_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueARM_OpRsh16Ux64(v)
+		return rewriteValueARM_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueARM_OpRsh16Ux8(v)
+		return rewriteValueARM_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueARM_OpRsh16x16(v)
+		return rewriteValueARM_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueARM_OpRsh16x32(v)
+		return rewriteValueARM_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueARM_OpRsh16x64(v)
+		return rewriteValueARM_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueARM_OpRsh16x8(v)
+		return rewriteValueARM_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueARM_OpRsh32Ux16(v)
+		return rewriteValueARM_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueARM_OpRsh32Ux32(v)
+		return rewriteValueARM_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueARM_OpRsh32Ux64(v)
+		return rewriteValueARM_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueARM_OpRsh32Ux8(v)
+		return rewriteValueARM_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueARM_OpRsh32x16(v)
+		return rewriteValueARM_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueARM_OpRsh32x32(v)
+		return rewriteValueARM_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueARM_OpRsh32x64(v)
+		return rewriteValueARM_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueARM_OpRsh32x8(v)
+		return rewriteValueARM_OpRsh32x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueARM_OpRsh8Ux16(v)
+		return rewriteValueARM_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueARM_OpRsh8Ux32(v)
+		return rewriteValueARM_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueARM_OpRsh8Ux64(v)
+		return rewriteValueARM_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueARM_OpRsh8Ux8(v)
+		return rewriteValueARM_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueARM_OpRsh8x16(v)
+		return rewriteValueARM_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueARM_OpRsh8x32(v)
+		return rewriteValueARM_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueARM_OpRsh8x64(v)
+		return rewriteValueARM_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueARM_OpRsh8x8(v)
+		return rewriteValueARM_OpRsh8x8_0(v)
 	case OpSelect0:
-		return rewriteValueARM_OpSelect0(v)
+		return rewriteValueARM_OpSelect0_0(v)
 	case OpSelect1:
-		return rewriteValueARM_OpSelect1(v)
+		return rewriteValueARM_OpSelect1_0(v)
 	case OpSignExt16to32:
-		return rewriteValueARM_OpSignExt16to32(v)
+		return rewriteValueARM_OpSignExt16to32_0(v)
 	case OpSignExt8to16:
-		return rewriteValueARM_OpSignExt8to16(v)
+		return rewriteValueARM_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueARM_OpSignExt8to32(v)
+		return rewriteValueARM_OpSignExt8to32_0(v)
 	case OpSignmask:
-		return rewriteValueARM_OpSignmask(v)
+		return rewriteValueARM_OpSignmask_0(v)
 	case OpSlicemask:
-		return rewriteValueARM_OpSlicemask(v)
+		return rewriteValueARM_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValueARM_OpSqrt(v)
+		return rewriteValueARM_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValueARM_OpStaticCall(v)
+		return rewriteValueARM_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueARM_OpStore(v)
+		return rewriteValueARM_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueARM_OpSub16(v)
+		return rewriteValueARM_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueARM_OpSub32(v)
+		return rewriteValueARM_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueARM_OpSub32F(v)
+		return rewriteValueARM_OpSub32F_0(v)
 	case OpSub32carry:
-		return rewriteValueARM_OpSub32carry(v)
+		return rewriteValueARM_OpSub32carry_0(v)
 	case OpSub32withcarry:
-		return rewriteValueARM_OpSub32withcarry(v)
+		return rewriteValueARM_OpSub32withcarry_0(v)
 	case OpSub64F:
-		return rewriteValueARM_OpSub64F(v)
+		return rewriteValueARM_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueARM_OpSub8(v)
+		return rewriteValueARM_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueARM_OpSubPtr(v)
+		return rewriteValueARM_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueARM_OpTrunc16to8(v)
+		return rewriteValueARM_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueARM_OpTrunc32to16(v)
+		return rewriteValueARM_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueARM_OpTrunc32to8(v)
+		return rewriteValueARM_OpTrunc32to8_0(v)
 	case OpXor16:
-		return rewriteValueARM_OpXor16(v)
+		return rewriteValueARM_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueARM_OpXor32(v)
+		return rewriteValueARM_OpXor32_0(v)
 	case OpXor8:
-		return rewriteValueARM_OpXor8(v)
+		return rewriteValueARM_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueARM_OpZero(v)
+		return rewriteValueARM_OpZero_0(v)
 	case OpZeroExt16to32:
-		return rewriteValueARM_OpZeroExt16to32(v)
+		return rewriteValueARM_OpZeroExt16to32_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueARM_OpZeroExt8to16(v)
+		return rewriteValueARM_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueARM_OpZeroExt8to32(v)
+		return rewriteValueARM_OpZeroExt8to32_0(v)
 	case OpZeromask:
-		return rewriteValueARM_OpZeromask(v)
+		return rewriteValueARM_OpZeromask_0(v)
 	}
 	return false
 }
-func rewriteValueARM_OpARMADC(v *Value) bool {
+func rewriteValueARM_OpARMADC_0(v *Value) bool {
 	// match: (ADC (MOVWconst [c]) x flags)
 	// cond:
 	// result: (ADCconst [c] x flags)
@@ -911,6 +911,9 @@
 		v.AddArg(flags)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMADC_10(v *Value) bool {
 	// match: (ADC (SRLconst [c] y) x flags)
 	// cond:
 	// result: (ADCshiftRL x y [c] flags)
@@ -1101,6 +1104,9 @@
 		v.AddArg(flags)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMADC_20(v *Value) bool {
 	// match: (ADC x (SRL y z) flags)
 	// cond:
 	// result: (ADCshiftRLreg x y z flags)
@@ -1255,7 +1261,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCconst(v *Value) bool {
+func rewriteValueARM_OpARMADCconst_0(v *Value) bool {
 	// match: (ADCconst [c] (ADDconst [d] x) flags)
 	// cond:
 	// result: (ADCconst [int64(int32(c+d))] x flags)
@@ -1294,7 +1300,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftLL (MOVWconst [c]) x [d] flags)
@@ -1338,7 +1344,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftLLreg (MOVWconst [c]) x y flags)
@@ -1383,7 +1389,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftRA (MOVWconst [c]) x [d] flags)
@@ -1427,7 +1433,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftRAreg (MOVWconst [c]) x y flags)
@@ -1472,7 +1478,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftRL (MOVWconst [c]) x [d] flags)
@@ -1516,7 +1522,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADCshiftRLreg (MOVWconst [c]) x y flags)
@@ -1561,9 +1567,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADD(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueARM_OpARMADD_0(v *Value) bool {
 	// match: (ADD x (MOVWconst [c]))
 	// cond:
 	// result: (ADDconst [c] x)
@@ -1730,6 +1734,11 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMADD_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ADD x (SRL y z))
 	// cond:
 	// result: (ADDshiftRLreg x y z)
@@ -1920,7 +1929,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDS(v *Value) bool {
+func rewriteValueARM_OpARMADDS_0(v *Value) bool {
 	// match: (ADDS x (MOVWconst [c]))
 	// cond:
 	// result: (ADDSconst [c] x)
@@ -2087,6 +2096,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMADDS_10(v *Value) bool {
 	// match: (ADDS x (SRL y z))
 	// cond:
 	// result: (ADDSshiftRLreg x y z)
@@ -2157,7 +2169,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftLL (MOVWconst [c]) x [d])
@@ -2197,7 +2209,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftLLreg (MOVWconst [c]) x y)
@@ -2238,7 +2250,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftRA (MOVWconst [c]) x [d])
@@ -2278,7 +2290,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftRAreg (MOVWconst [c]) x y)
@@ -2319,7 +2331,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftRL (MOVWconst [c]) x [d])
@@ -2359,7 +2371,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDSshiftRLreg (MOVWconst [c]) x y)
@@ -2400,7 +2412,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDconst(v *Value) bool {
+func rewriteValueARM_OpARMADDconst_0(v *Value) bool {
 	// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
 	// cond:
 	// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2496,7 +2508,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftLL (MOVWconst [c]) x [d])
@@ -2557,7 +2569,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftLLreg (MOVWconst [c]) x y)
@@ -2598,7 +2610,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRA (MOVWconst [c]) x [d])
@@ -2638,7 +2650,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRAreg (MOVWconst [c]) x y)
@@ -2679,7 +2691,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRL (MOVWconst [c]) x [d])
@@ -2740,7 +2752,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRLreg (MOVWconst [c]) x y)
@@ -2781,7 +2793,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMAND(v *Value) bool {
+func rewriteValueARM_OpARMAND_0(v *Value) bool {
 	// match: (AND x (MOVWconst [c]))
 	// cond:
 	// result: (ANDconst [c] x)
@@ -2948,6 +2960,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMAND_10(v *Value) bool {
 	// match: (AND x (SRL y z))
 	// cond:
 	// result: (ANDshiftRLreg x y z)
@@ -3110,6 +3125,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMAND_20(v *Value) bool {
 	// match: (AND (MVNshiftRL y [c]) x)
 	// cond:
 	// result: (BICshiftRL x y [c])
@@ -3163,7 +3181,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDconst(v *Value) bool {
+func rewriteValueARM_OpARMANDconst_0(v *Value) bool {
 	// match: (ANDconst [0] _)
 	// cond:
 	// result: (MOVWconst [0])
@@ -3221,7 +3239,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftLL (MOVWconst [c]) x [d])
@@ -3283,7 +3301,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftLLreg (MOVWconst [c]) x y)
@@ -3324,7 +3342,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRA (MOVWconst [c]) x [d])
@@ -3386,7 +3404,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRAreg (MOVWconst [c]) x y)
@@ -3427,7 +3445,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRL (MOVWconst [c]) x [d])
@@ -3489,7 +3507,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRLreg (MOVWconst [c]) x y)
@@ -3530,7 +3548,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBIC(v *Value) bool {
+func rewriteValueARM_OpARMBIC_0(v *Value) bool {
 	// match: (BIC x (MOVWconst [c]))
 	// cond:
 	// result: (BICconst [c] x)
@@ -3662,7 +3680,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICconst(v *Value) bool {
+func rewriteValueARM_OpARMBICconst_0(v *Value) bool {
 	// match: (BICconst [0] x)
 	// cond:
 	// result: x
@@ -3704,7 +3722,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool {
 	// match: (BICshiftLL x (MOVWconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(uint32(c)<<uint64(d))])
@@ -3744,7 +3762,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool {
 	// match: (BICshiftLLreg x y (MOVWconst [c]))
 	// cond:
 	// result: (BICshiftLL x y [c])
@@ -3764,7 +3782,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool {
 	// match: (BICshiftRA x (MOVWconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(int32(c)>>uint64(d))])
@@ -3804,7 +3822,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool {
 	// match: (BICshiftRAreg x y (MOVWconst [c]))
 	// cond:
 	// result: (BICshiftRA x y [c])
@@ -3824,7 +3842,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool {
 	// match: (BICshiftRL x (MOVWconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(uint32(c)>>uint64(d))])
@@ -3864,7 +3882,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool {
 	// match: (BICshiftRLreg x y (MOVWconst [c]))
 	// cond:
 	// result: (BICshiftRL x y [c])
@@ -3884,7 +3902,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool {
 	// match: (CMOVWHSconst _ (FlagEQ) [c])
 	// cond:
 	// result: (MOVWconst [c])
@@ -3971,7 +3989,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool {
 	// match: (CMOVWLSconst _ (FlagEQ) [c])
 	// cond:
 	// result: (MOVWconst [c])
@@ -4058,7 +4076,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMP(v *Value) bool {
+func rewriteValueARM_OpARMCMP_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMP x (MOVWconst [c]))
@@ -4237,6 +4255,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMCMP_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (CMP x (SRL y z))
 	// cond:
 	// result: (CMPshiftRLreg x y z)
@@ -4311,7 +4334,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPD(v *Value) bool {
+func rewriteValueARM_OpARMCMPD_0(v *Value) bool {
 	// match: (CMPD x (MOVDconst [0]))
 	// cond:
 	// result: (CMPD0 x)
@@ -4330,7 +4353,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPF(v *Value) bool {
+func rewriteValueARM_OpARMCMPF_0(v *Value) bool {
 	// match: (CMPF x (MOVFconst [0]))
 	// cond:
 	// result: (CMPF0 x)
@@ -4349,7 +4372,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPconst(v *Value) bool {
+func rewriteValueARM_OpARMCMPconst_0(v *Value) bool {
 	// match: (CMPconst (MOVWconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -4494,7 +4517,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftLL (MOVWconst [c]) x [d])
@@ -4536,7 +4559,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftLLreg (MOVWconst [c]) x y)
@@ -4579,7 +4602,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRA (MOVWconst [c]) x [d])
@@ -4621,7 +4644,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRAreg (MOVWconst [c]) x y)
@@ -4664,7 +4687,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRL (MOVWconst [c]) x [d])
@@ -4706,7 +4729,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRLreg (MOVWconst [c]) x y)
@@ -4749,7 +4772,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMEqual(v *Value) bool {
+func rewriteValueARM_OpARMEqual_0(v *Value) bool {
 	// match: (Equal (FlagEQ))
 	// cond:
 	// result: (MOVWconst [1])
@@ -4825,7 +4848,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMGreaterEqual(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool {
 	// match: (GreaterEqual (FlagEQ))
 	// cond:
 	// result: (MOVWconst [1])
@@ -4901,7 +4924,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool {
 	// match: (GreaterEqualU (FlagEQ))
 	// cond:
 	// result: (MOVWconst [1])
@@ -4977,7 +5000,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMGreaterThan(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool {
 	// match: (GreaterThan (FlagEQ))
 	// cond:
 	// result: (MOVWconst [0])
@@ -5053,7 +5076,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMGreaterThanU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool {
 	// match: (GreaterThanU (FlagEQ))
 	// cond:
 	// result: (MOVWconst [0])
@@ -5129,7 +5152,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMLessEqual(v *Value) bool {
+func rewriteValueARM_OpARMLessEqual_0(v *Value) bool {
 	// match: (LessEqual (FlagEQ))
 	// cond:
 	// result: (MOVWconst [1])
@@ -5205,7 +5228,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMLessEqualU(v *Value) bool {
+func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool {
 	// match: (LessEqualU (FlagEQ))
 	// cond:
 	// result: (MOVWconst [1])
@@ -5281,7 +5304,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMLessThan(v *Value) bool {
+func rewriteValueARM_OpARMLessThan_0(v *Value) bool {
 	// match: (LessThan (FlagEQ))
 	// cond:
 	// result: (MOVWconst [0])
@@ -5357,7 +5380,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMLessThanU(v *Value) bool {
+func rewriteValueARM_OpARMLessThanU_0(v *Value) bool {
 	// match: (LessThanU (FlagEQ))
 	// cond:
 	// result: (MOVWconst [0])
@@ -5433,7 +5456,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVBUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool {
 	// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -5503,7 +5526,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVBUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool {
 	// match: (MOVBUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVWreg x)
@@ -5558,7 +5581,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVBload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBload_0(v *Value) bool {
 	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -5628,7 +5651,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVBreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool {
 	// match: (MOVBreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVWreg x)
@@ -5686,7 +5709,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVBstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond:
 	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -5821,7 +5844,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVDload(v *Value) bool {
+func rewriteValueARM_OpARMMOVDload_0(v *Value) bool {
 	// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVDload [off1+off2] {sym} ptr mem)
@@ -5891,7 +5914,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVDstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond:
 	// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -5942,7 +5965,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVFload(v *Value) bool {
+func rewriteValueARM_OpARMMOVFload_0(v *Value) bool {
 	// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVFload [off1+off2] {sym} ptr mem)
@@ -6012,7 +6035,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVFstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool {
 	// match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond:
 	// result: (MOVFstore [off1+off2] {sym} ptr val mem)
@@ -6063,7 +6086,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVHUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool {
 	// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -6133,7 +6156,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVHUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool {
 	// match: (MOVHUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVWreg x)
@@ -6212,7 +6235,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVHload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond:
 	// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -6282,7 +6305,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVHreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool {
 	// match: (MOVHreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVWreg x)
@@ -6388,7 +6411,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVHstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond:
 	// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -6481,7 +6504,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWload(v *Value) bool {
+func rewriteValueARM_OpARMMOVWload_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6657,7 +6680,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool {
 	// match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _))
 	// cond: isSamePtr(ptr, ptr2)
 	// result: x
@@ -6831,7 +6854,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool {
 	// match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _))
 	// cond: c==d && isSamePtr(ptr, ptr2)
 	// result: x
@@ -6877,7 +6900,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool {
 	// match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _))
 	// cond: c==d && isSamePtr(ptr, ptr2)
 	// result: x
@@ -6923,7 +6946,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool {
 	// match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _))
 	// cond: c==d && isSamePtr(ptr, ptr2)
 	// result: x
@@ -6969,7 +6992,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool {
 	// match: (MOVWreg x)
 	// cond: x.Uses == 1
 	// result: (MOVWnop x)
@@ -6997,7 +7020,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -7162,7 +7185,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool {
 	// match: (MOVWstoreidx ptr (MOVWconst [c]) val mem)
 	// cond:
 	// result: (MOVWstore [c] ptr val mem)
@@ -7329,7 +7352,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool {
 	// match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem)
 	// cond:
 	// result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem)
@@ -7352,7 +7375,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool {
 	// match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem)
 	// cond:
 	// result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem)
@@ -7375,7 +7398,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool {
 	// match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem)
 	// cond:
 	// result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem)
@@ -7398,9 +7421,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMUL(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueARM_OpARMMUL_0(v *Value) bool {
 	// match: (MUL x (MOVWconst [c]))
 	// cond: int32(c) == -1
 	// result: (RSBconst [0] x)
@@ -7575,6 +7596,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMMUL_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MUL x (MOVWconst [c]))
 	// cond: isPowerOfTwo(c+1) && int32(c) >= 7
 	// result: (RSBshiftLL x x [log2(c+1)])
@@ -7789,6 +7815,9 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMMUL_20(v *Value) bool {
 	// match: (MUL (MOVWconst [c]) (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(int32(c*d))])
@@ -7827,7 +7856,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMULA(v *Value) bool {
+func rewriteValueARM_OpARMMULA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MULA x (MOVWconst [c]) a)
@@ -8056,6 +8085,11 @@
 		v.AddArg(a)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMMULA_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULA (MOVWconst [c]) x a)
 	// cond: int32(c) == -1
 	// result: (SUB a x)
@@ -8282,6 +8316,9 @@
 		v.AddArg(a)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMMULA_20(v *Value) bool {
 	// match: (MULA (MOVWconst [c]) (MOVWconst [d]) a)
 	// cond:
 	// result: (ADDconst [int64(int32(c*d))] a)
@@ -8304,7 +8341,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVN(v *Value) bool {
+func rewriteValueARM_OpARMMVN_0(v *Value) bool {
 	// match: (MVN (MOVWconst [c]))
 	// cond:
 	// result: (MOVWconst [^c])
@@ -8410,7 +8447,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool {
 	// match: (MVNshiftLL (MOVWconst [c]) [d])
 	// cond:
 	// result: (MOVWconst [^int64(uint32(c)<<uint64(d))])
@@ -8427,7 +8464,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool {
 	// match: (MVNshiftLLreg x (MOVWconst [c]))
 	// cond:
 	// result: (MVNshiftLL x [c])
@@ -8445,7 +8482,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool {
 	// match: (MVNshiftRA (MOVWconst [c]) [d])
 	// cond:
 	// result: (MOVWconst [^int64(int32(c)>>uint64(d))])
@@ -8462,7 +8499,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool {
 	// match: (MVNshiftRAreg x (MOVWconst [c]))
 	// cond:
 	// result: (MVNshiftRA x [c])
@@ -8480,7 +8517,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool {
 	// match: (MVNshiftRL (MOVWconst [c]) [d])
 	// cond:
 	// result: (MOVWconst [^int64(uint32(c)>>uint64(d))])
@@ -8497,7 +8534,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool {
 	// match: (MVNshiftRLreg x (MOVWconst [c]))
 	// cond:
 	// result: (MVNshiftRL x [c])
@@ -8515,7 +8552,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMNotEqual(v *Value) bool {
+func rewriteValueARM_OpARMNotEqual_0(v *Value) bool {
 	// match: (NotEqual (FlagEQ))
 	// cond:
 	// result: (MOVWconst [0])
@@ -8591,7 +8628,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMOR(v *Value) bool {
+func rewriteValueARM_OpARMOR_0(v *Value) bool {
 	// match: (OR x (MOVWconst [c]))
 	// cond:
 	// result: (ORconst [c] x)
@@ -8758,6 +8795,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMOR_10(v *Value) bool {
 	// match: (OR x (SRL y z))
 	// cond:
 	// result: (ORshiftRLreg x y z)
@@ -8841,7 +8881,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORconst(v *Value) bool {
+func rewriteValueARM_OpARMORconst_0(v *Value) bool {
 	// match: (ORconst [0] x)
 	// cond:
 	// result: x
@@ -8899,7 +8939,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftLL (MOVWconst [c]) x [d])
@@ -8982,7 +9022,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftLLreg (MOVWconst [c]) x y)
@@ -9023,7 +9063,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRA (MOVWconst [c]) x [d])
@@ -9085,7 +9125,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRAreg (MOVWconst [c]) x y)
@@ -9126,7 +9166,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRL (MOVWconst [c]) x [d])
@@ -9209,7 +9249,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRLreg (MOVWconst [c]) x y)
@@ -9250,7 +9290,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSB(v *Value) bool {
+func rewriteValueARM_OpARMRSB_0(v *Value) bool {
 	// match: (RSB (MOVWconst [c]) x)
 	// cond:
 	// result: (SUBconst [c] x)
@@ -9417,6 +9457,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMRSB_10(v *Value) bool {
 	// match: (RSB x (SRL y z))
 	// cond:
 	// result: (RSBshiftRLreg x y z)
@@ -9499,7 +9542,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftLL (MOVWconst [c]) x [d])
@@ -9539,7 +9582,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftLLreg (MOVWconst [c]) x y)
@@ -9580,7 +9623,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftRA (MOVWconst [c]) x [d])
@@ -9620,7 +9663,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftRAreg (MOVWconst [c]) x y)
@@ -9661,7 +9704,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftRL (MOVWconst [c]) x [d])
@@ -9701,7 +9744,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBSshiftRLreg (MOVWconst [c]) x y)
@@ -9742,7 +9785,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBconst(v *Value) bool {
+func rewriteValueARM_OpARMRSBconst_0(v *Value) bool {
 	// match: (RSBconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(int32(c-d))])
@@ -9807,7 +9850,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftLL (MOVWconst [c]) x [d])
@@ -9868,7 +9911,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftLLreg (MOVWconst [c]) x y)
@@ -9909,7 +9952,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftRA (MOVWconst [c]) x [d])
@@ -9970,7 +10013,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftRAreg (MOVWconst [c]) x y)
@@ -10011,7 +10054,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftRL (MOVWconst [c]) x [d])
@@ -10072,7 +10115,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSBshiftRLreg (MOVWconst [c]) x y)
@@ -10113,7 +10156,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCconst(v *Value) bool {
+func rewriteValueARM_OpARMRSCconst_0(v *Value) bool {
 	// match: (RSCconst [c] (ADDconst [d] x) flags)
 	// cond:
 	// result: (RSCconst [int64(int32(c-d))] x flags)
@@ -10152,7 +10195,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftLL (MOVWconst [c]) x [d] flags)
@@ -10196,7 +10239,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftLLreg (MOVWconst [c]) x y flags)
@@ -10241,7 +10284,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftRA (MOVWconst [c]) x [d] flags)
@@ -10285,7 +10328,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftRAreg (MOVWconst [c]) x y flags)
@@ -10330,7 +10373,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftRL (MOVWconst [c]) x [d] flags)
@@ -10374,7 +10417,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (RSCshiftRLreg (MOVWconst [c]) x y flags)
@@ -10419,7 +10462,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBC(v *Value) bool {
+func rewriteValueARM_OpARMSBC_0(v *Value) bool {
 	// match: (SBC (MOVWconst [c]) x flags)
 	// cond:
 	// result: (RSCconst [c] x flags)
@@ -10606,6 +10649,9 @@
 		v.AddArg(flags)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMSBC_10(v *Value) bool {
 	// match: (SBC x (SRL y z) flags)
 	// cond:
 	// result: (SBCshiftRLreg x y z flags)
@@ -10684,7 +10730,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCconst(v *Value) bool {
+func rewriteValueARM_OpARMSBCconst_0(v *Value) bool {
 	// match: (SBCconst [c] (ADDconst [d] x) flags)
 	// cond:
 	// result: (SBCconst [int64(int32(c-d))] x flags)
@@ -10723,7 +10769,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftLL (MOVWconst [c]) x [d] flags)
@@ -10767,7 +10813,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftLLreg (MOVWconst [c]) x y flags)
@@ -10812,7 +10858,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftRA (MOVWconst [c]) x [d] flags)
@@ -10856,7 +10902,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftRAreg (MOVWconst [c]) x y flags)
@@ -10901,7 +10947,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftRL (MOVWconst [c]) x [d] flags)
@@ -10945,7 +10991,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SBCshiftRLreg (MOVWconst [c]) x y flags)
@@ -10990,7 +11036,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSLL(v *Value) bool {
+func rewriteValueARM_OpARMSLL_0(v *Value) bool {
 	// match: (SLL x (MOVWconst [c]))
 	// cond:
 	// result: (SLLconst x [c&31])
@@ -11008,7 +11054,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSLLconst(v *Value) bool {
+func rewriteValueARM_OpARMSLLconst_0(v *Value) bool {
 	// match: (SLLconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(uint32(d)<<uint64(c))])
@@ -11025,7 +11071,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSRA(v *Value) bool {
+func rewriteValueARM_OpARMSRA_0(v *Value) bool {
 	// match: (SRA x (MOVWconst [c]))
 	// cond:
 	// result: (SRAconst x [c&31])
@@ -11043,7 +11089,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSRAcond(v *Value) bool {
+func rewriteValueARM_OpARMSRAcond_0(v *Value) bool {
 	// match: (SRAcond x _ (FlagEQ))
 	// cond:
 	// result: (SRAconst x [31])
@@ -11118,7 +11164,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSRAconst(v *Value) bool {
+func rewriteValueARM_OpARMSRAconst_0(v *Value) bool {
 	// match: (SRAconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(int32(d)>>uint64(c))])
@@ -11135,7 +11181,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSRL(v *Value) bool {
+func rewriteValueARM_OpARMSRL_0(v *Value) bool {
 	// match: (SRL x (MOVWconst [c]))
 	// cond:
 	// result: (SRLconst x [c&31])
@@ -11153,7 +11199,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSRLconst(v *Value) bool {
+func rewriteValueARM_OpARMSRLconst_0(v *Value) bool {
 	// match: (SRLconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(uint32(d)>>uint64(c))])
@@ -11170,7 +11216,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUB(v *Value) bool {
+func rewriteValueARM_OpARMSUB_0(v *Value) bool {
 	// match: (SUB (MOVWconst [c]) x)
 	// cond:
 	// result: (RSBconst [c] x)
@@ -11337,6 +11383,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMSUB_10(v *Value) bool {
 	// match: (SUB x (SRL y z))
 	// cond:
 	// result: (SUBshiftRLreg x y z)
@@ -11419,7 +11468,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBS(v *Value) bool {
+func rewriteValueARM_OpARMSUBS_0(v *Value) bool {
 	// match: (SUBS x (MOVWconst [c]))
 	// cond:
 	// result: (SUBSconst [c] x)
@@ -11588,6 +11637,9 @@
 		v.AddArg(z)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMSUBS_10(v *Value) bool {
 	// match: (SUBS (SRL y z) x)
 	// cond:
 	// result: (RSBSshiftRLreg x y z)
@@ -11641,7 +11693,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftLL (MOVWconst [c]) x [d])
@@ -11681,7 +11733,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftLLreg (MOVWconst [c]) x y)
@@ -11722,7 +11774,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftRA (MOVWconst [c]) x [d])
@@ -11762,7 +11814,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftRAreg (MOVWconst [c]) x y)
@@ -11803,7 +11855,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftRL (MOVWconst [c]) x [d])
@@ -11843,7 +11895,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBSshiftRLreg (MOVWconst [c]) x y)
@@ -11884,7 +11936,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBconst(v *Value) bool {
+func rewriteValueARM_OpARMSUBconst_0(v *Value) bool {
 	// match: (SUBconst [0] x)
 	// cond:
 	// result: x
@@ -11962,7 +12014,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftLL (MOVWconst [c]) x [d])
@@ -12023,7 +12075,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftLLreg (MOVWconst [c]) x y)
@@ -12064,7 +12116,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftRA (MOVWconst [c]) x [d])
@@ -12125,7 +12177,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftRAreg (MOVWconst [c]) x y)
@@ -12166,7 +12218,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftRL (MOVWconst [c]) x [d])
@@ -12227,7 +12279,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBshiftRLreg (MOVWconst [c]) x y)
@@ -12268,7 +12320,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXOR(v *Value) bool {
+func rewriteValueARM_OpARMXOR_0(v *Value) bool {
 	// match: (XOR x (MOVWconst [c]))
 	// cond:
 	// result: (XORconst [c] x)
@@ -12435,6 +12487,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueARM_OpARMXOR_10(v *Value) bool {
 	// match: (XOR x (SLL y z))
 	// cond:
 	// result: (XORshiftLLreg x y z)
@@ -12551,7 +12606,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORconst(v *Value) bool {
+func rewriteValueARM_OpARMXORconst_0(v *Value) bool {
 	// match: (XORconst [0] x)
 	// cond:
 	// result: x
@@ -12597,7 +12652,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftLL (MOVWconst [c]) x [d])
@@ -12679,7 +12734,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftLLreg (MOVWconst [c]) x y)
@@ -12720,7 +12775,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRA (MOVWconst [c]) x [d])
@@ -12781,7 +12836,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRAreg (MOVWconst [c]) x y)
@@ -12822,7 +12877,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRL (MOVWconst [c]) x [d])
@@ -12904,7 +12959,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRLreg (MOVWconst [c]) x y)
@@ -12945,7 +13000,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpARMXORshiftRR(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRR (MOVWconst [c]) x [d])
@@ -12985,7 +13040,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpAdd16(v *Value) bool {
+func rewriteValueARM_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADD x y)
@@ -12998,7 +13053,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd32(v *Value) bool {
+func rewriteValueARM_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADD x y)
@@ -13011,7 +13066,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd32F(v *Value) bool {
+func rewriteValueARM_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (ADDF x y)
@@ -13024,7 +13079,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd32carry(v *Value) bool {
+func rewriteValueARM_OpAdd32carry_0(v *Value) bool {
 	// match: (Add32carry x y)
 	// cond:
 	// result: (ADDS x y)
@@ -13037,7 +13092,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd32withcarry(v *Value) bool {
+func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool {
 	// match: (Add32withcarry x y c)
 	// cond:
 	// result: (ADC x y c)
@@ -13052,7 +13107,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd64F(v *Value) bool {
+func rewriteValueARM_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (ADDD x y)
@@ -13065,7 +13120,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAdd8(v *Value) bool {
+func rewriteValueARM_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADD x y)
@@ -13078,7 +13133,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAddPtr(v *Value) bool {
+func rewriteValueARM_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADD x y)
@@ -13091,7 +13146,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAddr(v *Value) bool {
+func rewriteValueARM_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVWaddr {sym} base)
@@ -13104,7 +13159,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAnd16(v *Value) bool {
+func rewriteValueARM_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (AND x y)
@@ -13117,7 +13172,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAnd32(v *Value) bool {
+func rewriteValueARM_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (AND x y)
@@ -13130,7 +13185,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAnd8(v *Value) bool {
+func rewriteValueARM_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (AND x y)
@@ -13143,7 +13198,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAndB(v *Value) bool {
+func rewriteValueARM_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (AND x y)
@@ -13156,7 +13211,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpAvg32u(v *Value) bool {
+func rewriteValueARM_OpAvg32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg32u <t> x y)
@@ -13178,7 +13233,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpBitLen32(v *Value) bool {
+func rewriteValueARM_OpBitLen32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (BitLen32 <t> x)
@@ -13195,7 +13250,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpBswap32(v *Value) bool {
+func rewriteValueARM_OpBswap32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Bswap32 <t> x)
@@ -13242,7 +13297,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpClosureCall(v *Value) bool {
+func rewriteValueARM_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -13259,7 +13314,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCom16(v *Value) bool {
+func rewriteValueARM_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (MVN x)
@@ -13270,7 +13325,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCom32(v *Value) bool {
+func rewriteValueARM_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (MVN x)
@@ -13281,7 +13336,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCom8(v *Value) bool {
+func rewriteValueARM_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (MVN x)
@@ -13292,7 +13347,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConst16(v *Value) bool {
+func rewriteValueARM_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -13303,7 +13358,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConst32(v *Value) bool {
+func rewriteValueARM_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -13314,7 +13369,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConst32F(v *Value) bool {
+func rewriteValueARM_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (MOVFconst [val])
@@ -13325,7 +13380,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConst64F(v *Value) bool {
+func rewriteValueARM_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -13336,7 +13391,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConst8(v *Value) bool {
+func rewriteValueARM_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -13347,7 +13402,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConstBool(v *Value) bool {
+func rewriteValueARM_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVWconst [b])
@@ -13358,7 +13413,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConstNil(v *Value) bool {
+func rewriteValueARM_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVWconst [0])
@@ -13368,7 +13423,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpConvert(v *Value) bool {
+func rewriteValueARM_OpConvert_0(v *Value) bool {
 	// match: (Convert x mem)
 	// cond:
 	// result: (MOVWconvert x mem)
@@ -13381,7 +13436,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCtz32(v *Value) bool {
+func rewriteValueARM_OpCtz32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Ctz32 <t> x)
@@ -13427,7 +13482,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (MOVFW x)
@@ -13438,7 +13493,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool {
 	// match: (Cvt32Fto32U x)
 	// cond:
 	// result: (MOVFWU x)
@@ -13449,7 +13504,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (MOVFD x)
@@ -13460,7 +13515,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool {
 	// match: (Cvt32Uto32F x)
 	// cond:
 	// result: (MOVWUF x)
@@ -13471,7 +13526,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool {
 	// match: (Cvt32Uto64F x)
 	// cond:
 	// result: (MOVWUD x)
@@ -13482,7 +13537,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (MOVWF x)
@@ -13493,7 +13548,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (MOVWD x)
@@ -13504,7 +13559,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (MOVDW x)
@@ -13515,7 +13570,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (MOVDF x)
@@ -13526,7 +13581,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool {
 	// match: (Cvt64Fto32U x)
 	// cond:
 	// result: (MOVDWU x)
@@ -13537,7 +13592,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv16(v *Value) bool {
+func rewriteValueARM_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13558,7 +13613,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv16u(v *Value) bool {
+func rewriteValueARM_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13579,7 +13634,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv32(v *Value) bool {
+func rewriteValueARM_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13634,7 +13689,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv32F(v *Value) bool {
+func rewriteValueARM_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (DIVF x y)
@@ -13647,7 +13702,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv32u(v *Value) bool {
+func rewriteValueARM_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13667,7 +13722,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv64F(v *Value) bool {
+func rewriteValueARM_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (DIVD x y)
@@ -13680,7 +13735,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv8(v *Value) bool {
+func rewriteValueARM_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13701,7 +13756,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpDiv8u(v *Value) bool {
+func rewriteValueARM_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13722,7 +13777,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEq16(v *Value) bool {
+func rewriteValueARM_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13745,7 +13800,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEq32(v *Value) bool {
+func rewriteValueARM_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x y)
@@ -13762,7 +13817,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEq32F(v *Value) bool {
+func rewriteValueARM_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -13779,7 +13834,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEq64F(v *Value) bool {
+func rewriteValueARM_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -13796,7 +13851,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEq8(v *Value) bool {
+func rewriteValueARM_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13819,7 +13874,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEqB(v *Value) bool {
+func rewriteValueARM_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13839,7 +13894,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpEqPtr(v *Value) bool {
+func rewriteValueARM_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqPtr x y)
@@ -13856,7 +13911,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq16(v *Value) bool {
+func rewriteValueARM_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13879,7 +13934,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq16U(v *Value) bool {
+func rewriteValueARM_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13902,7 +13957,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq32(v *Value) bool {
+func rewriteValueARM_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32 x y)
@@ -13919,7 +13974,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq32F(v *Value) bool {
+func rewriteValueARM_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -13936,7 +13991,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq32U(v *Value) bool {
+func rewriteValueARM_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32U x y)
@@ -13953,7 +14008,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq64F(v *Value) bool {
+func rewriteValueARM_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -13970,7 +14025,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq8(v *Value) bool {
+func rewriteValueARM_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13993,7 +14048,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGeq8U(v *Value) bool {
+func rewriteValueARM_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14016,7 +14071,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -14025,7 +14080,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater16(v *Value) bool {
+func rewriteValueARM_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14048,7 +14103,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater16U(v *Value) bool {
+func rewriteValueARM_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14071,7 +14126,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater32(v *Value) bool {
+func rewriteValueARM_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32 x y)
@@ -14088,7 +14143,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater32F(v *Value) bool {
+func rewriteValueARM_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -14105,7 +14160,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater32U(v *Value) bool {
+func rewriteValueARM_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32U x y)
@@ -14122,7 +14177,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater64F(v *Value) bool {
+func rewriteValueARM_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -14139,7 +14194,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater8(v *Value) bool {
+func rewriteValueARM_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14162,7 +14217,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpGreater8U(v *Value) bool {
+func rewriteValueARM_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14185,7 +14240,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpHmul32(v *Value) bool {
+func rewriteValueARM_OpHmul32_0(v *Value) bool {
 	// match: (Hmul32 x y)
 	// cond:
 	// result: (HMUL x y)
@@ -14198,7 +14253,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpHmul32u(v *Value) bool {
+func rewriteValueARM_OpHmul32u_0(v *Value) bool {
 	// match: (Hmul32u x y)
 	// cond:
 	// result: (HMULU x y)
@@ -14211,7 +14266,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpInterCall(v *Value) bool {
+func rewriteValueARM_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -14226,7 +14281,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpIsInBounds(v *Value) bool {
+func rewriteValueARM_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsInBounds idx len)
@@ -14243,7 +14298,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpIsNonNil(v *Value) bool {
+func rewriteValueARM_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsNonNil ptr)
@@ -14259,7 +14314,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsSliceInBounds idx len)
@@ -14276,7 +14331,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq16(v *Value) bool {
+func rewriteValueARM_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14299,7 +14354,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq16U(v *Value) bool {
+func rewriteValueARM_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14322,7 +14377,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq32(v *Value) bool {
+func rewriteValueARM_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32 x y)
@@ -14339,7 +14394,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq32F(v *Value) bool {
+func rewriteValueARM_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -14356,7 +14411,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq32U(v *Value) bool {
+func rewriteValueARM_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32U x y)
@@ -14373,7 +14428,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq64F(v *Value) bool {
+func rewriteValueARM_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -14390,7 +14445,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq8(v *Value) bool {
+func rewriteValueARM_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14413,7 +14468,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLeq8U(v *Value) bool {
+func rewriteValueARM_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14436,7 +14491,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess16(v *Value) bool {
+func rewriteValueARM_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14459,7 +14514,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess16U(v *Value) bool {
+func rewriteValueARM_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14482,7 +14537,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess32(v *Value) bool {
+func rewriteValueARM_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32 x y)
@@ -14499,7 +14554,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess32F(v *Value) bool {
+func rewriteValueARM_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -14516,7 +14571,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess32U(v *Value) bool {
+func rewriteValueARM_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32U x y)
@@ -14533,7 +14588,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess64F(v *Value) bool {
+func rewriteValueARM_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -14550,7 +14605,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess8(v *Value) bool {
+func rewriteValueARM_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14573,7 +14628,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLess8U(v *Value) bool {
+func rewriteValueARM_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14596,7 +14651,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLoad(v *Value) bool {
+func rewriteValueARM_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: t.IsBoolean()
 	// result: (MOVBUload ptr mem)
@@ -14719,7 +14774,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpLsh16x16(v *Value) bool {
+func rewriteValueARM_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14747,7 +14802,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh16x32(v *Value) bool {
+func rewriteValueARM_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x32 x y)
@@ -14769,7 +14824,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh16x64(v *Value) bool {
+func rewriteValueARM_OpLsh16x64_0(v *Value) bool {
 	// match: (Lsh16x64 x (Const64 [c]))
 	// cond: uint64(c) < 16
 	// result: (SLLconst x [c])
@@ -14806,7 +14861,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpLsh16x8(v *Value) bool {
+func rewriteValueARM_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14825,7 +14880,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh32x16(v *Value) bool {
+func rewriteValueARM_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14853,7 +14908,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh32x32(v *Value) bool {
+func rewriteValueARM_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x32 x y)
@@ -14875,7 +14930,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh32x64(v *Value) bool {
+func rewriteValueARM_OpLsh32x64_0(v *Value) bool {
 	// match: (Lsh32x64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SLLconst x [c])
@@ -14912,7 +14967,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpLsh32x8(v *Value) bool {
+func rewriteValueARM_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14931,7 +14986,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh8x16(v *Value) bool {
+func rewriteValueARM_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14959,7 +15014,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh8x32(v *Value) bool {
+func rewriteValueARM_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x32 x y)
@@ -14981,7 +15036,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpLsh8x64(v *Value) bool {
+func rewriteValueARM_OpLsh8x64_0(v *Value) bool {
 	// match: (Lsh8x64 x (Const64 [c]))
 	// cond: uint64(c) < 8
 	// result: (SLLconst x [c])
@@ -15018,7 +15073,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpLsh8x8(v *Value) bool {
+func rewriteValueARM_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15037,7 +15092,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod16(v *Value) bool {
+func rewriteValueARM_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15058,7 +15113,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod16u(v *Value) bool {
+func rewriteValueARM_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15079,7 +15134,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod32(v *Value) bool {
+func rewriteValueARM_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15128,7 +15183,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod32u(v *Value) bool {
+func rewriteValueARM_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15148,7 +15203,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod8(v *Value) bool {
+func rewriteValueARM_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15169,7 +15224,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMod8u(v *Value) bool {
+func rewriteValueARM_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15190,7 +15245,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMove(v *Value) bool {
+func rewriteValueARM_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -15462,7 +15517,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpMul16(v *Value) bool {
+func rewriteValueARM_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MUL x y)
@@ -15475,7 +15530,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMul32(v *Value) bool {
+func rewriteValueARM_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MUL x y)
@@ -15488,7 +15543,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMul32F(v *Value) bool {
+func rewriteValueARM_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (MULF x y)
@@ -15501,7 +15556,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMul32uhilo(v *Value) bool {
+func rewriteValueARM_OpMul32uhilo_0(v *Value) bool {
 	// match: (Mul32uhilo x y)
 	// cond:
 	// result: (MULLU x y)
@@ -15514,7 +15569,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMul64F(v *Value) bool {
+func rewriteValueARM_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (MULD x y)
@@ -15527,7 +15582,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpMul8(v *Value) bool {
+func rewriteValueARM_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MUL x y)
@@ -15540,7 +15595,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeg16(v *Value) bool {
+func rewriteValueARM_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (RSBconst [0] x)
@@ -15552,7 +15607,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeg32(v *Value) bool {
+func rewriteValueARM_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (RSBconst [0] x)
@@ -15564,7 +15619,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeg32F(v *Value) bool {
+func rewriteValueARM_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (NEGF x)
@@ -15575,7 +15630,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeg64F(v *Value) bool {
+func rewriteValueARM_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (NEGD x)
@@ -15586,7 +15641,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeg8(v *Value) bool {
+func rewriteValueARM_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (RSBconst [0] x)
@@ -15598,7 +15653,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeq16(v *Value) bool {
+func rewriteValueARM_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15621,7 +15676,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeq32(v *Value) bool {
+func rewriteValueARM_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x y)
@@ -15638,7 +15693,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeq32F(v *Value) bool {
+func rewriteValueARM_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -15655,7 +15710,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeq64F(v *Value) bool {
+func rewriteValueARM_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -15672,7 +15727,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeq8(v *Value) bool {
+func rewriteValueARM_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15695,7 +15750,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeqB(v *Value) bool {
+func rewriteValueARM_OpNeqB_0(v *Value) bool {
 	// match: (NeqB x y)
 	// cond:
 	// result: (XOR x y)
@@ -15708,7 +15763,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNeqPtr(v *Value) bool {
+func rewriteValueARM_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqPtr x y)
@@ -15725,7 +15780,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNilCheck(v *Value) bool {
+func rewriteValueARM_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -15738,7 +15793,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpNot(v *Value) bool {
+func rewriteValueARM_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORconst [1] x)
@@ -15750,7 +15805,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpOffPtr(v *Value) bool {
+func rewriteValueARM_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr [off] ptr:(SP))
 	// cond:
 	// result: (MOVWaddr [off] ptr)
@@ -15777,7 +15832,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpOr16(v *Value) bool {
+func rewriteValueARM_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (OR x y)
@@ -15790,7 +15845,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpOr32(v *Value) bool {
+func rewriteValueARM_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (OR x y)
@@ -15803,7 +15858,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpOr8(v *Value) bool {
+func rewriteValueARM_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (OR x y)
@@ -15816,7 +15871,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpOrB(v *Value) bool {
+func rewriteValueARM_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (OR x y)
@@ -15829,7 +15884,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRound32F(v *Value) bool {
+func rewriteValueARM_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -15841,7 +15896,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRound64F(v *Value) bool {
+func rewriteValueARM_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -15853,7 +15908,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15883,7 +15938,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15909,7 +15964,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15953,7 +16008,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -15974,7 +16029,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16x16(v *Value) bool {
+func rewriteValueARM_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16001,7 +16056,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16x32(v *Value) bool {
+func rewriteValueARM_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16024,7 +16079,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh16x64(v *Value) bool {
+func rewriteValueARM_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16073,7 +16128,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh16x8(v *Value) bool {
+func rewriteValueARM_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16094,7 +16149,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16122,7 +16177,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux32 x y)
@@ -16144,7 +16199,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool {
 	// match: (Rsh32Ux64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SRLconst x [c])
@@ -16181,7 +16236,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16200,7 +16255,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32x16(v *Value) bool {
+func rewriteValueARM_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16225,7 +16280,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32x32(v *Value) bool {
+func rewriteValueARM_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x32 x y)
@@ -16244,7 +16299,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh32x64(v *Value) bool {
+func rewriteValueARM_OpRsh32x64_0(v *Value) bool {
 	// match: (Rsh32x64 x (Const64 [c]))
 	// cond: uint64(c) < 32
 	// result: (SRAconst x [c])
@@ -16283,7 +16338,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh32x8(v *Value) bool {
+func rewriteValueARM_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16302,7 +16357,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16332,7 +16387,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16358,7 +16413,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16402,7 +16457,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16423,7 +16478,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8x16(v *Value) bool {
+func rewriteValueARM_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16450,7 +16505,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8x32(v *Value) bool {
+func rewriteValueARM_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16473,7 +16528,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpRsh8x64(v *Value) bool {
+func rewriteValueARM_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16522,7 +16577,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpRsh8x8(v *Value) bool {
+func rewriteValueARM_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -16543,7 +16598,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSelect0(v *Value) bool {
+func rewriteValueARM_OpSelect0_0(v *Value) bool {
 	// match: (Select0 (CALLudiv x (MOVWconst [1])))
 	// cond:
 	// result: x
@@ -16611,7 +16666,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpSelect1(v *Value) bool {
+func rewriteValueARM_OpSelect1_0(v *Value) bool {
 	// match: (Select1 (CALLudiv _ (MOVWconst [1])))
 	// cond:
 	// result: (MOVWconst [0])
@@ -16677,7 +16732,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -16688,7 +16743,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -16699,7 +16754,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -16710,7 +16765,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSignmask(v *Value) bool {
+func rewriteValueARM_OpSignmask_0(v *Value) bool {
 	// match: (Signmask x)
 	// cond:
 	// result: (SRAconst x [31])
@@ -16722,7 +16777,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSlicemask(v *Value) bool {
+func rewriteValueARM_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -16740,7 +16795,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSqrt(v *Value) bool {
+func rewriteValueARM_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (SQRTD x)
@@ -16751,7 +16806,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpStaticCall(v *Value) bool {
+func rewriteValueARM_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -16766,7 +16821,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpStore(v *Value) bool {
+func rewriteValueARM_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 1
 	// result: (MOVBstore ptr val mem)
@@ -16854,7 +16909,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpSub16(v *Value) bool {
+func rewriteValueARM_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUB x y)
@@ -16867,7 +16922,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub32(v *Value) bool {
+func rewriteValueARM_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUB x y)
@@ -16880,7 +16935,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub32F(v *Value) bool {
+func rewriteValueARM_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (SUBF x y)
@@ -16893,7 +16948,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub32carry(v *Value) bool {
+func rewriteValueARM_OpSub32carry_0(v *Value) bool {
 	// match: (Sub32carry x y)
 	// cond:
 	// result: (SUBS x y)
@@ -16906,7 +16961,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub32withcarry(v *Value) bool {
+func rewriteValueARM_OpSub32withcarry_0(v *Value) bool {
 	// match: (Sub32withcarry x y c)
 	// cond:
 	// result: (SBC x y c)
@@ -16921,7 +16976,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub64F(v *Value) bool {
+func rewriteValueARM_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (SUBD x y)
@@ -16934,7 +16989,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSub8(v *Value) bool {
+func rewriteValueARM_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUB x y)
@@ -16947,7 +17002,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpSubPtr(v *Value) bool {
+func rewriteValueARM_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUB x y)
@@ -16960,7 +17015,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -16972,7 +17027,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -16984,7 +17039,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -16996,7 +17051,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpXor16(v *Value) bool {
+func rewriteValueARM_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XOR x y)
@@ -17009,7 +17064,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpXor32(v *Value) bool {
+func rewriteValueARM_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XOR x y)
@@ -17022,7 +17077,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpXor8(v *Value) bool {
+func rewriteValueARM_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XOR x y)
@@ -17035,7 +17090,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpZero(v *Value) bool {
+func rewriteValueARM_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -17285,7 +17340,7 @@
 	}
 	return false
 }
-func rewriteValueARM_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -17296,7 +17351,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -17307,7 +17362,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -17318,7 +17373,7 @@
 		return true
 	}
 }
-func rewriteValueARM_OpZeromask(v *Value) bool {
+func rewriteValueARM_OpZeromask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 56f5ab5..684961b 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -14,711 +14,711 @@
 func rewriteValueARM64(v *Value) bool {
 	switch v.Op {
 	case OpARM64ADD:
-		return rewriteValueARM64_OpARM64ADD(v)
+		return rewriteValueARM64_OpARM64ADD_0(v)
 	case OpARM64ADDconst:
-		return rewriteValueARM64_OpARM64ADDconst(v)
+		return rewriteValueARM64_OpARM64ADDconst_0(v)
 	case OpARM64ADDshiftLL:
-		return rewriteValueARM64_OpARM64ADDshiftLL(v)
+		return rewriteValueARM64_OpARM64ADDshiftLL_0(v)
 	case OpARM64ADDshiftRA:
-		return rewriteValueARM64_OpARM64ADDshiftRA(v)
+		return rewriteValueARM64_OpARM64ADDshiftRA_0(v)
 	case OpARM64ADDshiftRL:
-		return rewriteValueARM64_OpARM64ADDshiftRL(v)
+		return rewriteValueARM64_OpARM64ADDshiftRL_0(v)
 	case OpARM64AND:
-		return rewriteValueARM64_OpARM64AND(v)
+		return rewriteValueARM64_OpARM64AND_0(v) || rewriteValueARM64_OpARM64AND_10(v)
 	case OpARM64ANDconst:
-		return rewriteValueARM64_OpARM64ANDconst(v)
+		return rewriteValueARM64_OpARM64ANDconst_0(v)
 	case OpARM64ANDshiftLL:
-		return rewriteValueARM64_OpARM64ANDshiftLL(v)
+		return rewriteValueARM64_OpARM64ANDshiftLL_0(v)
 	case OpARM64ANDshiftRA:
-		return rewriteValueARM64_OpARM64ANDshiftRA(v)
+		return rewriteValueARM64_OpARM64ANDshiftRA_0(v)
 	case OpARM64ANDshiftRL:
-		return rewriteValueARM64_OpARM64ANDshiftRL(v)
+		return rewriteValueARM64_OpARM64ANDshiftRL_0(v)
 	case OpARM64BIC:
-		return rewriteValueARM64_OpARM64BIC(v)
+		return rewriteValueARM64_OpARM64BIC_0(v)
 	case OpARM64BICconst:
-		return rewriteValueARM64_OpARM64BICconst(v)
+		return rewriteValueARM64_OpARM64BICconst_0(v)
 	case OpARM64BICshiftLL:
-		return rewriteValueARM64_OpARM64BICshiftLL(v)
+		return rewriteValueARM64_OpARM64BICshiftLL_0(v)
 	case OpARM64BICshiftRA:
-		return rewriteValueARM64_OpARM64BICshiftRA(v)
+		return rewriteValueARM64_OpARM64BICshiftRA_0(v)
 	case OpARM64BICshiftRL:
-		return rewriteValueARM64_OpARM64BICshiftRL(v)
+		return rewriteValueARM64_OpARM64BICshiftRL_0(v)
 	case OpARM64CMP:
-		return rewriteValueARM64_OpARM64CMP(v)
+		return rewriteValueARM64_OpARM64CMP_0(v)
 	case OpARM64CMPW:
-		return rewriteValueARM64_OpARM64CMPW(v)
+		return rewriteValueARM64_OpARM64CMPW_0(v)
 	case OpARM64CMPWconst:
-		return rewriteValueARM64_OpARM64CMPWconst(v)
+		return rewriteValueARM64_OpARM64CMPWconst_0(v)
 	case OpARM64CMPconst:
-		return rewriteValueARM64_OpARM64CMPconst(v)
+		return rewriteValueARM64_OpARM64CMPconst_0(v)
 	case OpARM64CMPshiftLL:
-		return rewriteValueARM64_OpARM64CMPshiftLL(v)
+		return rewriteValueARM64_OpARM64CMPshiftLL_0(v)
 	case OpARM64CMPshiftRA:
-		return rewriteValueARM64_OpARM64CMPshiftRA(v)
+		return rewriteValueARM64_OpARM64CMPshiftRA_0(v)
 	case OpARM64CMPshiftRL:
-		return rewriteValueARM64_OpARM64CMPshiftRL(v)
+		return rewriteValueARM64_OpARM64CMPshiftRL_0(v)
 	case OpARM64CSELULT:
-		return rewriteValueARM64_OpARM64CSELULT(v)
+		return rewriteValueARM64_OpARM64CSELULT_0(v)
 	case OpARM64CSELULT0:
-		return rewriteValueARM64_OpARM64CSELULT0(v)
+		return rewriteValueARM64_OpARM64CSELULT0_0(v)
 	case OpARM64DIV:
-		return rewriteValueARM64_OpARM64DIV(v)
+		return rewriteValueARM64_OpARM64DIV_0(v)
 	case OpARM64DIVW:
-		return rewriteValueARM64_OpARM64DIVW(v)
+		return rewriteValueARM64_OpARM64DIVW_0(v)
 	case OpARM64Equal:
-		return rewriteValueARM64_OpARM64Equal(v)
+		return rewriteValueARM64_OpARM64Equal_0(v)
 	case OpARM64FMOVDload:
-		return rewriteValueARM64_OpARM64FMOVDload(v)
+		return rewriteValueARM64_OpARM64FMOVDload_0(v)
 	case OpARM64FMOVDstore:
-		return rewriteValueARM64_OpARM64FMOVDstore(v)
+		return rewriteValueARM64_OpARM64FMOVDstore_0(v)
 	case OpARM64FMOVSload:
-		return rewriteValueARM64_OpARM64FMOVSload(v)
+		return rewriteValueARM64_OpARM64FMOVSload_0(v)
 	case OpARM64FMOVSstore:
-		return rewriteValueARM64_OpARM64FMOVSstore(v)
+		return rewriteValueARM64_OpARM64FMOVSstore_0(v)
 	case OpARM64GreaterEqual:
-		return rewriteValueARM64_OpARM64GreaterEqual(v)
+		return rewriteValueARM64_OpARM64GreaterEqual_0(v)
 	case OpARM64GreaterEqualU:
-		return rewriteValueARM64_OpARM64GreaterEqualU(v)
+		return rewriteValueARM64_OpARM64GreaterEqualU_0(v)
 	case OpARM64GreaterThan:
-		return rewriteValueARM64_OpARM64GreaterThan(v)
+		return rewriteValueARM64_OpARM64GreaterThan_0(v)
 	case OpARM64GreaterThanU:
-		return rewriteValueARM64_OpARM64GreaterThanU(v)
+		return rewriteValueARM64_OpARM64GreaterThanU_0(v)
 	case OpARM64LessEqual:
-		return rewriteValueARM64_OpARM64LessEqual(v)
+		return rewriteValueARM64_OpARM64LessEqual_0(v)
 	case OpARM64LessEqualU:
-		return rewriteValueARM64_OpARM64LessEqualU(v)
+		return rewriteValueARM64_OpARM64LessEqualU_0(v)
 	case OpARM64LessThan:
-		return rewriteValueARM64_OpARM64LessThan(v)
+		return rewriteValueARM64_OpARM64LessThan_0(v)
 	case OpARM64LessThanU:
-		return rewriteValueARM64_OpARM64LessThanU(v)
+		return rewriteValueARM64_OpARM64LessThanU_0(v)
 	case OpARM64MOD:
-		return rewriteValueARM64_OpARM64MOD(v)
+		return rewriteValueARM64_OpARM64MOD_0(v)
 	case OpARM64MODW:
-		return rewriteValueARM64_OpARM64MODW(v)
+		return rewriteValueARM64_OpARM64MODW_0(v)
 	case OpARM64MOVBUload:
-		return rewriteValueARM64_OpARM64MOVBUload(v)
+		return rewriteValueARM64_OpARM64MOVBUload_0(v)
 	case OpARM64MOVBUreg:
-		return rewriteValueARM64_OpARM64MOVBUreg(v)
+		return rewriteValueARM64_OpARM64MOVBUreg_0(v)
 	case OpARM64MOVBload:
-		return rewriteValueARM64_OpARM64MOVBload(v)
+		return rewriteValueARM64_OpARM64MOVBload_0(v)
 	case OpARM64MOVBreg:
-		return rewriteValueARM64_OpARM64MOVBreg(v)
+		return rewriteValueARM64_OpARM64MOVBreg_0(v)
 	case OpARM64MOVBstore:
-		return rewriteValueARM64_OpARM64MOVBstore(v)
+		return rewriteValueARM64_OpARM64MOVBstore_0(v)
 	case OpARM64MOVBstorezero:
-		return rewriteValueARM64_OpARM64MOVBstorezero(v)
+		return rewriteValueARM64_OpARM64MOVBstorezero_0(v)
 	case OpARM64MOVDload:
-		return rewriteValueARM64_OpARM64MOVDload(v)
+		return rewriteValueARM64_OpARM64MOVDload_0(v)
 	case OpARM64MOVDreg:
-		return rewriteValueARM64_OpARM64MOVDreg(v)
+		return rewriteValueARM64_OpARM64MOVDreg_0(v)
 	case OpARM64MOVDstore:
-		return rewriteValueARM64_OpARM64MOVDstore(v)
+		return rewriteValueARM64_OpARM64MOVDstore_0(v)
 	case OpARM64MOVDstorezero:
-		return rewriteValueARM64_OpARM64MOVDstorezero(v)
+		return rewriteValueARM64_OpARM64MOVDstorezero_0(v)
 	case OpARM64MOVHUload:
-		return rewriteValueARM64_OpARM64MOVHUload(v)
+		return rewriteValueARM64_OpARM64MOVHUload_0(v)
 	case OpARM64MOVHUreg:
-		return rewriteValueARM64_OpARM64MOVHUreg(v)
+		return rewriteValueARM64_OpARM64MOVHUreg_0(v)
 	case OpARM64MOVHload:
-		return rewriteValueARM64_OpARM64MOVHload(v)
+		return rewriteValueARM64_OpARM64MOVHload_0(v)
 	case OpARM64MOVHreg:
-		return rewriteValueARM64_OpARM64MOVHreg(v)
+		return rewriteValueARM64_OpARM64MOVHreg_0(v)
 	case OpARM64MOVHstore:
-		return rewriteValueARM64_OpARM64MOVHstore(v)
+		return rewriteValueARM64_OpARM64MOVHstore_0(v)
 	case OpARM64MOVHstorezero:
-		return rewriteValueARM64_OpARM64MOVHstorezero(v)
+		return rewriteValueARM64_OpARM64MOVHstorezero_0(v)
 	case OpARM64MOVWUload:
-		return rewriteValueARM64_OpARM64MOVWUload(v)
+		return rewriteValueARM64_OpARM64MOVWUload_0(v)
 	case OpARM64MOVWUreg:
-		return rewriteValueARM64_OpARM64MOVWUreg(v)
+		return rewriteValueARM64_OpARM64MOVWUreg_0(v)
 	case OpARM64MOVWload:
-		return rewriteValueARM64_OpARM64MOVWload(v)
+		return rewriteValueARM64_OpARM64MOVWload_0(v)
 	case OpARM64MOVWreg:
-		return rewriteValueARM64_OpARM64MOVWreg(v)
+		return rewriteValueARM64_OpARM64MOVWreg_0(v) || rewriteValueARM64_OpARM64MOVWreg_10(v)
 	case OpARM64MOVWstore:
-		return rewriteValueARM64_OpARM64MOVWstore(v)
+		return rewriteValueARM64_OpARM64MOVWstore_0(v)
 	case OpARM64MOVWstorezero:
-		return rewriteValueARM64_OpARM64MOVWstorezero(v)
+		return rewriteValueARM64_OpARM64MOVWstorezero_0(v)
 	case OpARM64MUL:
-		return rewriteValueARM64_OpARM64MUL(v)
+		return rewriteValueARM64_OpARM64MUL_0(v) || rewriteValueARM64_OpARM64MUL_10(v) || rewriteValueARM64_OpARM64MUL_20(v)
 	case OpARM64MULW:
-		return rewriteValueARM64_OpARM64MULW(v)
+		return rewriteValueARM64_OpARM64MULW_0(v) || rewriteValueARM64_OpARM64MULW_10(v) || rewriteValueARM64_OpARM64MULW_20(v)
 	case OpARM64MVN:
-		return rewriteValueARM64_OpARM64MVN(v)
+		return rewriteValueARM64_OpARM64MVN_0(v)
 	case OpARM64NEG:
-		return rewriteValueARM64_OpARM64NEG(v)
+		return rewriteValueARM64_OpARM64NEG_0(v)
 	case OpARM64NotEqual:
-		return rewriteValueARM64_OpARM64NotEqual(v)
+		return rewriteValueARM64_OpARM64NotEqual_0(v)
 	case OpARM64OR:
-		return rewriteValueARM64_OpARM64OR(v)
+		return rewriteValueARM64_OpARM64OR_0(v) || rewriteValueARM64_OpARM64OR_10(v)
 	case OpARM64ORconst:
-		return rewriteValueARM64_OpARM64ORconst(v)
+		return rewriteValueARM64_OpARM64ORconst_0(v)
 	case OpARM64ORshiftLL:
-		return rewriteValueARM64_OpARM64ORshiftLL(v)
+		return rewriteValueARM64_OpARM64ORshiftLL_0(v) || rewriteValueARM64_OpARM64ORshiftLL_10(v)
 	case OpARM64ORshiftRA:
-		return rewriteValueARM64_OpARM64ORshiftRA(v)
+		return rewriteValueARM64_OpARM64ORshiftRA_0(v)
 	case OpARM64ORshiftRL:
-		return rewriteValueARM64_OpARM64ORshiftRL(v)
+		return rewriteValueARM64_OpARM64ORshiftRL_0(v)
 	case OpARM64SLL:
-		return rewriteValueARM64_OpARM64SLL(v)
+		return rewriteValueARM64_OpARM64SLL_0(v)
 	case OpARM64SLLconst:
-		return rewriteValueARM64_OpARM64SLLconst(v)
+		return rewriteValueARM64_OpARM64SLLconst_0(v)
 	case OpARM64SRA:
-		return rewriteValueARM64_OpARM64SRA(v)
+		return rewriteValueARM64_OpARM64SRA_0(v)
 	case OpARM64SRAconst:
-		return rewriteValueARM64_OpARM64SRAconst(v)
+		return rewriteValueARM64_OpARM64SRAconst_0(v)
 	case OpARM64SRL:
-		return rewriteValueARM64_OpARM64SRL(v)
+		return rewriteValueARM64_OpARM64SRL_0(v)
 	case OpARM64SRLconst:
-		return rewriteValueARM64_OpARM64SRLconst(v)
+		return rewriteValueARM64_OpARM64SRLconst_0(v)
 	case OpARM64SUB:
-		return rewriteValueARM64_OpARM64SUB(v)
+		return rewriteValueARM64_OpARM64SUB_0(v)
 	case OpARM64SUBconst:
-		return rewriteValueARM64_OpARM64SUBconst(v)
+		return rewriteValueARM64_OpARM64SUBconst_0(v)
 	case OpARM64SUBshiftLL:
-		return rewriteValueARM64_OpARM64SUBshiftLL(v)
+		return rewriteValueARM64_OpARM64SUBshiftLL_0(v)
 	case OpARM64SUBshiftRA:
-		return rewriteValueARM64_OpARM64SUBshiftRA(v)
+		return rewriteValueARM64_OpARM64SUBshiftRA_0(v)
 	case OpARM64SUBshiftRL:
-		return rewriteValueARM64_OpARM64SUBshiftRL(v)
+		return rewriteValueARM64_OpARM64SUBshiftRL_0(v)
 	case OpARM64UDIV:
-		return rewriteValueARM64_OpARM64UDIV(v)
+		return rewriteValueARM64_OpARM64UDIV_0(v)
 	case OpARM64UDIVW:
-		return rewriteValueARM64_OpARM64UDIVW(v)
+		return rewriteValueARM64_OpARM64UDIVW_0(v)
 	case OpARM64UMOD:
-		return rewriteValueARM64_OpARM64UMOD(v)
+		return rewriteValueARM64_OpARM64UMOD_0(v)
 	case OpARM64UMODW:
-		return rewriteValueARM64_OpARM64UMODW(v)
+		return rewriteValueARM64_OpARM64UMODW_0(v)
 	case OpARM64XOR:
-		return rewriteValueARM64_OpARM64XOR(v)
+		return rewriteValueARM64_OpARM64XOR_0(v)
 	case OpARM64XORconst:
-		return rewriteValueARM64_OpARM64XORconst(v)
+		return rewriteValueARM64_OpARM64XORconst_0(v)
 	case OpARM64XORshiftLL:
-		return rewriteValueARM64_OpARM64XORshiftLL(v)
+		return rewriteValueARM64_OpARM64XORshiftLL_0(v)
 	case OpARM64XORshiftRA:
-		return rewriteValueARM64_OpARM64XORshiftRA(v)
+		return rewriteValueARM64_OpARM64XORshiftRA_0(v)
 	case OpARM64XORshiftRL:
-		return rewriteValueARM64_OpARM64XORshiftRL(v)
+		return rewriteValueARM64_OpARM64XORshiftRL_0(v)
 	case OpAdd16:
-		return rewriteValueARM64_OpAdd16(v)
+		return rewriteValueARM64_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueARM64_OpAdd32(v)
+		return rewriteValueARM64_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueARM64_OpAdd32F(v)
+		return rewriteValueARM64_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValueARM64_OpAdd64(v)
+		return rewriteValueARM64_OpAdd64_0(v)
 	case OpAdd64F:
-		return rewriteValueARM64_OpAdd64F(v)
+		return rewriteValueARM64_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueARM64_OpAdd8(v)
+		return rewriteValueARM64_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueARM64_OpAddPtr(v)
+		return rewriteValueARM64_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueARM64_OpAddr(v)
+		return rewriteValueARM64_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueARM64_OpAnd16(v)
+		return rewriteValueARM64_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueARM64_OpAnd32(v)
+		return rewriteValueARM64_OpAnd32_0(v)
 	case OpAnd64:
-		return rewriteValueARM64_OpAnd64(v)
+		return rewriteValueARM64_OpAnd64_0(v)
 	case OpAnd8:
-		return rewriteValueARM64_OpAnd8(v)
+		return rewriteValueARM64_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueARM64_OpAndB(v)
+		return rewriteValueARM64_OpAndB_0(v)
 	case OpAtomicAdd32:
-		return rewriteValueARM64_OpAtomicAdd32(v)
+		return rewriteValueARM64_OpAtomicAdd32_0(v)
 	case OpAtomicAdd64:
-		return rewriteValueARM64_OpAtomicAdd64(v)
+		return rewriteValueARM64_OpAtomicAdd64_0(v)
 	case OpAtomicAnd8:
-		return rewriteValueARM64_OpAtomicAnd8(v)
+		return rewriteValueARM64_OpAtomicAnd8_0(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValueARM64_OpAtomicCompareAndSwap32(v)
+		return rewriteValueARM64_OpAtomicCompareAndSwap32_0(v)
 	case OpAtomicCompareAndSwap64:
-		return rewriteValueARM64_OpAtomicCompareAndSwap64(v)
+		return rewriteValueARM64_OpAtomicCompareAndSwap64_0(v)
 	case OpAtomicExchange32:
-		return rewriteValueARM64_OpAtomicExchange32(v)
+		return rewriteValueARM64_OpAtomicExchange32_0(v)
 	case OpAtomicExchange64:
-		return rewriteValueARM64_OpAtomicExchange64(v)
+		return rewriteValueARM64_OpAtomicExchange64_0(v)
 	case OpAtomicLoad32:
-		return rewriteValueARM64_OpAtomicLoad32(v)
+		return rewriteValueARM64_OpAtomicLoad32_0(v)
 	case OpAtomicLoad64:
-		return rewriteValueARM64_OpAtomicLoad64(v)
+		return rewriteValueARM64_OpAtomicLoad64_0(v)
 	case OpAtomicLoadPtr:
-		return rewriteValueARM64_OpAtomicLoadPtr(v)
+		return rewriteValueARM64_OpAtomicLoadPtr_0(v)
 	case OpAtomicOr8:
-		return rewriteValueARM64_OpAtomicOr8(v)
+		return rewriteValueARM64_OpAtomicOr8_0(v)
 	case OpAtomicStore32:
-		return rewriteValueARM64_OpAtomicStore32(v)
+		return rewriteValueARM64_OpAtomicStore32_0(v)
 	case OpAtomicStore64:
-		return rewriteValueARM64_OpAtomicStore64(v)
+		return rewriteValueARM64_OpAtomicStore64_0(v)
 	case OpAtomicStorePtrNoWB:
-		return rewriteValueARM64_OpAtomicStorePtrNoWB(v)
+		return rewriteValueARM64_OpAtomicStorePtrNoWB_0(v)
 	case OpAvg64u:
-		return rewriteValueARM64_OpAvg64u(v)
+		return rewriteValueARM64_OpAvg64u_0(v)
 	case OpBitLen64:
-		return rewriteValueARM64_OpBitLen64(v)
+		return rewriteValueARM64_OpBitLen64_0(v)
 	case OpBitRev16:
-		return rewriteValueARM64_OpBitRev16(v)
+		return rewriteValueARM64_OpBitRev16_0(v)
 	case OpBitRev32:
-		return rewriteValueARM64_OpBitRev32(v)
+		return rewriteValueARM64_OpBitRev32_0(v)
 	case OpBitRev64:
-		return rewriteValueARM64_OpBitRev64(v)
+		return rewriteValueARM64_OpBitRev64_0(v)
 	case OpBitRev8:
-		return rewriteValueARM64_OpBitRev8(v)
+		return rewriteValueARM64_OpBitRev8_0(v)
 	case OpBswap32:
-		return rewriteValueARM64_OpBswap32(v)
+		return rewriteValueARM64_OpBswap32_0(v)
 	case OpBswap64:
-		return rewriteValueARM64_OpBswap64(v)
+		return rewriteValueARM64_OpBswap64_0(v)
 	case OpClosureCall:
-		return rewriteValueARM64_OpClosureCall(v)
+		return rewriteValueARM64_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueARM64_OpCom16(v)
+		return rewriteValueARM64_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueARM64_OpCom32(v)
+		return rewriteValueARM64_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValueARM64_OpCom64(v)
+		return rewriteValueARM64_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValueARM64_OpCom8(v)
+		return rewriteValueARM64_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueARM64_OpConst16(v)
+		return rewriteValueARM64_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueARM64_OpConst32(v)
+		return rewriteValueARM64_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueARM64_OpConst32F(v)
+		return rewriteValueARM64_OpConst32F_0(v)
 	case OpConst64:
-		return rewriteValueARM64_OpConst64(v)
+		return rewriteValueARM64_OpConst64_0(v)
 	case OpConst64F:
-		return rewriteValueARM64_OpConst64F(v)
+		return rewriteValueARM64_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueARM64_OpConst8(v)
+		return rewriteValueARM64_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueARM64_OpConstBool(v)
+		return rewriteValueARM64_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueARM64_OpConstNil(v)
+		return rewriteValueARM64_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueARM64_OpConvert(v)
+		return rewriteValueARM64_OpConvert_0(v)
 	case OpCtz32:
-		return rewriteValueARM64_OpCtz32(v)
+		return rewriteValueARM64_OpCtz32_0(v)
 	case OpCtz64:
-		return rewriteValueARM64_OpCtz64(v)
+		return rewriteValueARM64_OpCtz64_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueARM64_OpCvt32Fto32(v)
+		return rewriteValueARM64_OpCvt32Fto32_0(v)
 	case OpCvt32Fto32U:
-		return rewriteValueARM64_OpCvt32Fto32U(v)
+		return rewriteValueARM64_OpCvt32Fto32U_0(v)
 	case OpCvt32Fto64:
-		return rewriteValueARM64_OpCvt32Fto64(v)
+		return rewriteValueARM64_OpCvt32Fto64_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueARM64_OpCvt32Fto64F(v)
+		return rewriteValueARM64_OpCvt32Fto64F_0(v)
 	case OpCvt32Fto64U:
-		return rewriteValueARM64_OpCvt32Fto64U(v)
+		return rewriteValueARM64_OpCvt32Fto64U_0(v)
 	case OpCvt32Uto32F:
-		return rewriteValueARM64_OpCvt32Uto32F(v)
+		return rewriteValueARM64_OpCvt32Uto32F_0(v)
 	case OpCvt32Uto64F:
-		return rewriteValueARM64_OpCvt32Uto64F(v)
+		return rewriteValueARM64_OpCvt32Uto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueARM64_OpCvt32to32F(v)
+		return rewriteValueARM64_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueARM64_OpCvt32to64F(v)
+		return rewriteValueARM64_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueARM64_OpCvt64Fto32(v)
+		return rewriteValueARM64_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueARM64_OpCvt64Fto32F(v)
+		return rewriteValueARM64_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto32U:
-		return rewriteValueARM64_OpCvt64Fto32U(v)
+		return rewriteValueARM64_OpCvt64Fto32U_0(v)
 	case OpCvt64Fto64:
-		return rewriteValueARM64_OpCvt64Fto64(v)
+		return rewriteValueARM64_OpCvt64Fto64_0(v)
 	case OpCvt64Fto64U:
-		return rewriteValueARM64_OpCvt64Fto64U(v)
+		return rewriteValueARM64_OpCvt64Fto64U_0(v)
 	case OpCvt64Uto32F:
-		return rewriteValueARM64_OpCvt64Uto32F(v)
+		return rewriteValueARM64_OpCvt64Uto32F_0(v)
 	case OpCvt64Uto64F:
-		return rewriteValueARM64_OpCvt64Uto64F(v)
+		return rewriteValueARM64_OpCvt64Uto64F_0(v)
 	case OpCvt64to32F:
-		return rewriteValueARM64_OpCvt64to32F(v)
+		return rewriteValueARM64_OpCvt64to32F_0(v)
 	case OpCvt64to64F:
-		return rewriteValueARM64_OpCvt64to64F(v)
+		return rewriteValueARM64_OpCvt64to64F_0(v)
 	case OpDiv16:
-		return rewriteValueARM64_OpDiv16(v)
+		return rewriteValueARM64_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueARM64_OpDiv16u(v)
+		return rewriteValueARM64_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueARM64_OpDiv32(v)
+		return rewriteValueARM64_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueARM64_OpDiv32F(v)
+		return rewriteValueARM64_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueARM64_OpDiv32u(v)
+		return rewriteValueARM64_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValueARM64_OpDiv64(v)
+		return rewriteValueARM64_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValueARM64_OpDiv64F(v)
+		return rewriteValueARM64_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValueARM64_OpDiv64u(v)
+		return rewriteValueARM64_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValueARM64_OpDiv8(v)
+		return rewriteValueARM64_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueARM64_OpDiv8u(v)
+		return rewriteValueARM64_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueARM64_OpEq16(v)
+		return rewriteValueARM64_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueARM64_OpEq32(v)
+		return rewriteValueARM64_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueARM64_OpEq32F(v)
+		return rewriteValueARM64_OpEq32F_0(v)
 	case OpEq64:
-		return rewriteValueARM64_OpEq64(v)
+		return rewriteValueARM64_OpEq64_0(v)
 	case OpEq64F:
-		return rewriteValueARM64_OpEq64F(v)
+		return rewriteValueARM64_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueARM64_OpEq8(v)
+		return rewriteValueARM64_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueARM64_OpEqB(v)
+		return rewriteValueARM64_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueARM64_OpEqPtr(v)
+		return rewriteValueARM64_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueARM64_OpGeq16(v)
+		return rewriteValueARM64_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueARM64_OpGeq16U(v)
+		return rewriteValueARM64_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueARM64_OpGeq32(v)
+		return rewriteValueARM64_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueARM64_OpGeq32F(v)
+		return rewriteValueARM64_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueARM64_OpGeq32U(v)
+		return rewriteValueARM64_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValueARM64_OpGeq64(v)
+		return rewriteValueARM64_OpGeq64_0(v)
 	case OpGeq64F:
-		return rewriteValueARM64_OpGeq64F(v)
+		return rewriteValueARM64_OpGeq64F_0(v)
 	case OpGeq64U:
-		return rewriteValueARM64_OpGeq64U(v)
+		return rewriteValueARM64_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValueARM64_OpGeq8(v)
+		return rewriteValueARM64_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueARM64_OpGeq8U(v)
+		return rewriteValueARM64_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueARM64_OpGetClosurePtr(v)
+		return rewriteValueARM64_OpGetClosurePtr_0(v)
 	case OpGreater16:
-		return rewriteValueARM64_OpGreater16(v)
+		return rewriteValueARM64_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueARM64_OpGreater16U(v)
+		return rewriteValueARM64_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueARM64_OpGreater32(v)
+		return rewriteValueARM64_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueARM64_OpGreater32F(v)
+		return rewriteValueARM64_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueARM64_OpGreater32U(v)
+		return rewriteValueARM64_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValueARM64_OpGreater64(v)
+		return rewriteValueARM64_OpGreater64_0(v)
 	case OpGreater64F:
-		return rewriteValueARM64_OpGreater64F(v)
+		return rewriteValueARM64_OpGreater64F_0(v)
 	case OpGreater64U:
-		return rewriteValueARM64_OpGreater64U(v)
+		return rewriteValueARM64_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValueARM64_OpGreater8(v)
+		return rewriteValueARM64_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueARM64_OpGreater8U(v)
+		return rewriteValueARM64_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueARM64_OpHmul32(v)
+		return rewriteValueARM64_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueARM64_OpHmul32u(v)
+		return rewriteValueARM64_OpHmul32u_0(v)
 	case OpHmul64:
-		return rewriteValueARM64_OpHmul64(v)
+		return rewriteValueARM64_OpHmul64_0(v)
 	case OpHmul64u:
-		return rewriteValueARM64_OpHmul64u(v)
+		return rewriteValueARM64_OpHmul64u_0(v)
 	case OpInterCall:
-		return rewriteValueARM64_OpInterCall(v)
+		return rewriteValueARM64_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueARM64_OpIsInBounds(v)
+		return rewriteValueARM64_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueARM64_OpIsNonNil(v)
+		return rewriteValueARM64_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueARM64_OpIsSliceInBounds(v)
+		return rewriteValueARM64_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueARM64_OpLeq16(v)
+		return rewriteValueARM64_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueARM64_OpLeq16U(v)
+		return rewriteValueARM64_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueARM64_OpLeq32(v)
+		return rewriteValueARM64_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueARM64_OpLeq32F(v)
+		return rewriteValueARM64_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueARM64_OpLeq32U(v)
+		return rewriteValueARM64_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValueARM64_OpLeq64(v)
+		return rewriteValueARM64_OpLeq64_0(v)
 	case OpLeq64F:
-		return rewriteValueARM64_OpLeq64F(v)
+		return rewriteValueARM64_OpLeq64F_0(v)
 	case OpLeq64U:
-		return rewriteValueARM64_OpLeq64U(v)
+		return rewriteValueARM64_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValueARM64_OpLeq8(v)
+		return rewriteValueARM64_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueARM64_OpLeq8U(v)
+		return rewriteValueARM64_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueARM64_OpLess16(v)
+		return rewriteValueARM64_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueARM64_OpLess16U(v)
+		return rewriteValueARM64_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueARM64_OpLess32(v)
+		return rewriteValueARM64_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueARM64_OpLess32F(v)
+		return rewriteValueARM64_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueARM64_OpLess32U(v)
+		return rewriteValueARM64_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValueARM64_OpLess64(v)
+		return rewriteValueARM64_OpLess64_0(v)
 	case OpLess64F:
-		return rewriteValueARM64_OpLess64F(v)
+		return rewriteValueARM64_OpLess64F_0(v)
 	case OpLess64U:
-		return rewriteValueARM64_OpLess64U(v)
+		return rewriteValueARM64_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValueARM64_OpLess8(v)
+		return rewriteValueARM64_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueARM64_OpLess8U(v)
+		return rewriteValueARM64_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueARM64_OpLoad(v)
+		return rewriteValueARM64_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueARM64_OpLsh16x16(v)
+		return rewriteValueARM64_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueARM64_OpLsh16x32(v)
+		return rewriteValueARM64_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueARM64_OpLsh16x64(v)
+		return rewriteValueARM64_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueARM64_OpLsh16x8(v)
+		return rewriteValueARM64_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueARM64_OpLsh32x16(v)
+		return rewriteValueARM64_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueARM64_OpLsh32x32(v)
+		return rewriteValueARM64_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueARM64_OpLsh32x64(v)
+		return rewriteValueARM64_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueARM64_OpLsh32x8(v)
+		return rewriteValueARM64_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValueARM64_OpLsh64x16(v)
+		return rewriteValueARM64_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValueARM64_OpLsh64x32(v)
+		return rewriteValueARM64_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValueARM64_OpLsh64x64(v)
+		return rewriteValueARM64_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValueARM64_OpLsh64x8(v)
+		return rewriteValueARM64_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueARM64_OpLsh8x16(v)
+		return rewriteValueARM64_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueARM64_OpLsh8x32(v)
+		return rewriteValueARM64_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueARM64_OpLsh8x64(v)
+		return rewriteValueARM64_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueARM64_OpLsh8x8(v)
+		return rewriteValueARM64_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValueARM64_OpMod16(v)
+		return rewriteValueARM64_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueARM64_OpMod16u(v)
+		return rewriteValueARM64_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueARM64_OpMod32(v)
+		return rewriteValueARM64_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueARM64_OpMod32u(v)
+		return rewriteValueARM64_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValueARM64_OpMod64(v)
+		return rewriteValueARM64_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValueARM64_OpMod64u(v)
+		return rewriteValueARM64_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValueARM64_OpMod8(v)
+		return rewriteValueARM64_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueARM64_OpMod8u(v)
+		return rewriteValueARM64_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueARM64_OpMove(v)
+		return rewriteValueARM64_OpMove_0(v) || rewriteValueARM64_OpMove_10(v)
 	case OpMul16:
-		return rewriteValueARM64_OpMul16(v)
+		return rewriteValueARM64_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueARM64_OpMul32(v)
+		return rewriteValueARM64_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueARM64_OpMul32F(v)
+		return rewriteValueARM64_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValueARM64_OpMul64(v)
+		return rewriteValueARM64_OpMul64_0(v)
 	case OpMul64F:
-		return rewriteValueARM64_OpMul64F(v)
+		return rewriteValueARM64_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValueARM64_OpMul8(v)
+		return rewriteValueARM64_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueARM64_OpNeg16(v)
+		return rewriteValueARM64_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueARM64_OpNeg32(v)
+		return rewriteValueARM64_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueARM64_OpNeg32F(v)
+		return rewriteValueARM64_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValueARM64_OpNeg64(v)
+		return rewriteValueARM64_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValueARM64_OpNeg64F(v)
+		return rewriteValueARM64_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueARM64_OpNeg8(v)
+		return rewriteValueARM64_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueARM64_OpNeq16(v)
+		return rewriteValueARM64_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueARM64_OpNeq32(v)
+		return rewriteValueARM64_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueARM64_OpNeq32F(v)
+		return rewriteValueARM64_OpNeq32F_0(v)
 	case OpNeq64:
-		return rewriteValueARM64_OpNeq64(v)
+		return rewriteValueARM64_OpNeq64_0(v)
 	case OpNeq64F:
-		return rewriteValueARM64_OpNeq64F(v)
+		return rewriteValueARM64_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueARM64_OpNeq8(v)
+		return rewriteValueARM64_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueARM64_OpNeqB(v)
+		return rewriteValueARM64_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueARM64_OpNeqPtr(v)
+		return rewriteValueARM64_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueARM64_OpNilCheck(v)
+		return rewriteValueARM64_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueARM64_OpNot(v)
+		return rewriteValueARM64_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueARM64_OpOffPtr(v)
+		return rewriteValueARM64_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueARM64_OpOr16(v)
+		return rewriteValueARM64_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueARM64_OpOr32(v)
+		return rewriteValueARM64_OpOr32_0(v)
 	case OpOr64:
-		return rewriteValueARM64_OpOr64(v)
+		return rewriteValueARM64_OpOr64_0(v)
 	case OpOr8:
-		return rewriteValueARM64_OpOr8(v)
+		return rewriteValueARM64_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueARM64_OpOrB(v)
+		return rewriteValueARM64_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValueARM64_OpRound32F(v)
+		return rewriteValueARM64_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueARM64_OpRound64F(v)
+		return rewriteValueARM64_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueARM64_OpRsh16Ux16(v)
+		return rewriteValueARM64_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueARM64_OpRsh16Ux32(v)
+		return rewriteValueARM64_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueARM64_OpRsh16Ux64(v)
+		return rewriteValueARM64_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueARM64_OpRsh16Ux8(v)
+		return rewriteValueARM64_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueARM64_OpRsh16x16(v)
+		return rewriteValueARM64_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueARM64_OpRsh16x32(v)
+		return rewriteValueARM64_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueARM64_OpRsh16x64(v)
+		return rewriteValueARM64_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueARM64_OpRsh16x8(v)
+		return rewriteValueARM64_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueARM64_OpRsh32Ux16(v)
+		return rewriteValueARM64_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueARM64_OpRsh32Ux32(v)
+		return rewriteValueARM64_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueARM64_OpRsh32Ux64(v)
+		return rewriteValueARM64_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueARM64_OpRsh32Ux8(v)
+		return rewriteValueARM64_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueARM64_OpRsh32x16(v)
+		return rewriteValueARM64_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueARM64_OpRsh32x32(v)
+		return rewriteValueARM64_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueARM64_OpRsh32x64(v)
+		return rewriteValueARM64_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueARM64_OpRsh32x8(v)
+		return rewriteValueARM64_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValueARM64_OpRsh64Ux16(v)
+		return rewriteValueARM64_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValueARM64_OpRsh64Ux32(v)
+		return rewriteValueARM64_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValueARM64_OpRsh64Ux64(v)
+		return rewriteValueARM64_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValueARM64_OpRsh64Ux8(v)
+		return rewriteValueARM64_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValueARM64_OpRsh64x16(v)
+		return rewriteValueARM64_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValueARM64_OpRsh64x32(v)
+		return rewriteValueARM64_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValueARM64_OpRsh64x64(v)
+		return rewriteValueARM64_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValueARM64_OpRsh64x8(v)
+		return rewriteValueARM64_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueARM64_OpRsh8Ux16(v)
+		return rewriteValueARM64_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueARM64_OpRsh8Ux32(v)
+		return rewriteValueARM64_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueARM64_OpRsh8Ux64(v)
+		return rewriteValueARM64_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueARM64_OpRsh8Ux8(v)
+		return rewriteValueARM64_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueARM64_OpRsh8x16(v)
+		return rewriteValueARM64_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueARM64_OpRsh8x32(v)
+		return rewriteValueARM64_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueARM64_OpRsh8x64(v)
+		return rewriteValueARM64_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueARM64_OpRsh8x8(v)
+		return rewriteValueARM64_OpRsh8x8_0(v)
 	case OpSignExt16to32:
-		return rewriteValueARM64_OpSignExt16to32(v)
+		return rewriteValueARM64_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValueARM64_OpSignExt16to64(v)
+		return rewriteValueARM64_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValueARM64_OpSignExt32to64(v)
+		return rewriteValueARM64_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValueARM64_OpSignExt8to16(v)
+		return rewriteValueARM64_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueARM64_OpSignExt8to32(v)
+		return rewriteValueARM64_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValueARM64_OpSignExt8to64(v)
+		return rewriteValueARM64_OpSignExt8to64_0(v)
 	case OpSlicemask:
-		return rewriteValueARM64_OpSlicemask(v)
+		return rewriteValueARM64_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValueARM64_OpSqrt(v)
+		return rewriteValueARM64_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValueARM64_OpStaticCall(v)
+		return rewriteValueARM64_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueARM64_OpStore(v)
+		return rewriteValueARM64_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueARM64_OpSub16(v)
+		return rewriteValueARM64_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueARM64_OpSub32(v)
+		return rewriteValueARM64_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueARM64_OpSub32F(v)
+		return rewriteValueARM64_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValueARM64_OpSub64(v)
+		return rewriteValueARM64_OpSub64_0(v)
 	case OpSub64F:
-		return rewriteValueARM64_OpSub64F(v)
+		return rewriteValueARM64_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueARM64_OpSub8(v)
+		return rewriteValueARM64_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueARM64_OpSubPtr(v)
+		return rewriteValueARM64_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueARM64_OpTrunc16to8(v)
+		return rewriteValueARM64_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueARM64_OpTrunc32to16(v)
+		return rewriteValueARM64_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueARM64_OpTrunc32to8(v)
+		return rewriteValueARM64_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValueARM64_OpTrunc64to16(v)
+		return rewriteValueARM64_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValueARM64_OpTrunc64to32(v)
+		return rewriteValueARM64_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValueARM64_OpTrunc64to8(v)
+		return rewriteValueARM64_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValueARM64_OpXor16(v)
+		return rewriteValueARM64_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueARM64_OpXor32(v)
+		return rewriteValueARM64_OpXor32_0(v)
 	case OpXor64:
-		return rewriteValueARM64_OpXor64(v)
+		return rewriteValueARM64_OpXor64_0(v)
 	case OpXor8:
-		return rewriteValueARM64_OpXor8(v)
+		return rewriteValueARM64_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueARM64_OpZero(v)
+		return rewriteValueARM64_OpZero_0(v) || rewriteValueARM64_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValueARM64_OpZeroExt16to32(v)
+		return rewriteValueARM64_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValueARM64_OpZeroExt16to64(v)
+		return rewriteValueARM64_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValueARM64_OpZeroExt32to64(v)
+		return rewriteValueARM64_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueARM64_OpZeroExt8to16(v)
+		return rewriteValueARM64_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueARM64_OpZeroExt8to32(v)
+		return rewriteValueARM64_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValueARM64_OpZeroExt8to64(v)
+		return rewriteValueARM64_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ADD(v *Value) bool {
+func rewriteValueARM64_OpARM64ADD_0(v *Value) bool {
 	// match: (ADD x (MOVDconst [c]))
 	// cond:
 	// result: (ADDconst [c] x)
@@ -883,7 +883,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool {
 	// match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr))
 	// cond:
 	// result: (MOVDaddr [off1+off2] {sym} ptr)
@@ -963,7 +963,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftLL (MOVDconst [c]) x [d])
@@ -1053,7 +1053,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRA (MOVDconst [c]) x [d])
@@ -1093,7 +1093,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ADDshiftRL (MOVDconst [c]) x [d])
@@ -1183,7 +1183,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64AND(v *Value) bool {
+func rewriteValueARM64_OpARM64AND_0(v *Value) bool {
 	// match: (AND x (MOVDconst [c]))
 	// cond:
 	// result: (ANDconst [c] x)
@@ -1342,6 +1342,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64AND_10(v *Value) bool {
 	// match: (AND (SRAconst [c] y) x)
 	// cond:
 	// result: (ANDshiftRA x y [c])
@@ -1361,7 +1364,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool {
 	// match: (ANDconst [0] _)
 	// cond:
 	// result: (MOVDconst [0])
@@ -1418,7 +1421,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftLL (MOVDconst [c]) x [d])
@@ -1480,7 +1483,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRA (MOVDconst [c]) x [d])
@@ -1542,7 +1545,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ANDshiftRL (MOVDconst [c]) x [d])
@@ -1604,7 +1607,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64BIC(v *Value) bool {
+func rewriteValueARM64_OpARM64BIC_0(v *Value) bool {
 	// match: (BIC x (MOVDconst [c]))
 	// cond:
 	// result: (BICconst [c] x)
@@ -1685,7 +1688,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64BICconst(v *Value) bool {
+func rewriteValueARM64_OpARM64BICconst_0(v *Value) bool {
 	// match: (BICconst [0] x)
 	// cond:
 	// result: x
@@ -1726,7 +1729,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftLL_0(v *Value) bool {
 	// match: (BICshiftLL x (MOVDconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(uint64(c)<<uint64(d))])
@@ -1766,7 +1769,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRA_0(v *Value) bool {
 	// match: (BICshiftRA x (MOVDconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(int64(c)>>uint64(d))])
@@ -1806,7 +1809,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool {
 	// match: (BICshiftRL x (MOVDconst [c]) [d])
 	// cond:
 	// result: (BICconst x [int64(uint64(c)>>uint64(d))])
@@ -1846,7 +1849,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMP(v *Value) bool {
+func rewriteValueARM64_OpARM64CMP_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMP x (MOVDconst [c]))
@@ -1991,7 +1994,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPW x (MOVDconst [c]))
@@ -2028,7 +2031,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool {
 	// match: (CMPWconst (MOVDconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -2141,7 +2144,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool {
 	// match: (CMPconst (MOVDconst [x]) [y])
 	// cond: x==y
 	// result: (FlagEQ)
@@ -2301,7 +2304,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftLL (MOVDconst [c]) x [d])
@@ -2343,7 +2346,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRA (MOVDconst [c]) x [d])
@@ -2385,7 +2388,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPshiftRL (MOVDconst [c]) x [d])
@@ -2427,7 +2430,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CSELULT(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT_0(v *Value) bool {
 	// match: (CSELULT x (MOVDconst [0]) flag)
 	// cond:
 	// result: (CSELULT0 x flag)
@@ -2518,7 +2521,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT0_0(v *Value) bool {
 	// match: (CSELULT0 _ (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -2585,7 +2588,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64DIV(v *Value) bool {
+func rewriteValueARM64_OpARM64DIV_0(v *Value) bool {
 	// match: (DIV (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(c)/int64(d)])
@@ -2606,7 +2609,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool {
 	// match: (DIVW (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(int32(c)/int32(d))])
@@ -2627,7 +2630,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64Equal(v *Value) bool {
+func rewriteValueARM64_OpARM64Equal_0(v *Value) bool {
 	// match: (Equal (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -2703,7 +2706,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool {
 	// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 8, sym)
 	// result: (FMOVDload [off1+off2] {sym} ptr mem)
@@ -2753,7 +2756,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool {
 	// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 8, sym)
 	// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -2807,7 +2810,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool {
 	// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (FMOVSload [off1+off2] {sym} ptr mem)
@@ -2857,7 +2860,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool {
 	// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -2911,7 +2914,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool {
 	// match: (GreaterEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -2987,7 +2990,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool {
 	// match: (GreaterEqualU (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -3063,7 +3066,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool {
 	// match: (GreaterThan (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -3139,7 +3142,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool {
 	// match: (GreaterThanU (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -3215,7 +3218,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool {
 	// match: (LessEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -3291,7 +3294,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool {
 	// match: (LessEqualU (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -3367,7 +3370,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool {
 	// match: (LessThan (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -3443,7 +3446,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64LessThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool {
 	// match: (LessThanU (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -3519,7 +3522,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOD(v *Value) bool {
+func rewriteValueARM64_OpARM64MOD_0(v *Value) bool {
 	// match: (MOD (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(c)%int64(d)])
@@ -3540,7 +3543,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MODW(v *Value) bool {
+func rewriteValueARM64_OpARM64MODW_0(v *Value) bool {
 	// match: (MODW (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(int32(c)%int32(d))])
@@ -3561,7 +3564,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool {
 	// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 1, sym)
 	// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -3632,7 +3635,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool {
 	// match: (MOVBUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -3672,7 +3675,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool {
 	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 1, sym)
 	// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -3743,7 +3746,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool {
 	// match: (MOVBreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -3783,7 +3786,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 1, sym)
 	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -3985,7 +3988,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool {
 	// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 1, sym)
 	// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
@@ -4035,7 +4038,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool {
 	// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 8, sym)
 	// result: (MOVDload [off1+off2] {sym} ptr mem)
@@ -4106,7 +4109,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool {
 	// match: (MOVDreg x)
 	// cond: x.Uses == 1
 	// result: (MOVDnop x)
@@ -4134,7 +4137,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 8, sym)
 	// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -4210,7 +4213,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool {
 	// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 8, sym)
 	// result: (MOVDstorezero [off1+off2] {sym} ptr mem)
@@ -4260,7 +4263,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool {
 	// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 2, sym)
 	// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -4331,7 +4334,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool {
 	// match: (MOVHUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -4395,7 +4398,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 2, sym)
 	// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -4466,7 +4469,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool {
 	// match: (MOVHreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -4554,7 +4557,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 2, sym)
 	// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -4714,7 +4717,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool {
 	// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 2, sym)
 	// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
@@ -4764,7 +4767,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool {
 	// match: (MOVWUload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (MOVWUload [off1+off2] {sym} ptr mem)
@@ -4835,7 +4838,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool {
 	// match: (MOVWUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -4923,7 +4926,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool {
 	// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (MOVWload [off1+off2] {sym} ptr mem)
@@ -4994,7 +4997,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool {
 	// match: (MOVWreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -5115,6 +5118,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool {
 	// match: (MOVWreg (MOVDconst [c]))
 	// cond:
 	// result: (MOVDconst [int64(int32(c))])
@@ -5130,7 +5136,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (MOVWstore [off1+off2] {sym} ptr val mem)
@@ -5248,7 +5254,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool {
 	// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: fitsARM64Offset(off1+off2, 4, sym)
 	// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
@@ -5298,9 +5304,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MUL(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueARM64_OpARM64MUL_0(v *Value) bool {
 	// match: (MUL x (MOVDconst [-1]))
 	// cond:
 	// result: (NEG x)
@@ -5471,6 +5475,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64MUL_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MUL x (MOVDconst [c]))
 	// cond: isPowerOfTwo(c+1) && c >= 7
 	// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
@@ -5693,6 +5702,9 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64MUL_20(v *Value) bool {
 	// match: (MUL (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [c*d])
@@ -5731,9 +5743,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MULW(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueARM64_OpARM64MULW_0(v *Value) bool {
 	// match: (MULW x (MOVDconst [c]))
 	// cond: int32(c)==-1
 	// result: (NEG x)
@@ -5910,6 +5920,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64MULW_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MULW x (MOVDconst [c]))
 	// cond: isPowerOfTwo(c+1) && int32(c) >= 7
 	// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
@@ -6132,6 +6147,9 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64MULW_20(v *Value) bool {
 	// match: (MULW (MOVDconst [c]) (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(int32(c)*int32(d))])
@@ -6170,7 +6188,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64MVN(v *Value) bool {
+func rewriteValueARM64_OpARM64MVN_0(v *Value) bool {
 	// match: (MVN (MOVDconst [c]))
 	// cond:
 	// result: (MOVDconst [^c])
@@ -6186,7 +6204,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64NEG(v *Value) bool {
+func rewriteValueARM64_OpARM64NEG_0(v *Value) bool {
 	// match: (NEG (MOVDconst [c]))
 	// cond:
 	// result: (MOVDconst [-c])
@@ -6202,7 +6220,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool {
 	// match: (NotEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -6278,7 +6296,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64OR(v *Value) bool {
+func rewriteValueARM64_OpARM64OR_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (OR x (MOVDconst [c]))
@@ -6533,6 +6551,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64OR_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (OR <t> y3:(MOVDnop x3:(MOVBUload [i0] {s} p mem)) o0:(ORshiftLL [8] o1:(ORshiftLL [16] s0:(SLLconst [24] y0:(MOVDnop x0:(MOVBUload [i3] {s} p mem))) y1:(MOVDnop x1:(MOVBUload [i2] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i1] {s} p mem))))
 	// cond: i1 == i0+1 	&& i2 == i0+2 	&& i3 == i0+3 	&& x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 	&& y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 	&& o0.Uses == 1 && o1.Uses == 1 && s0.Uses == 1 	&& mergePoint(b,x0,x1,x2,x3) != nil 	&& clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) 	&& clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) 	&& clobber(o0) && clobber(o1) && clobber(s0)
 	// result: @mergePoint(b,x0,x1,x2,x3) (MOVWUload <t> {s} (OffPtr <p.Type> [i0] p) mem)
@@ -7696,7 +7719,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool {
 	// match: (ORconst [0] x)
 	// cond:
 	// result: x
@@ -7753,7 +7776,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftLL (MOVDconst [c]) x [d])
@@ -8247,6 +8270,11 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (ORshiftLL <t> [56] o0:(ORshiftLL [48] o1:(ORshiftLL [40] o2:(ORshiftLL [32] y0:(REVW x0:(MOVWUload [i4] {s} p mem)) y1:(MOVDnop x1:(MOVBUload [i3] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i2] {s} p mem))) y3:(MOVDnop x3:(MOVBUload [i1] {s} p mem))) y4:(MOVDnop x4:(MOVBUload [i0] {s} p mem)))
 	// cond: i1 == i0+1 	&& i2 == i0+2 	&& i3 == i0+3 	&& i4 == i0+4 	&& x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && x4.Uses == 1 	&& y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 && y4.Uses == 1 	&& o0.Uses == 1 && o1.Uses == 1 && o2.Uses == 1 	&& mergePoint(b,x0,x1,x2,x3,x4) != nil 	&& clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(x4) 	&& clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) && clobber(y4) 	&& clobber(o0) && clobber(o1) && clobber(o2)
 	// result: @mergePoint(b,x0,x1,x2,x3,x4) (REV <t> (MOVDload <t> {s} (OffPtr <p.Type> [i0] p) mem))
@@ -8379,7 +8407,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRA (MOVDconst [c]) x [d])
@@ -8441,7 +8469,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ORshiftRL (MOVDconst [c]) x [d])
@@ -8553,7 +8581,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SLL_0(v *Value) bool {
 	// match: (SLL x (MOVDconst [c]))
 	// cond:
 	// result: (SLLconst x [c&63])
@@ -8571,7 +8599,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SLLconst_0(v *Value) bool {
 	// match: (SLLconst [c] (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(d)<<uint64(c)])
@@ -8609,7 +8637,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SRA_0(v *Value) bool {
 	// match: (SRA x (MOVDconst [c]))
 	// cond:
 	// result: (SRAconst x [c&63])
@@ -8627,7 +8655,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRAconst_0(v *Value) bool {
 	// match: (SRAconst [c] (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(d)>>uint64(c)])
@@ -8644,7 +8672,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SRL_0(v *Value) bool {
 	// match: (SRL x (MOVDconst [c]))
 	// cond:
 	// result: (SRLconst x [c&63])
@@ -8662,7 +8690,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool {
 	// match: (SRLconst [c] (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [int64(uint64(d)>>uint64(c))])
@@ -8700,7 +8728,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SUB(v *Value) bool {
+func rewriteValueARM64_OpARM64SUB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUB x (MOVDconst [c]))
@@ -8821,7 +8849,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool {
 	// match: (SUBconst [0] x)
 	// cond:
 	// result: x
@@ -8883,7 +8911,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftLL_0(v *Value) bool {
 	// match: (SUBshiftLL x (MOVDconst [c]) [d])
 	// cond:
 	// result: (SUBconst x [int64(uint64(c)<<uint64(d))])
@@ -8923,7 +8951,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRA_0(v *Value) bool {
 	// match: (SUBshiftRA x (MOVDconst [c]) [d])
 	// cond:
 	// result: (SUBconst x [int64(int64(c)>>uint64(d))])
@@ -8963,7 +8991,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool {
 	// match: (SUBshiftRL x (MOVDconst [c]) [d])
 	// cond:
 	// result: (SUBconst x [int64(uint64(c)>>uint64(d))])
@@ -9003,7 +9031,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool {
 	// match: (UDIV x (MOVDconst [1]))
 	// cond:
 	// result: x
@@ -9059,7 +9087,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool {
 	// match: (UDIVW x (MOVDconst [c]))
 	// cond: uint32(c)==1
 	// result: x
@@ -9116,7 +9144,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
+func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool {
 	// match: (UMOD _ (MOVDconst [1]))
 	// cond:
 	// result: (MOVDconst [0])
@@ -9170,7 +9198,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
+func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool {
 	// match: (UMODW _ (MOVDconst [c]))
 	// cond: uint32(c)==1
 	// result: (MOVDconst [0])
@@ -9225,7 +9253,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64XOR(v *Value) bool {
+func rewriteValueARM64_OpARM64XOR_0(v *Value) bool {
 	// match: (XOR x (MOVDconst [c]))
 	// cond:
 	// result: (XORconst [c] x)
@@ -9372,7 +9400,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool {
 	// match: (XORconst [0] x)
 	// cond:
 	// result: x
@@ -9430,7 +9458,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftLL (MOVDconst [c]) x [d])
@@ -9541,7 +9569,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRA (MOVDconst [c]) x [d])
@@ -9602,7 +9630,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (XORshiftRL (MOVDconst [c]) x [d])
@@ -9713,7 +9741,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpAdd16(v *Value) bool {
+func rewriteValueARM64_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADD x y)
@@ -9726,7 +9754,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAdd32(v *Value) bool {
+func rewriteValueARM64_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADD x y)
@@ -9739,7 +9767,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAdd32F(v *Value) bool {
+func rewriteValueARM64_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (FADDS x y)
@@ -9752,7 +9780,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAdd64(v *Value) bool {
+func rewriteValueARM64_OpAdd64_0(v *Value) bool {
 	// match: (Add64 x y)
 	// cond:
 	// result: (ADD x y)
@@ -9765,7 +9793,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAdd64F(v *Value) bool {
+func rewriteValueARM64_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (FADDD x y)
@@ -9778,7 +9806,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAdd8(v *Value) bool {
+func rewriteValueARM64_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADD x y)
@@ -9791,7 +9819,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAddPtr(v *Value) bool {
+func rewriteValueARM64_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADD x y)
@@ -9804,7 +9832,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAddr(v *Value) bool {
+func rewriteValueARM64_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVDaddr {sym} base)
@@ -9817,7 +9845,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAnd16(v *Value) bool {
+func rewriteValueARM64_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (AND x y)
@@ -9830,7 +9858,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAnd32(v *Value) bool {
+func rewriteValueARM64_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (AND x y)
@@ -9843,7 +9871,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAnd64(v *Value) bool {
+func rewriteValueARM64_OpAnd64_0(v *Value) bool {
 	// match: (And64 x y)
 	// cond:
 	// result: (AND x y)
@@ -9856,7 +9884,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAnd8(v *Value) bool {
+func rewriteValueARM64_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (AND x y)
@@ -9869,7 +9897,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAndB(v *Value) bool {
+func rewriteValueARM64_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (AND x y)
@@ -9882,7 +9910,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool {
 	// match: (AtomicAdd32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAdd32 ptr val mem)
@@ -9897,7 +9925,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool {
 	// match: (AtomicAdd64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAdd64 ptr val mem)
@@ -9912,7 +9940,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool {
 	// match: (AtomicAnd8 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAnd8 ptr val mem)
@@ -9927,7 +9955,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -9944,7 +9972,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -9961,7 +9989,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool {
 	// match: (AtomicExchange32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange32 ptr val mem)
@@ -9976,7 +10004,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool {
 	// match: (AtomicExchange64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange64 ptr val mem)
@@ -9991,7 +10019,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool {
 	// match: (AtomicLoad32 ptr mem)
 	// cond:
 	// result: (LDARW ptr mem)
@@ -10004,7 +10032,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool {
 	// match: (AtomicLoad64 ptr mem)
 	// cond:
 	// result: (LDAR  ptr mem)
@@ -10017,7 +10045,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool {
 	// match: (AtomicLoadPtr ptr mem)
 	// cond:
 	// result: (LDAR  ptr mem)
@@ -10030,7 +10058,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicOr8(v *Value) bool {
+func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool {
 	// match: (AtomicOr8 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicOr8  ptr val mem)
@@ -10045,7 +10073,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicStore32(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool {
 	// match: (AtomicStore32 ptr val mem)
 	// cond:
 	// result: (STLRW ptr val mem)
@@ -10060,7 +10088,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicStore64(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool {
 	// match: (AtomicStore64 ptr val mem)
 	// cond:
 	// result: (STLR  ptr val mem)
@@ -10075,7 +10103,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool {
 	// match: (AtomicStorePtrNoWB ptr val mem)
 	// cond:
 	// result: (STLR  ptr val mem)
@@ -10090,7 +10118,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpAvg64u(v *Value) bool {
+func rewriteValueARM64_OpAvg64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg64u <t> x y)
@@ -10112,7 +10140,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBitLen64(v *Value) bool {
+func rewriteValueARM64_OpBitLen64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10132,7 +10160,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBitRev16(v *Value) bool {
+func rewriteValueARM64_OpBitRev16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10150,7 +10178,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBitRev32(v *Value) bool {
+func rewriteValueARM64_OpBitRev32_0(v *Value) bool {
 	// match: (BitRev32 x)
 	// cond:
 	// result: (RBITW x)
@@ -10161,7 +10189,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBitRev64(v *Value) bool {
+func rewriteValueARM64_OpBitRev64_0(v *Value) bool {
 	// match: (BitRev64 x)
 	// cond:
 	// result: (RBIT x)
@@ -10172,7 +10200,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBitRev8(v *Value) bool {
+func rewriteValueARM64_OpBitRev8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10190,7 +10218,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBswap32(v *Value) bool {
+func rewriteValueARM64_OpBswap32_0(v *Value) bool {
 	// match: (Bswap32 x)
 	// cond:
 	// result: (REVW x)
@@ -10201,7 +10229,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpBswap64(v *Value) bool {
+func rewriteValueARM64_OpBswap64_0(v *Value) bool {
 	// match: (Bswap64 x)
 	// cond:
 	// result: (REV x)
@@ -10212,7 +10240,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpClosureCall(v *Value) bool {
+func rewriteValueARM64_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -10229,7 +10257,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCom16(v *Value) bool {
+func rewriteValueARM64_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (MVN x)
@@ -10240,7 +10268,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCom32(v *Value) bool {
+func rewriteValueARM64_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (MVN x)
@@ -10251,7 +10279,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCom64(v *Value) bool {
+func rewriteValueARM64_OpCom64_0(v *Value) bool {
 	// match: (Com64 x)
 	// cond:
 	// result: (MVN x)
@@ -10262,7 +10290,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCom8(v *Value) bool {
+func rewriteValueARM64_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (MVN x)
@@ -10273,7 +10301,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst16(v *Value) bool {
+func rewriteValueARM64_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -10284,7 +10312,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst32(v *Value) bool {
+func rewriteValueARM64_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -10295,7 +10323,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst32F(v *Value) bool {
+func rewriteValueARM64_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (FMOVSconst [val])
@@ -10306,7 +10334,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst64(v *Value) bool {
+func rewriteValueARM64_OpConst64_0(v *Value) bool {
 	// match: (Const64 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -10317,7 +10345,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst64F(v *Value) bool {
+func rewriteValueARM64_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (FMOVDconst [val])
@@ -10328,7 +10356,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConst8(v *Value) bool {
+func rewriteValueARM64_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -10339,7 +10367,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConstBool(v *Value) bool {
+func rewriteValueARM64_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVDconst [b])
@@ -10350,7 +10378,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConstNil(v *Value) bool {
+func rewriteValueARM64_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVDconst [0])
@@ -10360,7 +10388,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpConvert(v *Value) bool {
+func rewriteValueARM64_OpConvert_0(v *Value) bool {
 	// match: (Convert x mem)
 	// cond:
 	// result: (MOVDconvert x mem)
@@ -10373,7 +10401,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCtz32(v *Value) bool {
+func rewriteValueARM64_OpCtz32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Ctz32 <t> x)
@@ -10389,7 +10417,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCtz64(v *Value) bool {
+func rewriteValueARM64_OpCtz64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Ctz64 <t> x)
@@ -10405,7 +10433,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (FCVTZSSW x)
@@ -10416,7 +10444,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool {
 	// match: (Cvt32Fto32U x)
 	// cond:
 	// result: (FCVTZUSW x)
@@ -10427,7 +10455,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool {
 	// match: (Cvt32Fto64 x)
 	// cond:
 	// result: (FCVTZSS x)
@@ -10438,7 +10466,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (FCVTSD x)
@@ -10449,7 +10477,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool {
 	// match: (Cvt32Fto64U x)
 	// cond:
 	// result: (FCVTZUS x)
@@ -10460,7 +10488,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool {
 	// match: (Cvt32Uto32F x)
 	// cond:
 	// result: (UCVTFWS x)
@@ -10471,7 +10499,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool {
 	// match: (Cvt32Uto64F x)
 	// cond:
 	// result: (UCVTFWD x)
@@ -10482,7 +10510,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (SCVTFWS x)
@@ -10493,7 +10521,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (SCVTFWD x)
@@ -10504,7 +10532,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (FCVTZSDW x)
@@ -10515,7 +10543,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (FCVTDS x)
@@ -10526,7 +10554,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool {
 	// match: (Cvt64Fto32U x)
 	// cond:
 	// result: (FCVTZUDW x)
@@ -10537,7 +10565,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool {
 	// match: (Cvt64Fto64 x)
 	// cond:
 	// result: (FCVTZSD x)
@@ -10548,7 +10576,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool {
 	// match: (Cvt64Fto64U x)
 	// cond:
 	// result: (FCVTZUD x)
@@ -10559,7 +10587,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool {
 	// match: (Cvt64Uto32F x)
 	// cond:
 	// result: (UCVTFS x)
@@ -10570,7 +10598,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool {
 	// match: (Cvt64Uto64F x)
 	// cond:
 	// result: (UCVTFD x)
@@ -10581,7 +10609,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool {
 	// match: (Cvt64to32F x)
 	// cond:
 	// result: (SCVTFS x)
@@ -10592,7 +10620,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpCvt64to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool {
 	// match: (Cvt64to64F x)
 	// cond:
 	// result: (SCVTFD x)
@@ -10603,7 +10631,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv16(v *Value) bool {
+func rewriteValueARM64_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10624,7 +10652,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv16u(v *Value) bool {
+func rewriteValueARM64_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10645,7 +10673,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv32(v *Value) bool {
+func rewriteValueARM64_OpDiv32_0(v *Value) bool {
 	// match: (Div32 x y)
 	// cond:
 	// result: (DIVW x y)
@@ -10658,7 +10686,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv32F(v *Value) bool {
+func rewriteValueARM64_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (FDIVS x y)
@@ -10671,7 +10699,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv32u(v *Value) bool {
+func rewriteValueARM64_OpDiv32u_0(v *Value) bool {
 	// match: (Div32u x y)
 	// cond:
 	// result: (UDIVW x y)
@@ -10684,7 +10712,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv64(v *Value) bool {
+func rewriteValueARM64_OpDiv64_0(v *Value) bool {
 	// match: (Div64 x y)
 	// cond:
 	// result: (DIV x y)
@@ -10697,7 +10725,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv64F(v *Value) bool {
+func rewriteValueARM64_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (FDIVD x y)
@@ -10710,7 +10738,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv64u(v *Value) bool {
+func rewriteValueARM64_OpDiv64u_0(v *Value) bool {
 	// match: (Div64u x y)
 	// cond:
 	// result: (UDIV x y)
@@ -10723,7 +10751,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv8(v *Value) bool {
+func rewriteValueARM64_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10744,7 +10772,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpDiv8u(v *Value) bool {
+func rewriteValueARM64_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10765,7 +10793,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq16(v *Value) bool {
+func rewriteValueARM64_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10788,7 +10816,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq32(v *Value) bool {
+func rewriteValueARM64_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x y)
@@ -10805,7 +10833,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq32F(v *Value) bool {
+func rewriteValueARM64_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -10822,7 +10850,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq64(v *Value) bool {
+func rewriteValueARM64_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64 x y)
@@ -10839,7 +10867,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq64F(v *Value) bool {
+func rewriteValueARM64_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -10856,7 +10884,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEq8(v *Value) bool {
+func rewriteValueARM64_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10879,7 +10907,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEqB(v *Value) bool {
+func rewriteValueARM64_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10901,7 +10929,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpEqPtr(v *Value) bool {
+func rewriteValueARM64_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqPtr x y)
@@ -10918,7 +10946,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq16(v *Value) bool {
+func rewriteValueARM64_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10941,7 +10969,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq16U(v *Value) bool {
+func rewriteValueARM64_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10964,7 +10992,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq32(v *Value) bool {
+func rewriteValueARM64_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32 x y)
@@ -10981,7 +11009,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq32F(v *Value) bool {
+func rewriteValueARM64_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -10998,7 +11026,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq32U(v *Value) bool {
+func rewriteValueARM64_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32U x y)
@@ -11015,7 +11043,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq64(v *Value) bool {
+func rewriteValueARM64_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64 x y)
@@ -11032,7 +11060,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq64F(v *Value) bool {
+func rewriteValueARM64_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -11049,7 +11077,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq64U(v *Value) bool {
+func rewriteValueARM64_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64U x y)
@@ -11066,7 +11094,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq8(v *Value) bool {
+func rewriteValueARM64_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11089,7 +11117,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGeq8U(v *Value) bool {
+func rewriteValueARM64_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11112,7 +11140,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -11121,7 +11149,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater16(v *Value) bool {
+func rewriteValueARM64_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11144,7 +11172,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater16U(v *Value) bool {
+func rewriteValueARM64_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11167,7 +11195,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater32(v *Value) bool {
+func rewriteValueARM64_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32 x y)
@@ -11184,7 +11212,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater32F(v *Value) bool {
+func rewriteValueARM64_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -11201,7 +11229,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater32U(v *Value) bool {
+func rewriteValueARM64_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32U x y)
@@ -11218,7 +11246,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater64(v *Value) bool {
+func rewriteValueARM64_OpGreater64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64 x y)
@@ -11235,7 +11263,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater64F(v *Value) bool {
+func rewriteValueARM64_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -11252,7 +11280,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater64U(v *Value) bool {
+func rewriteValueARM64_OpGreater64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64U x y)
@@ -11269,7 +11297,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater8(v *Value) bool {
+func rewriteValueARM64_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11292,7 +11320,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpGreater8U(v *Value) bool {
+func rewriteValueARM64_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11315,7 +11343,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpHmul32(v *Value) bool {
+func rewriteValueARM64_OpHmul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11335,7 +11363,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpHmul32u(v *Value) bool {
+func rewriteValueARM64_OpHmul32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11355,7 +11383,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpHmul64(v *Value) bool {
+func rewriteValueARM64_OpHmul64_0(v *Value) bool {
 	// match: (Hmul64 x y)
 	// cond:
 	// result: (MULH x y)
@@ -11368,7 +11396,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpHmul64u(v *Value) bool {
+func rewriteValueARM64_OpHmul64u_0(v *Value) bool {
 	// match: (Hmul64u x y)
 	// cond:
 	// result: (UMULH x y)
@@ -11381,7 +11409,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpInterCall(v *Value) bool {
+func rewriteValueARM64_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -11396,7 +11424,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpIsInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsInBounds idx len)
@@ -11413,7 +11441,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpIsNonNil(v *Value) bool {
+func rewriteValueARM64_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsNonNil ptr)
@@ -11429,7 +11457,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsSliceInBounds idx len)
@@ -11446,7 +11474,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq16(v *Value) bool {
+func rewriteValueARM64_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11469,7 +11497,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq16U(v *Value) bool {
+func rewriteValueARM64_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11492,7 +11520,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq32(v *Value) bool {
+func rewriteValueARM64_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32 x y)
@@ -11509,7 +11537,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq32F(v *Value) bool {
+func rewriteValueARM64_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -11526,7 +11554,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq32U(v *Value) bool {
+func rewriteValueARM64_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32U x y)
@@ -11543,7 +11571,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq64(v *Value) bool {
+func rewriteValueARM64_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64 x y)
@@ -11560,7 +11588,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq64F(v *Value) bool {
+func rewriteValueARM64_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -11577,7 +11605,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq64U(v *Value) bool {
+func rewriteValueARM64_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64U x y)
@@ -11594,7 +11622,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq8(v *Value) bool {
+func rewriteValueARM64_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11617,7 +11645,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLeq8U(v *Value) bool {
+func rewriteValueARM64_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11640,7 +11668,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess16(v *Value) bool {
+func rewriteValueARM64_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11663,7 +11691,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess16U(v *Value) bool {
+func rewriteValueARM64_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11686,7 +11714,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess32(v *Value) bool {
+func rewriteValueARM64_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32 x y)
@@ -11703,7 +11731,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess32F(v *Value) bool {
+func rewriteValueARM64_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -11720,7 +11748,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess32U(v *Value) bool {
+func rewriteValueARM64_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32U x y)
@@ -11737,7 +11765,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess64(v *Value) bool {
+func rewriteValueARM64_OpLess64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64 x y)
@@ -11754,7 +11782,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess64F(v *Value) bool {
+func rewriteValueARM64_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -11771,7 +11799,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess64U(v *Value) bool {
+func rewriteValueARM64_OpLess64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64U x y)
@@ -11788,7 +11816,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess8(v *Value) bool {
+func rewriteValueARM64_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11811,7 +11839,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLess8U(v *Value) bool {
+func rewriteValueARM64_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11834,7 +11862,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLoad(v *Value) bool {
+func rewriteValueARM64_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: t.IsBoolean()
 	// result: (MOVBUload ptr mem)
@@ -11987,7 +12015,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpLsh16x16(v *Value) bool {
+func rewriteValueARM64_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12018,7 +12046,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh16x32(v *Value) bool {
+func rewriteValueARM64_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12049,7 +12077,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh16x64(v *Value) bool {
+func rewriteValueARM64_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x64 x (MOVDconst [c]))
@@ -12108,7 +12136,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh16x8(v *Value) bool {
+func rewriteValueARM64_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12139,7 +12167,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh32x16(v *Value) bool {
+func rewriteValueARM64_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12170,7 +12198,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh32x32(v *Value) bool {
+func rewriteValueARM64_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12201,7 +12229,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh32x64(v *Value) bool {
+func rewriteValueARM64_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x64 x (MOVDconst [c]))
@@ -12260,7 +12288,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh32x8(v *Value) bool {
+func rewriteValueARM64_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12291,7 +12319,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh64x16(v *Value) bool {
+func rewriteValueARM64_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12322,7 +12350,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh64x32(v *Value) bool {
+func rewriteValueARM64_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12353,7 +12381,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh64x64(v *Value) bool {
+func rewriteValueARM64_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x64 x (MOVDconst [c]))
@@ -12412,7 +12440,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh64x8(v *Value) bool {
+func rewriteValueARM64_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12443,7 +12471,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh8x16(v *Value) bool {
+func rewriteValueARM64_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12474,7 +12502,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh8x32(v *Value) bool {
+func rewriteValueARM64_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12505,7 +12533,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh8x64(v *Value) bool {
+func rewriteValueARM64_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x64 x (MOVDconst [c]))
@@ -12564,7 +12592,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpLsh8x8(v *Value) bool {
+func rewriteValueARM64_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12595,7 +12623,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod16(v *Value) bool {
+func rewriteValueARM64_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12616,7 +12644,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod16u(v *Value) bool {
+func rewriteValueARM64_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12637,7 +12665,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod32(v *Value) bool {
+func rewriteValueARM64_OpMod32_0(v *Value) bool {
 	// match: (Mod32 x y)
 	// cond:
 	// result: (MODW x y)
@@ -12650,7 +12678,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod32u(v *Value) bool {
+func rewriteValueARM64_OpMod32u_0(v *Value) bool {
 	// match: (Mod32u x y)
 	// cond:
 	// result: (UMODW x y)
@@ -12663,7 +12691,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod64(v *Value) bool {
+func rewriteValueARM64_OpMod64_0(v *Value) bool {
 	// match: (Mod64 x y)
 	// cond:
 	// result: (MOD x y)
@@ -12676,7 +12704,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod64u(v *Value) bool {
+func rewriteValueARM64_OpMod64u_0(v *Value) bool {
 	// match: (Mod64u x y)
 	// cond:
 	// result: (UMOD x y)
@@ -12689,7 +12717,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod8(v *Value) bool {
+func rewriteValueARM64_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12710,7 +12738,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMod8u(v *Value) bool {
+func rewriteValueARM64_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12731,11 +12759,9 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMove(v *Value) bool {
+func rewriteValueARM64_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Move [0] _ _ mem)
@@ -12976,6 +13002,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [16] dst src mem)
 	// cond:
 	// result: (MOVDstore [8] dst (MOVDload [8] src mem) 		(MOVDstore dst (MOVDload src mem) mem))
@@ -13111,7 +13146,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpMul16(v *Value) bool {
+func rewriteValueARM64_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MULW x y)
@@ -13124,7 +13159,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMul32(v *Value) bool {
+func rewriteValueARM64_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MULW x y)
@@ -13137,7 +13172,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMul32F(v *Value) bool {
+func rewriteValueARM64_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (FMULS x y)
@@ -13150,7 +13185,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMul64(v *Value) bool {
+func rewriteValueARM64_OpMul64_0(v *Value) bool {
 	// match: (Mul64 x y)
 	// cond:
 	// result: (MUL x y)
@@ -13163,7 +13198,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMul64F(v *Value) bool {
+func rewriteValueARM64_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (FMULD x y)
@@ -13176,7 +13211,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpMul8(v *Value) bool {
+func rewriteValueARM64_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MULW x y)
@@ -13189,7 +13224,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg16(v *Value) bool {
+func rewriteValueARM64_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEG x)
@@ -13200,7 +13235,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg32(v *Value) bool {
+func rewriteValueARM64_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEG x)
@@ -13211,7 +13246,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg32F(v *Value) bool {
+func rewriteValueARM64_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (FNEGS x)
@@ -13222,7 +13257,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg64(v *Value) bool {
+func rewriteValueARM64_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 x)
 	// cond:
 	// result: (NEG x)
@@ -13233,7 +13268,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg64F(v *Value) bool {
+func rewriteValueARM64_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (FNEGD x)
@@ -13244,7 +13279,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeg8(v *Value) bool {
+func rewriteValueARM64_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEG x)
@@ -13255,7 +13290,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq16(v *Value) bool {
+func rewriteValueARM64_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13278,7 +13313,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq32(v *Value) bool {
+func rewriteValueARM64_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x y)
@@ -13295,7 +13330,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq32F(v *Value) bool {
+func rewriteValueARM64_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -13312,7 +13347,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq64(v *Value) bool {
+func rewriteValueARM64_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64 x y)
@@ -13329,7 +13364,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq64F(v *Value) bool {
+func rewriteValueARM64_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -13346,7 +13381,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeq8(v *Value) bool {
+func rewriteValueARM64_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13369,7 +13404,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeqB(v *Value) bool {
+func rewriteValueARM64_OpNeqB_0(v *Value) bool {
 	// match: (NeqB x y)
 	// cond:
 	// result: (XOR x y)
@@ -13382,7 +13417,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNeqPtr(v *Value) bool {
+func rewriteValueARM64_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqPtr x y)
@@ -13399,7 +13434,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNilCheck(v *Value) bool {
+func rewriteValueARM64_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -13412,7 +13447,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpNot(v *Value) bool {
+func rewriteValueARM64_OpNot_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13430,7 +13465,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOffPtr(v *Value) bool {
+func rewriteValueARM64_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr [off] ptr:(SP))
 	// cond:
 	// result: (MOVDaddr [off] ptr)
@@ -13457,7 +13492,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOr16(v *Value) bool {
+func rewriteValueARM64_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (OR x y)
@@ -13470,7 +13505,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOr32(v *Value) bool {
+func rewriteValueARM64_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (OR x y)
@@ -13483,7 +13518,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOr64(v *Value) bool {
+func rewriteValueARM64_OpOr64_0(v *Value) bool {
 	// match: (Or64 x y)
 	// cond:
 	// result: (OR x y)
@@ -13496,7 +13531,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOr8(v *Value) bool {
+func rewriteValueARM64_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (OR x y)
@@ -13509,7 +13544,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpOrB(v *Value) bool {
+func rewriteValueARM64_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (OR x y)
@@ -13522,7 +13557,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRound32F(v *Value) bool {
+func rewriteValueARM64_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -13534,7 +13569,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRound64F(v *Value) bool {
+func rewriteValueARM64_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -13546,7 +13581,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13579,7 +13614,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13612,7 +13647,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13677,7 +13712,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13710,7 +13745,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16x16(v *Value) bool {
+func rewriteValueARM64_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13742,7 +13777,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16x32(v *Value) bool {
+func rewriteValueARM64_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13774,7 +13809,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16x64(v *Value) bool {
+func rewriteValueARM64_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13842,7 +13877,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh16x8(v *Value) bool {
+func rewriteValueARM64_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13874,7 +13909,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13907,7 +13942,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13940,7 +13975,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14005,7 +14040,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14038,7 +14073,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32x16(v *Value) bool {
+func rewriteValueARM64_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14070,7 +14105,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32x32(v *Value) bool {
+func rewriteValueARM64_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14102,7 +14137,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32x64(v *Value) bool {
+func rewriteValueARM64_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14170,7 +14205,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh32x8(v *Value) bool {
+func rewriteValueARM64_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14202,7 +14237,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14233,7 +14268,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14264,7 +14299,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux64 x (MOVDconst [c]))
@@ -14323,7 +14358,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14354,7 +14389,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64x16(v *Value) bool {
+func rewriteValueARM64_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14384,7 +14419,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64x32(v *Value) bool {
+func rewriteValueARM64_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14414,7 +14449,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64x64(v *Value) bool {
+func rewriteValueARM64_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x64 x (MOVDconst [c]))
@@ -14474,7 +14509,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh64x8(v *Value) bool {
+func rewriteValueARM64_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14504,7 +14539,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14537,7 +14572,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14570,7 +14605,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14635,7 +14670,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14668,7 +14703,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8x16(v *Value) bool {
+func rewriteValueARM64_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14700,7 +14735,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8x32(v *Value) bool {
+func rewriteValueARM64_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14732,7 +14767,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8x64(v *Value) bool {
+func rewriteValueARM64_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14800,7 +14835,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpRsh8x8(v *Value) bool {
+func rewriteValueARM64_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14832,7 +14867,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -14843,7 +14878,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt16to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -14854,7 +14889,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt32to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 x)
 	// cond:
 	// result: (MOVWreg x)
@@ -14865,7 +14900,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -14876,7 +14911,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -14887,7 +14922,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSignExt8to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -14898,7 +14933,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSlicemask(v *Value) bool {
+func rewriteValueARM64_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -14915,7 +14950,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSqrt(v *Value) bool {
+func rewriteValueARM64_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (FSQRTD x)
@@ -14926,7 +14961,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpStaticCall(v *Value) bool {
+func rewriteValueARM64_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -14941,7 +14976,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpStore(v *Value) bool {
+func rewriteValueARM64_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 1
 	// result: (MOVBstore ptr val mem)
@@ -15046,7 +15081,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpSub16(v *Value) bool {
+func rewriteValueARM64_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUB x y)
@@ -15059,7 +15094,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSub32(v *Value) bool {
+func rewriteValueARM64_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUB x y)
@@ -15072,7 +15107,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSub32F(v *Value) bool {
+func rewriteValueARM64_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (FSUBS x y)
@@ -15085,7 +15120,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSub64(v *Value) bool {
+func rewriteValueARM64_OpSub64_0(v *Value) bool {
 	// match: (Sub64 x y)
 	// cond:
 	// result: (SUB x y)
@@ -15098,7 +15133,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSub64F(v *Value) bool {
+func rewriteValueARM64_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (FSUBD x y)
@@ -15111,7 +15146,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSub8(v *Value) bool {
+func rewriteValueARM64_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUB x y)
@@ -15124,7 +15159,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpSubPtr(v *Value) bool {
+func rewriteValueARM64_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUB x y)
@@ -15137,7 +15172,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -15149,7 +15184,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -15161,7 +15196,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -15173,7 +15208,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc64to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 x)
 	// cond:
 	// result: x
@@ -15185,7 +15220,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc64to32(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 x)
 	// cond:
 	// result: x
@@ -15197,7 +15232,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpTrunc64to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 x)
 	// cond:
 	// result: x
@@ -15209,7 +15244,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpXor16(v *Value) bool {
+func rewriteValueARM64_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XOR x y)
@@ -15222,7 +15257,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpXor32(v *Value) bool {
+func rewriteValueARM64_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XOR x y)
@@ -15235,7 +15270,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpXor64(v *Value) bool {
+func rewriteValueARM64_OpXor64_0(v *Value) bool {
 	// match: (Xor64 x y)
 	// cond:
 	// result: (XOR x y)
@@ -15248,7 +15283,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpXor8(v *Value) bool {
+func rewriteValueARM64_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XOR x y)
@@ -15261,11 +15296,9 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZero(v *Value) bool {
+func rewriteValueARM64_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Zero [0] _ mem)
@@ -15476,6 +15509,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueARM64_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Zero [16] ptr mem)
 	// cond:
 	// result: (MOVDstore [8] ptr (MOVDconst [0]) 		(MOVDstore ptr (MOVDconst [0]) mem))
@@ -15591,7 +15633,7 @@
 	}
 	return false
 }
-func rewriteValueARM64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -15602,7 +15644,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -15613,7 +15655,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 x)
 	// cond:
 	// result: (MOVWUreg x)
@@ -15624,7 +15666,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -15635,7 +15677,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -15646,7 +15688,7 @@
 		return true
 	}
 }
-func rewriteValueARM64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 x)
 	// cond:
 	// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 64a6ddf..bed923b 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -14,499 +14,499 @@
 func rewriteValueMIPS(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValueMIPS_OpAdd16(v)
+		return rewriteValueMIPS_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueMIPS_OpAdd32(v)
+		return rewriteValueMIPS_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueMIPS_OpAdd32F(v)
+		return rewriteValueMIPS_OpAdd32F_0(v)
 	case OpAdd32withcarry:
-		return rewriteValueMIPS_OpAdd32withcarry(v)
+		return rewriteValueMIPS_OpAdd32withcarry_0(v)
 	case OpAdd64F:
-		return rewriteValueMIPS_OpAdd64F(v)
+		return rewriteValueMIPS_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueMIPS_OpAdd8(v)
+		return rewriteValueMIPS_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueMIPS_OpAddPtr(v)
+		return rewriteValueMIPS_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueMIPS_OpAddr(v)
+		return rewriteValueMIPS_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueMIPS_OpAnd16(v)
+		return rewriteValueMIPS_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueMIPS_OpAnd32(v)
+		return rewriteValueMIPS_OpAnd32_0(v)
 	case OpAnd8:
-		return rewriteValueMIPS_OpAnd8(v)
+		return rewriteValueMIPS_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueMIPS_OpAndB(v)
+		return rewriteValueMIPS_OpAndB_0(v)
 	case OpAtomicAdd32:
-		return rewriteValueMIPS_OpAtomicAdd32(v)
+		return rewriteValueMIPS_OpAtomicAdd32_0(v)
 	case OpAtomicAnd8:
-		return rewriteValueMIPS_OpAtomicAnd8(v)
+		return rewriteValueMIPS_OpAtomicAnd8_0(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
+		return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v)
 	case OpAtomicExchange32:
-		return rewriteValueMIPS_OpAtomicExchange32(v)
+		return rewriteValueMIPS_OpAtomicExchange32_0(v)
 	case OpAtomicLoad32:
-		return rewriteValueMIPS_OpAtomicLoad32(v)
+		return rewriteValueMIPS_OpAtomicLoad32_0(v)
 	case OpAtomicLoadPtr:
-		return rewriteValueMIPS_OpAtomicLoadPtr(v)
+		return rewriteValueMIPS_OpAtomicLoadPtr_0(v)
 	case OpAtomicOr8:
-		return rewriteValueMIPS_OpAtomicOr8(v)
+		return rewriteValueMIPS_OpAtomicOr8_0(v)
 	case OpAtomicStore32:
-		return rewriteValueMIPS_OpAtomicStore32(v)
+		return rewriteValueMIPS_OpAtomicStore32_0(v)
 	case OpAtomicStorePtrNoWB:
-		return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
+		return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v)
 	case OpAvg32u:
-		return rewriteValueMIPS_OpAvg32u(v)
+		return rewriteValueMIPS_OpAvg32u_0(v)
 	case OpBitLen32:
-		return rewriteValueMIPS_OpBitLen32(v)
+		return rewriteValueMIPS_OpBitLen32_0(v)
 	case OpClosureCall:
-		return rewriteValueMIPS_OpClosureCall(v)
+		return rewriteValueMIPS_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueMIPS_OpCom16(v)
+		return rewriteValueMIPS_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueMIPS_OpCom32(v)
+		return rewriteValueMIPS_OpCom32_0(v)
 	case OpCom8:
-		return rewriteValueMIPS_OpCom8(v)
+		return rewriteValueMIPS_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueMIPS_OpConst16(v)
+		return rewriteValueMIPS_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueMIPS_OpConst32(v)
+		return rewriteValueMIPS_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueMIPS_OpConst32F(v)
+		return rewriteValueMIPS_OpConst32F_0(v)
 	case OpConst64F:
-		return rewriteValueMIPS_OpConst64F(v)
+		return rewriteValueMIPS_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueMIPS_OpConst8(v)
+		return rewriteValueMIPS_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueMIPS_OpConstBool(v)
+		return rewriteValueMIPS_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueMIPS_OpConstNil(v)
+		return rewriteValueMIPS_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueMIPS_OpConvert(v)
+		return rewriteValueMIPS_OpConvert_0(v)
 	case OpCtz32:
-		return rewriteValueMIPS_OpCtz32(v)
+		return rewriteValueMIPS_OpCtz32_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueMIPS_OpCvt32Fto32(v)
+		return rewriteValueMIPS_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueMIPS_OpCvt32Fto64F(v)
+		return rewriteValueMIPS_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueMIPS_OpCvt32to32F(v)
+		return rewriteValueMIPS_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueMIPS_OpCvt32to64F(v)
+		return rewriteValueMIPS_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueMIPS_OpCvt64Fto32(v)
+		return rewriteValueMIPS_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueMIPS_OpCvt64Fto32F(v)
+		return rewriteValueMIPS_OpCvt64Fto32F_0(v)
 	case OpDiv16:
-		return rewriteValueMIPS_OpDiv16(v)
+		return rewriteValueMIPS_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueMIPS_OpDiv16u(v)
+		return rewriteValueMIPS_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueMIPS_OpDiv32(v)
+		return rewriteValueMIPS_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueMIPS_OpDiv32F(v)
+		return rewriteValueMIPS_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueMIPS_OpDiv32u(v)
+		return rewriteValueMIPS_OpDiv32u_0(v)
 	case OpDiv64F:
-		return rewriteValueMIPS_OpDiv64F(v)
+		return rewriteValueMIPS_OpDiv64F_0(v)
 	case OpDiv8:
-		return rewriteValueMIPS_OpDiv8(v)
+		return rewriteValueMIPS_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueMIPS_OpDiv8u(v)
+		return rewriteValueMIPS_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueMIPS_OpEq16(v)
+		return rewriteValueMIPS_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueMIPS_OpEq32(v)
+		return rewriteValueMIPS_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueMIPS_OpEq32F(v)
+		return rewriteValueMIPS_OpEq32F_0(v)
 	case OpEq64F:
-		return rewriteValueMIPS_OpEq64F(v)
+		return rewriteValueMIPS_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueMIPS_OpEq8(v)
+		return rewriteValueMIPS_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueMIPS_OpEqB(v)
+		return rewriteValueMIPS_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueMIPS_OpEqPtr(v)
+		return rewriteValueMIPS_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueMIPS_OpGeq16(v)
+		return rewriteValueMIPS_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueMIPS_OpGeq16U(v)
+		return rewriteValueMIPS_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueMIPS_OpGeq32(v)
+		return rewriteValueMIPS_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueMIPS_OpGeq32F(v)
+		return rewriteValueMIPS_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueMIPS_OpGeq32U(v)
+		return rewriteValueMIPS_OpGeq32U_0(v)
 	case OpGeq64F:
-		return rewriteValueMIPS_OpGeq64F(v)
+		return rewriteValueMIPS_OpGeq64F_0(v)
 	case OpGeq8:
-		return rewriteValueMIPS_OpGeq8(v)
+		return rewriteValueMIPS_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueMIPS_OpGeq8U(v)
+		return rewriteValueMIPS_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueMIPS_OpGetClosurePtr(v)
+		return rewriteValueMIPS_OpGetClosurePtr_0(v)
 	case OpGreater16:
-		return rewriteValueMIPS_OpGreater16(v)
+		return rewriteValueMIPS_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueMIPS_OpGreater16U(v)
+		return rewriteValueMIPS_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueMIPS_OpGreater32(v)
+		return rewriteValueMIPS_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueMIPS_OpGreater32F(v)
+		return rewriteValueMIPS_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueMIPS_OpGreater32U(v)
+		return rewriteValueMIPS_OpGreater32U_0(v)
 	case OpGreater64F:
-		return rewriteValueMIPS_OpGreater64F(v)
+		return rewriteValueMIPS_OpGreater64F_0(v)
 	case OpGreater8:
-		return rewriteValueMIPS_OpGreater8(v)
+		return rewriteValueMIPS_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueMIPS_OpGreater8U(v)
+		return rewriteValueMIPS_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueMIPS_OpHmul32(v)
+		return rewriteValueMIPS_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueMIPS_OpHmul32u(v)
+		return rewriteValueMIPS_OpHmul32u_0(v)
 	case OpInterCall:
-		return rewriteValueMIPS_OpInterCall(v)
+		return rewriteValueMIPS_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueMIPS_OpIsInBounds(v)
+		return rewriteValueMIPS_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueMIPS_OpIsNonNil(v)
+		return rewriteValueMIPS_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueMIPS_OpIsSliceInBounds(v)
+		return rewriteValueMIPS_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueMIPS_OpLeq16(v)
+		return rewriteValueMIPS_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueMIPS_OpLeq16U(v)
+		return rewriteValueMIPS_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueMIPS_OpLeq32(v)
+		return rewriteValueMIPS_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueMIPS_OpLeq32F(v)
+		return rewriteValueMIPS_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueMIPS_OpLeq32U(v)
+		return rewriteValueMIPS_OpLeq32U_0(v)
 	case OpLeq64F:
-		return rewriteValueMIPS_OpLeq64F(v)
+		return rewriteValueMIPS_OpLeq64F_0(v)
 	case OpLeq8:
-		return rewriteValueMIPS_OpLeq8(v)
+		return rewriteValueMIPS_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueMIPS_OpLeq8U(v)
+		return rewriteValueMIPS_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueMIPS_OpLess16(v)
+		return rewriteValueMIPS_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueMIPS_OpLess16U(v)
+		return rewriteValueMIPS_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueMIPS_OpLess32(v)
+		return rewriteValueMIPS_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueMIPS_OpLess32F(v)
+		return rewriteValueMIPS_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueMIPS_OpLess32U(v)
+		return rewriteValueMIPS_OpLess32U_0(v)
 	case OpLess64F:
-		return rewriteValueMIPS_OpLess64F(v)
+		return rewriteValueMIPS_OpLess64F_0(v)
 	case OpLess8:
-		return rewriteValueMIPS_OpLess8(v)
+		return rewriteValueMIPS_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueMIPS_OpLess8U(v)
+		return rewriteValueMIPS_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueMIPS_OpLoad(v)
+		return rewriteValueMIPS_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueMIPS_OpLsh16x16(v)
+		return rewriteValueMIPS_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueMIPS_OpLsh16x32(v)
+		return rewriteValueMIPS_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueMIPS_OpLsh16x64(v)
+		return rewriteValueMIPS_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueMIPS_OpLsh16x8(v)
+		return rewriteValueMIPS_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueMIPS_OpLsh32x16(v)
+		return rewriteValueMIPS_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueMIPS_OpLsh32x32(v)
+		return rewriteValueMIPS_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueMIPS_OpLsh32x64(v)
+		return rewriteValueMIPS_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueMIPS_OpLsh32x8(v)
+		return rewriteValueMIPS_OpLsh32x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueMIPS_OpLsh8x16(v)
+		return rewriteValueMIPS_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueMIPS_OpLsh8x32(v)
+		return rewriteValueMIPS_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueMIPS_OpLsh8x64(v)
+		return rewriteValueMIPS_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueMIPS_OpLsh8x8(v)
+		return rewriteValueMIPS_OpLsh8x8_0(v)
 	case OpMIPSADD:
-		return rewriteValueMIPS_OpMIPSADD(v)
+		return rewriteValueMIPS_OpMIPSADD_0(v)
 	case OpMIPSADDconst:
-		return rewriteValueMIPS_OpMIPSADDconst(v)
+		return rewriteValueMIPS_OpMIPSADDconst_0(v)
 	case OpMIPSAND:
-		return rewriteValueMIPS_OpMIPSAND(v)
+		return rewriteValueMIPS_OpMIPSAND_0(v)
 	case OpMIPSANDconst:
-		return rewriteValueMIPS_OpMIPSANDconst(v)
+		return rewriteValueMIPS_OpMIPSANDconst_0(v)
 	case OpMIPSCMOVZ:
-		return rewriteValueMIPS_OpMIPSCMOVZ(v)
+		return rewriteValueMIPS_OpMIPSCMOVZ_0(v)
 	case OpMIPSCMOVZzero:
-		return rewriteValueMIPS_OpMIPSCMOVZzero(v)
+		return rewriteValueMIPS_OpMIPSCMOVZzero_0(v)
 	case OpMIPSLoweredAtomicAdd:
-		return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
+		return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v)
 	case OpMIPSLoweredAtomicStore:
-		return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v)
+		return rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v)
 	case OpMIPSMOVBUload:
-		return rewriteValueMIPS_OpMIPSMOVBUload(v)
+		return rewriteValueMIPS_OpMIPSMOVBUload_0(v)
 	case OpMIPSMOVBUreg:
-		return rewriteValueMIPS_OpMIPSMOVBUreg(v)
+		return rewriteValueMIPS_OpMIPSMOVBUreg_0(v)
 	case OpMIPSMOVBload:
-		return rewriteValueMIPS_OpMIPSMOVBload(v)
+		return rewriteValueMIPS_OpMIPSMOVBload_0(v)
 	case OpMIPSMOVBreg:
-		return rewriteValueMIPS_OpMIPSMOVBreg(v)
+		return rewriteValueMIPS_OpMIPSMOVBreg_0(v)
 	case OpMIPSMOVBstore:
-		return rewriteValueMIPS_OpMIPSMOVBstore(v)
+		return rewriteValueMIPS_OpMIPSMOVBstore_0(v)
 	case OpMIPSMOVBstorezero:
-		return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
+		return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v)
 	case OpMIPSMOVDload:
-		return rewriteValueMIPS_OpMIPSMOVDload(v)
+		return rewriteValueMIPS_OpMIPSMOVDload_0(v)
 	case OpMIPSMOVDstore:
-		return rewriteValueMIPS_OpMIPSMOVDstore(v)
+		return rewriteValueMIPS_OpMIPSMOVDstore_0(v)
 	case OpMIPSMOVFload:
-		return rewriteValueMIPS_OpMIPSMOVFload(v)
+		return rewriteValueMIPS_OpMIPSMOVFload_0(v)
 	case OpMIPSMOVFstore:
-		return rewriteValueMIPS_OpMIPSMOVFstore(v)
+		return rewriteValueMIPS_OpMIPSMOVFstore_0(v)
 	case OpMIPSMOVHUload:
-		return rewriteValueMIPS_OpMIPSMOVHUload(v)
+		return rewriteValueMIPS_OpMIPSMOVHUload_0(v)
 	case OpMIPSMOVHUreg:
-		return rewriteValueMIPS_OpMIPSMOVHUreg(v)
+		return rewriteValueMIPS_OpMIPSMOVHUreg_0(v)
 	case OpMIPSMOVHload:
-		return rewriteValueMIPS_OpMIPSMOVHload(v)
+		return rewriteValueMIPS_OpMIPSMOVHload_0(v)
 	case OpMIPSMOVHreg:
-		return rewriteValueMIPS_OpMIPSMOVHreg(v)
+		return rewriteValueMIPS_OpMIPSMOVHreg_0(v)
 	case OpMIPSMOVHstore:
-		return rewriteValueMIPS_OpMIPSMOVHstore(v)
+		return rewriteValueMIPS_OpMIPSMOVHstore_0(v)
 	case OpMIPSMOVHstorezero:
-		return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
+		return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v)
 	case OpMIPSMOVWload:
-		return rewriteValueMIPS_OpMIPSMOVWload(v)
+		return rewriteValueMIPS_OpMIPSMOVWload_0(v)
 	case OpMIPSMOVWreg:
-		return rewriteValueMIPS_OpMIPSMOVWreg(v)
+		return rewriteValueMIPS_OpMIPSMOVWreg_0(v)
 	case OpMIPSMOVWstore:
-		return rewriteValueMIPS_OpMIPSMOVWstore(v)
+		return rewriteValueMIPS_OpMIPSMOVWstore_0(v)
 	case OpMIPSMOVWstorezero:
-		return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
+		return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v)
 	case OpMIPSMUL:
-		return rewriteValueMIPS_OpMIPSMUL(v)
+		return rewriteValueMIPS_OpMIPSMUL_0(v)
 	case OpMIPSNEG:
-		return rewriteValueMIPS_OpMIPSNEG(v)
+		return rewriteValueMIPS_OpMIPSNEG_0(v)
 	case OpMIPSNOR:
-		return rewriteValueMIPS_OpMIPSNOR(v)
+		return rewriteValueMIPS_OpMIPSNOR_0(v)
 	case OpMIPSNORconst:
-		return rewriteValueMIPS_OpMIPSNORconst(v)
+		return rewriteValueMIPS_OpMIPSNORconst_0(v)
 	case OpMIPSOR:
-		return rewriteValueMIPS_OpMIPSOR(v)
+		return rewriteValueMIPS_OpMIPSOR_0(v)
 	case OpMIPSORconst:
-		return rewriteValueMIPS_OpMIPSORconst(v)
+		return rewriteValueMIPS_OpMIPSORconst_0(v)
 	case OpMIPSSGT:
-		return rewriteValueMIPS_OpMIPSSGT(v)
+		return rewriteValueMIPS_OpMIPSSGT_0(v)
 	case OpMIPSSGTU:
-		return rewriteValueMIPS_OpMIPSSGTU(v)
+		return rewriteValueMIPS_OpMIPSSGTU_0(v)
 	case OpMIPSSGTUconst:
-		return rewriteValueMIPS_OpMIPSSGTUconst(v)
+		return rewriteValueMIPS_OpMIPSSGTUconst_0(v)
 	case OpMIPSSGTUzero:
-		return rewriteValueMIPS_OpMIPSSGTUzero(v)
+		return rewriteValueMIPS_OpMIPSSGTUzero_0(v)
 	case OpMIPSSGTconst:
-		return rewriteValueMIPS_OpMIPSSGTconst(v)
+		return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v)
 	case OpMIPSSGTzero:
-		return rewriteValueMIPS_OpMIPSSGTzero(v)
+		return rewriteValueMIPS_OpMIPSSGTzero_0(v)
 	case OpMIPSSLL:
-		return rewriteValueMIPS_OpMIPSSLL(v)
+		return rewriteValueMIPS_OpMIPSSLL_0(v)
 	case OpMIPSSLLconst:
-		return rewriteValueMIPS_OpMIPSSLLconst(v)
+		return rewriteValueMIPS_OpMIPSSLLconst_0(v)
 	case OpMIPSSRA:
-		return rewriteValueMIPS_OpMIPSSRA(v)
+		return rewriteValueMIPS_OpMIPSSRA_0(v)
 	case OpMIPSSRAconst:
-		return rewriteValueMIPS_OpMIPSSRAconst(v)
+		return rewriteValueMIPS_OpMIPSSRAconst_0(v)
 	case OpMIPSSRL:
-		return rewriteValueMIPS_OpMIPSSRL(v)
+		return rewriteValueMIPS_OpMIPSSRL_0(v)
 	case OpMIPSSRLconst:
-		return rewriteValueMIPS_OpMIPSSRLconst(v)
+		return rewriteValueMIPS_OpMIPSSRLconst_0(v)
 	case OpMIPSSUB:
-		return rewriteValueMIPS_OpMIPSSUB(v)
+		return rewriteValueMIPS_OpMIPSSUB_0(v)
 	case OpMIPSSUBconst:
-		return rewriteValueMIPS_OpMIPSSUBconst(v)
+		return rewriteValueMIPS_OpMIPSSUBconst_0(v)
 	case OpMIPSXOR:
-		return rewriteValueMIPS_OpMIPSXOR(v)
+		return rewriteValueMIPS_OpMIPSXOR_0(v)
 	case OpMIPSXORconst:
-		return rewriteValueMIPS_OpMIPSXORconst(v)
+		return rewriteValueMIPS_OpMIPSXORconst_0(v)
 	case OpMod16:
-		return rewriteValueMIPS_OpMod16(v)
+		return rewriteValueMIPS_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueMIPS_OpMod16u(v)
+		return rewriteValueMIPS_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueMIPS_OpMod32(v)
+		return rewriteValueMIPS_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueMIPS_OpMod32u(v)
+		return rewriteValueMIPS_OpMod32u_0(v)
 	case OpMod8:
-		return rewriteValueMIPS_OpMod8(v)
+		return rewriteValueMIPS_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueMIPS_OpMod8u(v)
+		return rewriteValueMIPS_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueMIPS_OpMove(v)
+		return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v)
 	case OpMul16:
-		return rewriteValueMIPS_OpMul16(v)
+		return rewriteValueMIPS_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueMIPS_OpMul32(v)
+		return rewriteValueMIPS_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueMIPS_OpMul32F(v)
+		return rewriteValueMIPS_OpMul32F_0(v)
 	case OpMul32uhilo:
-		return rewriteValueMIPS_OpMul32uhilo(v)
+		return rewriteValueMIPS_OpMul32uhilo_0(v)
 	case OpMul64F:
-		return rewriteValueMIPS_OpMul64F(v)
+		return rewriteValueMIPS_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValueMIPS_OpMul8(v)
+		return rewriteValueMIPS_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueMIPS_OpNeg16(v)
+		return rewriteValueMIPS_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueMIPS_OpNeg32(v)
+		return rewriteValueMIPS_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueMIPS_OpNeg32F(v)
+		return rewriteValueMIPS_OpNeg32F_0(v)
 	case OpNeg64F:
-		return rewriteValueMIPS_OpNeg64F(v)
+		return rewriteValueMIPS_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueMIPS_OpNeg8(v)
+		return rewriteValueMIPS_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueMIPS_OpNeq16(v)
+		return rewriteValueMIPS_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueMIPS_OpNeq32(v)
+		return rewriteValueMIPS_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueMIPS_OpNeq32F(v)
+		return rewriteValueMIPS_OpNeq32F_0(v)
 	case OpNeq64F:
-		return rewriteValueMIPS_OpNeq64F(v)
+		return rewriteValueMIPS_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueMIPS_OpNeq8(v)
+		return rewriteValueMIPS_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueMIPS_OpNeqB(v)
+		return rewriteValueMIPS_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueMIPS_OpNeqPtr(v)
+		return rewriteValueMIPS_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueMIPS_OpNilCheck(v)
+		return rewriteValueMIPS_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueMIPS_OpNot(v)
+		return rewriteValueMIPS_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueMIPS_OpOffPtr(v)
+		return rewriteValueMIPS_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueMIPS_OpOr16(v)
+		return rewriteValueMIPS_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueMIPS_OpOr32(v)
+		return rewriteValueMIPS_OpOr32_0(v)
 	case OpOr8:
-		return rewriteValueMIPS_OpOr8(v)
+		return rewriteValueMIPS_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueMIPS_OpOrB(v)
+		return rewriteValueMIPS_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValueMIPS_OpRound32F(v)
+		return rewriteValueMIPS_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueMIPS_OpRound64F(v)
+		return rewriteValueMIPS_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueMIPS_OpRsh16Ux16(v)
+		return rewriteValueMIPS_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueMIPS_OpRsh16Ux32(v)
+		return rewriteValueMIPS_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueMIPS_OpRsh16Ux64(v)
+		return rewriteValueMIPS_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueMIPS_OpRsh16Ux8(v)
+		return rewriteValueMIPS_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueMIPS_OpRsh16x16(v)
+		return rewriteValueMIPS_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueMIPS_OpRsh16x32(v)
+		return rewriteValueMIPS_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueMIPS_OpRsh16x64(v)
+		return rewriteValueMIPS_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueMIPS_OpRsh16x8(v)
+		return rewriteValueMIPS_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueMIPS_OpRsh32Ux16(v)
+		return rewriteValueMIPS_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueMIPS_OpRsh32Ux32(v)
+		return rewriteValueMIPS_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueMIPS_OpRsh32Ux64(v)
+		return rewriteValueMIPS_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueMIPS_OpRsh32Ux8(v)
+		return rewriteValueMIPS_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueMIPS_OpRsh32x16(v)
+		return rewriteValueMIPS_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueMIPS_OpRsh32x32(v)
+		return rewriteValueMIPS_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueMIPS_OpRsh32x64(v)
+		return rewriteValueMIPS_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueMIPS_OpRsh32x8(v)
+		return rewriteValueMIPS_OpRsh32x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueMIPS_OpRsh8Ux16(v)
+		return rewriteValueMIPS_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueMIPS_OpRsh8Ux32(v)
+		return rewriteValueMIPS_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueMIPS_OpRsh8Ux64(v)
+		return rewriteValueMIPS_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueMIPS_OpRsh8Ux8(v)
+		return rewriteValueMIPS_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueMIPS_OpRsh8x16(v)
+		return rewriteValueMIPS_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueMIPS_OpRsh8x32(v)
+		return rewriteValueMIPS_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueMIPS_OpRsh8x64(v)
+		return rewriteValueMIPS_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueMIPS_OpRsh8x8(v)
+		return rewriteValueMIPS_OpRsh8x8_0(v)
 	case OpSelect0:
-		return rewriteValueMIPS_OpSelect0(v)
+		return rewriteValueMIPS_OpSelect0_0(v) || rewriteValueMIPS_OpSelect0_10(v)
 	case OpSelect1:
-		return rewriteValueMIPS_OpSelect1(v)
+		return rewriteValueMIPS_OpSelect1_0(v) || rewriteValueMIPS_OpSelect1_10(v)
 	case OpSignExt16to32:
-		return rewriteValueMIPS_OpSignExt16to32(v)
+		return rewriteValueMIPS_OpSignExt16to32_0(v)
 	case OpSignExt8to16:
-		return rewriteValueMIPS_OpSignExt8to16(v)
+		return rewriteValueMIPS_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueMIPS_OpSignExt8to32(v)
+		return rewriteValueMIPS_OpSignExt8to32_0(v)
 	case OpSignmask:
-		return rewriteValueMIPS_OpSignmask(v)
+		return rewriteValueMIPS_OpSignmask_0(v)
 	case OpSlicemask:
-		return rewriteValueMIPS_OpSlicemask(v)
+		return rewriteValueMIPS_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValueMIPS_OpSqrt(v)
+		return rewriteValueMIPS_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValueMIPS_OpStaticCall(v)
+		return rewriteValueMIPS_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueMIPS_OpStore(v)
+		return rewriteValueMIPS_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueMIPS_OpSub16(v)
+		return rewriteValueMIPS_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueMIPS_OpSub32(v)
+		return rewriteValueMIPS_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueMIPS_OpSub32F(v)
+		return rewriteValueMIPS_OpSub32F_0(v)
 	case OpSub32withcarry:
-		return rewriteValueMIPS_OpSub32withcarry(v)
+		return rewriteValueMIPS_OpSub32withcarry_0(v)
 	case OpSub64F:
-		return rewriteValueMIPS_OpSub64F(v)
+		return rewriteValueMIPS_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueMIPS_OpSub8(v)
+		return rewriteValueMIPS_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueMIPS_OpSubPtr(v)
+		return rewriteValueMIPS_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueMIPS_OpTrunc16to8(v)
+		return rewriteValueMIPS_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueMIPS_OpTrunc32to16(v)
+		return rewriteValueMIPS_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueMIPS_OpTrunc32to8(v)
+		return rewriteValueMIPS_OpTrunc32to8_0(v)
 	case OpXor16:
-		return rewriteValueMIPS_OpXor16(v)
+		return rewriteValueMIPS_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueMIPS_OpXor32(v)
+		return rewriteValueMIPS_OpXor32_0(v)
 	case OpXor8:
-		return rewriteValueMIPS_OpXor8(v)
+		return rewriteValueMIPS_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueMIPS_OpZero(v)
+		return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValueMIPS_OpZeroExt16to32(v)
+		return rewriteValueMIPS_OpZeroExt16to32_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueMIPS_OpZeroExt8to16(v)
+		return rewriteValueMIPS_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueMIPS_OpZeroExt8to32(v)
+		return rewriteValueMIPS_OpZeroExt8to32_0(v)
 	case OpZeromask:
-		return rewriteValueMIPS_OpZeromask(v)
+		return rewriteValueMIPS_OpZeromask_0(v)
 	}
 	return false
 }
-func rewriteValueMIPS_OpAdd16(v *Value) bool {
+func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADD x y)
@@ -519,7 +519,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32(v *Value) bool {
+func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADD x y)
@@ -532,7 +532,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32F(v *Value) bool {
+func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (ADDF x y)
@@ -545,7 +545,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
+func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Add32withcarry <t> x y c)
@@ -565,7 +565,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd64F(v *Value) bool {
+func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (ADDD x y)
@@ -578,7 +578,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAdd8(v *Value) bool {
+func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADD x y)
@@ -591,7 +591,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAddPtr(v *Value) bool {
+func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADD x y)
@@ -604,7 +604,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAddr(v *Value) bool {
+func rewriteValueMIPS_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVWaddr {sym} base)
@@ -617,7 +617,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd16(v *Value) bool {
+func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (AND x y)
@@ -630,7 +630,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd32(v *Value) bool {
+func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (AND x y)
@@ -643,7 +643,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAnd8(v *Value) bool {
+func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (AND x y)
@@ -656,7 +656,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAndB(v *Value) bool {
+func rewriteValueMIPS_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (AND x y)
@@ -669,7 +669,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
 	// match: (AtomicAdd32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAdd ptr val mem)
@@ -684,7 +684,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -797,7 +797,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas ptr old new_ mem)
@@ -814,7 +814,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
 	// match: (AtomicExchange32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange ptr val mem)
@@ -829,7 +829,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
 	// match: (AtomicLoad32 ptr mem)
 	// cond:
 	// result: (LoweredAtomicLoad ptr mem)
@@ -842,7 +842,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
 	// match: (AtomicLoadPtr ptr mem)
 	// cond:
 	// result: (LoweredAtomicLoad  ptr mem)
@@ -855,7 +855,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
+func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -931,7 +931,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
 	// match: (AtomicStore32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicStore ptr val mem)
@@ -946,7 +946,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
 	// match: (AtomicStorePtrNoWB ptr val mem)
 	// cond:
 	// result: (LoweredAtomicStore  ptr val mem)
@@ -961,7 +961,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpAvg32u(v *Value) bool {
+func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg32u <t> x y)
@@ -983,7 +983,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpBitLen32(v *Value) bool {
+func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1004,7 +1004,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpClosureCall(v *Value) bool {
+func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -1021,7 +1021,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom16(v *Value) bool {
+func rewriteValueMIPS_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (NORconst [0] x)
@@ -1033,7 +1033,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom32(v *Value) bool {
+func rewriteValueMIPS_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (NORconst [0] x)
@@ -1045,7 +1045,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCom8(v *Value) bool {
+func rewriteValueMIPS_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (NORconst [0] x)
@@ -1057,7 +1057,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst16(v *Value) bool {
+func rewriteValueMIPS_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -1068,7 +1068,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst32(v *Value) bool {
+func rewriteValueMIPS_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -1079,7 +1079,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst32F(v *Value) bool {
+func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (MOVFconst [val])
@@ -1090,7 +1090,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst64F(v *Value) bool {
+func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1101,7 +1101,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConst8(v *Value) bool {
+func rewriteValueMIPS_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVWconst [val])
@@ -1112,7 +1112,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConstBool(v *Value) bool {
+func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVWconst [b])
@@ -1123,7 +1123,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConstNil(v *Value) bool {
+func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVWconst [0])
@@ -1133,7 +1133,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpConvert(v *Value) bool {
+func rewriteValueMIPS_OpConvert_0(v *Value) bool {
 	// match: (Convert x mem)
 	// cond:
 	// result: (MOVWconvert x mem)
@@ -1146,7 +1146,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCtz32(v *Value) bool {
+func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1175,7 +1175,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (TRUNCFW x)
@@ -1186,7 +1186,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (MOVFD x)
@@ -1197,7 +1197,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (MOVWF x)
@@ -1208,7 +1208,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (MOVWD x)
@@ -1219,7 +1219,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (TRUNCDW x)
@@ -1230,7 +1230,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (MOVDF x)
@@ -1241,7 +1241,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv16(v *Value) bool {
+func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1264,7 +1264,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv16u(v *Value) bool {
+func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1287,7 +1287,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32(v *Value) bool {
+func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1306,7 +1306,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32F(v *Value) bool {
+func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (DIVF x y)
@@ -1319,7 +1319,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv32u(v *Value) bool {
+func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1338,7 +1338,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv64F(v *Value) bool {
+func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (DIVD x y)
@@ -1351,7 +1351,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv8(v *Value) bool {
+func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1374,7 +1374,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpDiv8u(v *Value) bool {
+func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1397,7 +1397,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq16(v *Value) bool {
+func rewriteValueMIPS_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1421,7 +1421,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq32(v *Value) bool {
+func rewriteValueMIPS_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1441,7 +1441,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq32F(v *Value) bool {
+func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -1458,7 +1458,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq64F(v *Value) bool {
+func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -1475,7 +1475,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEq8(v *Value) bool {
+func rewriteValueMIPS_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1499,7 +1499,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEqB(v *Value) bool {
+func rewriteValueMIPS_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1519,7 +1519,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpEqPtr(v *Value) bool {
+func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1539,7 +1539,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq16(v *Value) bool {
+func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1563,7 +1563,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq16U(v *Value) bool {
+func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1587,7 +1587,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32(v *Value) bool {
+func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1607,7 +1607,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32F(v *Value) bool {
+func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -1624,7 +1624,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq32U(v *Value) bool {
+func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1644,7 +1644,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq64F(v *Value) bool {
+func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -1661,7 +1661,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq8(v *Value) bool {
+func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1685,7 +1685,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGeq8U(v *Value) bool {
+func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1709,7 +1709,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -1718,7 +1718,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater16(v *Value) bool {
+func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1739,7 +1739,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater16U(v *Value) bool {
+func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1760,7 +1760,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32(v *Value) bool {
+func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
 	// match: (Greater32 x y)
 	// cond:
 	// result: (SGT x y)
@@ -1773,7 +1773,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32F(v *Value) bool {
+func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -1790,7 +1790,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater32U(v *Value) bool {
+func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
 	// match: (Greater32U x y)
 	// cond:
 	// result: (SGTU x y)
@@ -1803,7 +1803,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater64F(v *Value) bool {
+func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -1820,7 +1820,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater8(v *Value) bool {
+func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1841,7 +1841,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpGreater8U(v *Value) bool {
+func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1862,7 +1862,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpHmul32(v *Value) bool {
+func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1881,7 +1881,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpHmul32u(v *Value) bool {
+func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1900,7 +1900,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpInterCall(v *Value) bool {
+func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -1915,7 +1915,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
+func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
 	// match: (IsInBounds idx len)
 	// cond:
 	// result: (SGTU len idx)
@@ -1928,7 +1928,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
+func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1946,7 +1946,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1966,7 +1966,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq16(v *Value) bool {
+func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1990,7 +1990,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq16U(v *Value) bool {
+func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2014,7 +2014,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32(v *Value) bool {
+func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2034,7 +2034,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32F(v *Value) bool {
+func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -2051,7 +2051,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq32U(v *Value) bool {
+func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2071,7 +2071,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq64F(v *Value) bool {
+func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -2088,7 +2088,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq8(v *Value) bool {
+func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2112,7 +2112,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLeq8U(v *Value) bool {
+func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2136,7 +2136,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess16(v *Value) bool {
+func rewriteValueMIPS_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2157,7 +2157,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess16U(v *Value) bool {
+func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2178,7 +2178,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32(v *Value) bool {
+func rewriteValueMIPS_OpLess32_0(v *Value) bool {
 	// match: (Less32 x y)
 	// cond:
 	// result: (SGT y x)
@@ -2191,7 +2191,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32F(v *Value) bool {
+func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -2208,7 +2208,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess32U(v *Value) bool {
+func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
 	// match: (Less32U x y)
 	// cond:
 	// result: (SGTU y x)
@@ -2221,7 +2221,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess64F(v *Value) bool {
+func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -2238,7 +2238,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess8(v *Value) bool {
+func rewriteValueMIPS_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2259,7 +2259,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLess8U(v *Value) bool {
+func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2280,7 +2280,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLoad(v *Value) bool {
+func rewriteValueMIPS_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: t.IsBoolean()
 	// result: (MOVBUload ptr mem)
@@ -2403,7 +2403,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2434,7 +2434,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2461,7 +2461,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
 	// match: (Lsh16x64 x (Const64 [c]))
 	// cond: uint32(c) < 16
 	// result: (SLLconst x [c])
@@ -2498,7 +2498,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2529,7 +2529,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2560,7 +2560,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2587,7 +2587,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
 	// match: (Lsh32x64 x (Const64 [c]))
 	// cond: uint32(c) < 32
 	// result: (SLLconst x [c])
@@ -2624,7 +2624,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2655,7 +2655,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2686,7 +2686,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2713,7 +2713,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
 	// match: (Lsh8x64 x (Const64 [c]))
 	// cond: uint32(c) < 8
 	// result: (SLLconst x [c])
@@ -2750,7 +2750,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2781,7 +2781,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
 	// match: (ADD x (MOVWconst [c]))
 	// cond:
 	// result: (ADDconst [c] x)
@@ -2844,7 +2844,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
 	// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
 	// cond:
 	// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2924,7 +2924,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
+func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (AND x (MOVWconst [c]))
@@ -3028,7 +3028,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
 	// match: (ANDconst [0] _)
 	// cond:
 	// result: (MOVWconst [0])
@@ -3085,7 +3085,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMOVZ _ b (MOVWconst [0]))
@@ -3143,7 +3143,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
 	// match: (CMOVZzero _ (MOVWconst [0]))
 	// cond:
 	// result: (MOVWconst [0])
@@ -3179,7 +3179,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
 	// match: (LoweredAtomicAdd ptr (MOVWconst [c]) mem)
 	// cond: is16Bit(c)
 	// result: (LoweredAtomicAddconst [c] ptr mem)
@@ -3202,7 +3202,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v *Value) bool {
 	// match: (LoweredAtomicStore ptr (MOVWconst [0]) mem)
 	// cond:
 	// result: (LoweredAtomicStorezero ptr mem)
@@ -3223,7 +3223,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
 	// match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -3296,7 +3296,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBUreg x:(MOVBUload _ _))
@@ -3379,7 +3379,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
 	// match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVBload  [off1+off2] {sym} ptr mem)
@@ -3452,7 +3452,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBreg x:(MOVBload _ _))
@@ -3538,7 +3538,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -3719,7 +3719,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
 	// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
@@ -3769,7 +3769,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
 	// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVDload  [off1+off2] {sym} ptr mem)
@@ -3842,7 +3842,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -3896,7 +3896,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
 	// match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVFload  [off1+off2] {sym} ptr mem)
@@ -3969,7 +3969,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
 	// match: (MOVFstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVFstore [off1+off2] {sym} ptr val mem)
@@ -4023,7 +4023,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
 	// match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -4096,7 +4096,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVHUreg x:(MOVBUload _ _))
@@ -4203,7 +4203,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVHload  [off1+off2] {sym} ptr mem)
@@ -4276,7 +4276,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVHreg x:(MOVBload _ _))
@@ -4410,7 +4410,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -4549,7 +4549,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
 	// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
@@ -4599,7 +4599,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
 	// match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVWload  [off1+off2] {sym} ptr mem)
@@ -4672,7 +4672,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
 	// match: (MOVWreg x)
 	// cond: x.Uses == 1
 	// result: (MOVWnop x)
@@ -4700,7 +4700,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVWstore [off1+off2] {sym} ptr val mem)
@@ -4797,7 +4797,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
 	// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
 	// cond: (is16Bit(off1+off2) || x.Uses == 1)
 	// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
@@ -4847,7 +4847,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
 	// match: (MUL (MOVWconst [0]) _)
 	// cond:
 	// result: (MOVWconst [0])
@@ -5018,7 +5018,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
 	// match: (NEG (MOVWconst [c]))
 	// cond:
 	// result: (MOVWconst [int64(int32(-c))])
@@ -5034,7 +5034,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
 	// match: (NOR x (MOVWconst [c]))
 	// cond:
 	// result: (NORconst [c] x)
@@ -5067,7 +5067,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
 	// match: (NORconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [^(c|d)])
@@ -5084,7 +5084,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (OR x (MOVWconst [c]))
@@ -5174,7 +5174,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
 	// match: (ORconst [0] x)
 	// cond:
 	// result: x
@@ -5231,7 +5231,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
 	// match: (SGT (MOVWconst [c]) x)
 	// cond:
 	// result: (SGTconst  [c] x)
@@ -5265,7 +5265,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
 	// match: (SGTU (MOVWconst [c]) x)
 	// cond:
 	// result: (SGTUconst [c] x)
@@ -5299,7 +5299,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
 	// match: (SGTUconst [c] (MOVWconst [d]))
 	// cond: uint32(c)>uint32(d)
 	// result: (MOVWconst [1])
@@ -5402,7 +5402,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
 	// match: (SGTUzero (MOVWconst [d]))
 	// cond: uint32(d) != 0
 	// result: (MOVWconst [1])
@@ -5437,7 +5437,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
 	// match: (SGTconst [c] (MOVWconst [d]))
 	// cond: int32(c) > int32(d)
 	// result: (MOVWconst [1])
@@ -5600,6 +5600,9 @@
 		v.AuxInt = 0
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
 	// match: (SGTconst [c] (ANDconst [m] _))
 	// cond: 0 <= int32(m) && int32(m) < int32(c)
 	// result: (MOVWconst [1])
@@ -5636,7 +5639,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
 	// match: (SGTzero (MOVWconst [d]))
 	// cond: int32(d) > 0
 	// result: (MOVWconst [1])
@@ -5671,7 +5674,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
 	// match: (SLL _ (MOVWconst [c]))
 	// cond: uint32(c)>=32
 	// result: (MOVWconst [0])
@@ -5705,7 +5708,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
 	// match: (SLLconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))])
@@ -5722,7 +5725,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
 	// match: (SRA x (MOVWconst [c]))
 	// cond: uint32(c)>=32
 	// result: (SRAconst x [31])
@@ -5758,7 +5761,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
 	// match: (SRAconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(int32(d)>>uint32(c))])
@@ -5775,7 +5778,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
 	// match: (SRL _ (MOVWconst [c]))
 	// cond: uint32(c)>=32
 	// result: (MOVWconst [0])
@@ -5809,7 +5812,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
 	// match: (SRLconst [c] (MOVWconst [d]))
 	// cond:
 	// result: (MOVWconst [int64(uint32(d)>>uint32(c))])
@@ -5826,7 +5829,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
 	// match: (SUB x (MOVWconst [c]))
 	// cond:
 	// result: (SUBconst [c] x)
@@ -5872,7 +5875,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
 	// match: (SUBconst [0] x)
 	// cond:
 	// result: x
@@ -5934,7 +5937,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
 	// match: (XOR x (MOVWconst [c]))
 	// cond:
 	// result: (XORconst [c] x)
@@ -5979,7 +5982,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
 	// match: (XORconst [0] x)
 	// cond:
 	// result: x
@@ -6038,7 +6041,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMod16(v *Value) bool {
+func rewriteValueMIPS_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6061,7 +6064,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod16u(v *Value) bool {
+func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6084,7 +6087,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod32(v *Value) bool {
+func rewriteValueMIPS_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6103,7 +6106,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod32u(v *Value) bool {
+func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6122,7 +6125,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod8(v *Value) bool {
+func rewriteValueMIPS_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6145,7 +6148,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMod8u(v *Value) bool {
+func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6168,11 +6171,9 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMove(v *Value) bool {
+func rewriteValueMIPS_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Move [0] _ _ mem)
@@ -6478,6 +6479,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [6] {t} dst src mem)
 	// cond: t.(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)))
@@ -6635,7 +6645,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpMul16(v *Value) bool {
+func rewriteValueMIPS_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MUL x y)
@@ -6648,7 +6658,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32(v *Value) bool {
+func rewriteValueMIPS_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MUL x y)
@@ -6661,7 +6671,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32F(v *Value) bool {
+func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (MULF x y)
@@ -6674,7 +6684,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
+func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
 	// match: (Mul32uhilo x y)
 	// cond:
 	// result: (MULTU x y)
@@ -6687,7 +6697,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul64F(v *Value) bool {
+func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (MULD x y)
@@ -6700,7 +6710,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpMul8(v *Value) bool {
+func rewriteValueMIPS_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MUL x y)
@@ -6713,7 +6723,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg16(v *Value) bool {
+func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEG x)
@@ -6724,7 +6734,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg32(v *Value) bool {
+func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEG x)
@@ -6735,7 +6745,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg32F(v *Value) bool {
+func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (NEGF x)
@@ -6746,7 +6756,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg64F(v *Value) bool {
+func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (NEGD x)
@@ -6757,7 +6767,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeg8(v *Value) bool {
+func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEG x)
@@ -6768,7 +6778,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq16(v *Value) bool {
+func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6794,7 +6804,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq32(v *Value) bool {
+func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6816,7 +6826,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq32F(v *Value) bool {
+func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -6833,7 +6843,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq64F(v *Value) bool {
+func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -6850,7 +6860,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeq8(v *Value) bool {
+func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6876,7 +6886,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeqB(v *Value) bool {
+func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
 	// match: (NeqB x y)
 	// cond:
 	// result: (XOR x y)
@@ -6889,7 +6899,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
+func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6911,7 +6921,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNilCheck(v *Value) bool {
+func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -6924,7 +6934,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpNot(v *Value) bool {
+func rewriteValueMIPS_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORconst [1] x)
@@ -6936,7 +6946,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpOffPtr(v *Value) bool {
+func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr [off] ptr:(SP))
 	// cond:
 	// result: (MOVWaddr [off] ptr)
@@ -6963,7 +6973,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr16(v *Value) bool {
+func rewriteValueMIPS_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (OR x y)
@@ -6976,7 +6986,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr32(v *Value) bool {
+func rewriteValueMIPS_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (OR x y)
@@ -6989,7 +6999,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpOr8(v *Value) bool {
+func rewriteValueMIPS_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (OR x y)
@@ -7002,7 +7012,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpOrB(v *Value) bool {
+func rewriteValueMIPS_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (OR x y)
@@ -7015,7 +7025,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRound32F(v *Value) bool {
+func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -7027,7 +7037,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRound64F(v *Value) bool {
+func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -7039,7 +7049,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7072,7 +7082,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7101,7 +7111,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7145,7 +7155,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7178,7 +7188,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7210,7 +7220,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7238,7 +7248,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7287,7 +7297,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7319,7 +7329,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7350,7 +7360,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7377,7 +7387,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
 	// match: (Rsh32Ux64 x (Const64 [c]))
 	// cond: uint32(c) < 32
 	// result: (SRLconst x [c])
@@ -7414,7 +7424,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7445,7 +7455,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7475,7 +7485,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7501,7 +7511,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
 	// match: (Rsh32x64 x (Const64 [c]))
 	// cond: uint32(c) < 32
 	// result: (SRAconst x [c])
@@ -7540,7 +7550,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7570,7 +7580,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7603,7 +7613,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7632,7 +7642,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7676,7 +7686,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7709,7 +7719,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7741,7 +7751,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7769,7 +7779,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7818,7 +7828,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7850,7 +7860,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSelect0(v *Value) bool {
+func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8063,6 +8073,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS_OpSelect0_10(v *Value) bool {
 	// match: (Select0 (MULTU (MOVWconst [c]) (MOVWconst [d])))
 	// cond:
 	// result: (MOVWconst [(c*d)>>32])
@@ -8153,7 +8166,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpSelect1(v *Value) bool {
+func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8364,6 +8377,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS_OpSelect1_10(v *Value) bool {
 	// match: (Select1 (MULTU (MOVWconst [c]) (MOVWconst [d])))
 	// cond:
 	// result: (MOVWconst [int64(int32(uint32(c)*uint32(d)))])
@@ -8454,7 +8470,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
+func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -8465,7 +8481,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -8476,7 +8492,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -8487,7 +8503,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSignmask(v *Value) bool {
+func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
 	// match: (Signmask x)
 	// cond:
 	// result: (SRAconst x [31])
@@ -8499,7 +8515,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSlicemask(v *Value) bool {
+func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -8516,7 +8532,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSqrt(v *Value) bool {
+func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (SQRTD x)
@@ -8527,7 +8543,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpStaticCall(v *Value) bool {
+func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -8542,7 +8558,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpStore(v *Value) bool {
+func rewriteValueMIPS_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 1
 	// result: (MOVBstore ptr val mem)
@@ -8630,7 +8646,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpSub16(v *Value) bool {
+func rewriteValueMIPS_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUB x y)
@@ -8643,7 +8659,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32(v *Value) bool {
+func rewriteValueMIPS_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUB x y)
@@ -8656,7 +8672,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32F(v *Value) bool {
+func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (SUBF x y)
@@ -8669,7 +8685,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
+func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Sub32withcarry <t> x y c)
@@ -8689,7 +8705,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub64F(v *Value) bool {
+func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (SUBD x y)
@@ -8702,7 +8718,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSub8(v *Value) bool {
+func rewriteValueMIPS_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUB x y)
@@ -8715,7 +8731,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpSubPtr(v *Value) bool {
+func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUB x y)
@@ -8728,7 +8744,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
+func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -8740,7 +8756,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -8752,7 +8768,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -8764,7 +8780,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor16(v *Value) bool {
+func rewriteValueMIPS_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XOR x y)
@@ -8777,7 +8793,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor32(v *Value) bool {
+func rewriteValueMIPS_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XOR x y)
@@ -8790,7 +8806,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpXor8(v *Value) bool {
+func rewriteValueMIPS_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XOR x y)
@@ -8803,11 +8819,9 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpZero(v *Value) bool {
+func rewriteValueMIPS_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Zero [0] _ mem)
@@ -9072,6 +9086,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Zero [12] {t} ptr mem)
 	// cond: t.(Type).Alignment()%4 == 0
 	// result: (MOVWstore [8] ptr (MOVWconst [0]) 		(MOVWstore [4] ptr (MOVWconst [0]) 			(MOVWstore [0] ptr (MOVWconst [0]) mem)))
@@ -9174,7 +9197,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -9185,7 +9208,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -9196,7 +9219,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -9207,7 +9230,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS_OpZeromask(v *Value) bool {
+func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 3c23d2d..7958537 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -14,563 +14,563 @@
 func rewriteValueMIPS64(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValueMIPS64_OpAdd16(v)
+		return rewriteValueMIPS64_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueMIPS64_OpAdd32(v)
+		return rewriteValueMIPS64_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueMIPS64_OpAdd32F(v)
+		return rewriteValueMIPS64_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValueMIPS64_OpAdd64(v)
+		return rewriteValueMIPS64_OpAdd64_0(v)
 	case OpAdd64F:
-		return rewriteValueMIPS64_OpAdd64F(v)
+		return rewriteValueMIPS64_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueMIPS64_OpAdd8(v)
+		return rewriteValueMIPS64_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueMIPS64_OpAddPtr(v)
+		return rewriteValueMIPS64_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueMIPS64_OpAddr(v)
+		return rewriteValueMIPS64_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueMIPS64_OpAnd16(v)
+		return rewriteValueMIPS64_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueMIPS64_OpAnd32(v)
+		return rewriteValueMIPS64_OpAnd32_0(v)
 	case OpAnd64:
-		return rewriteValueMIPS64_OpAnd64(v)
+		return rewriteValueMIPS64_OpAnd64_0(v)
 	case OpAnd8:
-		return rewriteValueMIPS64_OpAnd8(v)
+		return rewriteValueMIPS64_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueMIPS64_OpAndB(v)
+		return rewriteValueMIPS64_OpAndB_0(v)
 	case OpAvg64u:
-		return rewriteValueMIPS64_OpAvg64u(v)
+		return rewriteValueMIPS64_OpAvg64u_0(v)
 	case OpClosureCall:
-		return rewriteValueMIPS64_OpClosureCall(v)
+		return rewriteValueMIPS64_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueMIPS64_OpCom16(v)
+		return rewriteValueMIPS64_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueMIPS64_OpCom32(v)
+		return rewriteValueMIPS64_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValueMIPS64_OpCom64(v)
+		return rewriteValueMIPS64_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValueMIPS64_OpCom8(v)
+		return rewriteValueMIPS64_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueMIPS64_OpConst16(v)
+		return rewriteValueMIPS64_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueMIPS64_OpConst32(v)
+		return rewriteValueMIPS64_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueMIPS64_OpConst32F(v)
+		return rewriteValueMIPS64_OpConst32F_0(v)
 	case OpConst64:
-		return rewriteValueMIPS64_OpConst64(v)
+		return rewriteValueMIPS64_OpConst64_0(v)
 	case OpConst64F:
-		return rewriteValueMIPS64_OpConst64F(v)
+		return rewriteValueMIPS64_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueMIPS64_OpConst8(v)
+		return rewriteValueMIPS64_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueMIPS64_OpConstBool(v)
+		return rewriteValueMIPS64_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueMIPS64_OpConstNil(v)
+		return rewriteValueMIPS64_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueMIPS64_OpConvert(v)
+		return rewriteValueMIPS64_OpConvert_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueMIPS64_OpCvt32Fto32(v)
+		return rewriteValueMIPS64_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64:
-		return rewriteValueMIPS64_OpCvt32Fto64(v)
+		return rewriteValueMIPS64_OpCvt32Fto64_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueMIPS64_OpCvt32Fto64F(v)
+		return rewriteValueMIPS64_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueMIPS64_OpCvt32to32F(v)
+		return rewriteValueMIPS64_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueMIPS64_OpCvt32to64F(v)
+		return rewriteValueMIPS64_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueMIPS64_OpCvt64Fto32(v)
+		return rewriteValueMIPS64_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueMIPS64_OpCvt64Fto32F(v)
+		return rewriteValueMIPS64_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto64:
-		return rewriteValueMIPS64_OpCvt64Fto64(v)
+		return rewriteValueMIPS64_OpCvt64Fto64_0(v)
 	case OpCvt64to32F:
-		return rewriteValueMIPS64_OpCvt64to32F(v)
+		return rewriteValueMIPS64_OpCvt64to32F_0(v)
 	case OpCvt64to64F:
-		return rewriteValueMIPS64_OpCvt64to64F(v)
+		return rewriteValueMIPS64_OpCvt64to64F_0(v)
 	case OpDiv16:
-		return rewriteValueMIPS64_OpDiv16(v)
+		return rewriteValueMIPS64_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueMIPS64_OpDiv16u(v)
+		return rewriteValueMIPS64_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueMIPS64_OpDiv32(v)
+		return rewriteValueMIPS64_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueMIPS64_OpDiv32F(v)
+		return rewriteValueMIPS64_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueMIPS64_OpDiv32u(v)
+		return rewriteValueMIPS64_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValueMIPS64_OpDiv64(v)
+		return rewriteValueMIPS64_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValueMIPS64_OpDiv64F(v)
+		return rewriteValueMIPS64_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValueMIPS64_OpDiv64u(v)
+		return rewriteValueMIPS64_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValueMIPS64_OpDiv8(v)
+		return rewriteValueMIPS64_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueMIPS64_OpDiv8u(v)
+		return rewriteValueMIPS64_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueMIPS64_OpEq16(v)
+		return rewriteValueMIPS64_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueMIPS64_OpEq32(v)
+		return rewriteValueMIPS64_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueMIPS64_OpEq32F(v)
+		return rewriteValueMIPS64_OpEq32F_0(v)
 	case OpEq64:
-		return rewriteValueMIPS64_OpEq64(v)
+		return rewriteValueMIPS64_OpEq64_0(v)
 	case OpEq64F:
-		return rewriteValueMIPS64_OpEq64F(v)
+		return rewriteValueMIPS64_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueMIPS64_OpEq8(v)
+		return rewriteValueMIPS64_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueMIPS64_OpEqB(v)
+		return rewriteValueMIPS64_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueMIPS64_OpEqPtr(v)
+		return rewriteValueMIPS64_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueMIPS64_OpGeq16(v)
+		return rewriteValueMIPS64_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueMIPS64_OpGeq16U(v)
+		return rewriteValueMIPS64_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueMIPS64_OpGeq32(v)
+		return rewriteValueMIPS64_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueMIPS64_OpGeq32F(v)
+		return rewriteValueMIPS64_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueMIPS64_OpGeq32U(v)
+		return rewriteValueMIPS64_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValueMIPS64_OpGeq64(v)
+		return rewriteValueMIPS64_OpGeq64_0(v)
 	case OpGeq64F:
-		return rewriteValueMIPS64_OpGeq64F(v)
+		return rewriteValueMIPS64_OpGeq64F_0(v)
 	case OpGeq64U:
-		return rewriteValueMIPS64_OpGeq64U(v)
+		return rewriteValueMIPS64_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValueMIPS64_OpGeq8(v)
+		return rewriteValueMIPS64_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueMIPS64_OpGeq8U(v)
+		return rewriteValueMIPS64_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueMIPS64_OpGetClosurePtr(v)
+		return rewriteValueMIPS64_OpGetClosurePtr_0(v)
 	case OpGreater16:
-		return rewriteValueMIPS64_OpGreater16(v)
+		return rewriteValueMIPS64_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueMIPS64_OpGreater16U(v)
+		return rewriteValueMIPS64_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueMIPS64_OpGreater32(v)
+		return rewriteValueMIPS64_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueMIPS64_OpGreater32F(v)
+		return rewriteValueMIPS64_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueMIPS64_OpGreater32U(v)
+		return rewriteValueMIPS64_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValueMIPS64_OpGreater64(v)
+		return rewriteValueMIPS64_OpGreater64_0(v)
 	case OpGreater64F:
-		return rewriteValueMIPS64_OpGreater64F(v)
+		return rewriteValueMIPS64_OpGreater64F_0(v)
 	case OpGreater64U:
-		return rewriteValueMIPS64_OpGreater64U(v)
+		return rewriteValueMIPS64_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValueMIPS64_OpGreater8(v)
+		return rewriteValueMIPS64_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueMIPS64_OpGreater8U(v)
+		return rewriteValueMIPS64_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueMIPS64_OpHmul32(v)
+		return rewriteValueMIPS64_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueMIPS64_OpHmul32u(v)
+		return rewriteValueMIPS64_OpHmul32u_0(v)
 	case OpHmul64:
-		return rewriteValueMIPS64_OpHmul64(v)
+		return rewriteValueMIPS64_OpHmul64_0(v)
 	case OpHmul64u:
-		return rewriteValueMIPS64_OpHmul64u(v)
+		return rewriteValueMIPS64_OpHmul64u_0(v)
 	case OpInterCall:
-		return rewriteValueMIPS64_OpInterCall(v)
+		return rewriteValueMIPS64_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueMIPS64_OpIsInBounds(v)
+		return rewriteValueMIPS64_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueMIPS64_OpIsNonNil(v)
+		return rewriteValueMIPS64_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueMIPS64_OpIsSliceInBounds(v)
+		return rewriteValueMIPS64_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueMIPS64_OpLeq16(v)
+		return rewriteValueMIPS64_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueMIPS64_OpLeq16U(v)
+		return rewriteValueMIPS64_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueMIPS64_OpLeq32(v)
+		return rewriteValueMIPS64_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueMIPS64_OpLeq32F(v)
+		return rewriteValueMIPS64_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueMIPS64_OpLeq32U(v)
+		return rewriteValueMIPS64_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValueMIPS64_OpLeq64(v)
+		return rewriteValueMIPS64_OpLeq64_0(v)
 	case OpLeq64F:
-		return rewriteValueMIPS64_OpLeq64F(v)
+		return rewriteValueMIPS64_OpLeq64F_0(v)
 	case OpLeq64U:
-		return rewriteValueMIPS64_OpLeq64U(v)
+		return rewriteValueMIPS64_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValueMIPS64_OpLeq8(v)
+		return rewriteValueMIPS64_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueMIPS64_OpLeq8U(v)
+		return rewriteValueMIPS64_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueMIPS64_OpLess16(v)
+		return rewriteValueMIPS64_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueMIPS64_OpLess16U(v)
+		return rewriteValueMIPS64_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueMIPS64_OpLess32(v)
+		return rewriteValueMIPS64_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueMIPS64_OpLess32F(v)
+		return rewriteValueMIPS64_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueMIPS64_OpLess32U(v)
+		return rewriteValueMIPS64_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValueMIPS64_OpLess64(v)
+		return rewriteValueMIPS64_OpLess64_0(v)
 	case OpLess64F:
-		return rewriteValueMIPS64_OpLess64F(v)
+		return rewriteValueMIPS64_OpLess64F_0(v)
 	case OpLess64U:
-		return rewriteValueMIPS64_OpLess64U(v)
+		return rewriteValueMIPS64_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValueMIPS64_OpLess8(v)
+		return rewriteValueMIPS64_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueMIPS64_OpLess8U(v)
+		return rewriteValueMIPS64_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueMIPS64_OpLoad(v)
+		return rewriteValueMIPS64_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueMIPS64_OpLsh16x16(v)
+		return rewriteValueMIPS64_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueMIPS64_OpLsh16x32(v)
+		return rewriteValueMIPS64_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueMIPS64_OpLsh16x64(v)
+		return rewriteValueMIPS64_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueMIPS64_OpLsh16x8(v)
+		return rewriteValueMIPS64_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueMIPS64_OpLsh32x16(v)
+		return rewriteValueMIPS64_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueMIPS64_OpLsh32x32(v)
+		return rewriteValueMIPS64_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueMIPS64_OpLsh32x64(v)
+		return rewriteValueMIPS64_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueMIPS64_OpLsh32x8(v)
+		return rewriteValueMIPS64_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValueMIPS64_OpLsh64x16(v)
+		return rewriteValueMIPS64_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValueMIPS64_OpLsh64x32(v)
+		return rewriteValueMIPS64_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValueMIPS64_OpLsh64x64(v)
+		return rewriteValueMIPS64_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValueMIPS64_OpLsh64x8(v)
+		return rewriteValueMIPS64_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueMIPS64_OpLsh8x16(v)
+		return rewriteValueMIPS64_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueMIPS64_OpLsh8x32(v)
+		return rewriteValueMIPS64_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueMIPS64_OpLsh8x64(v)
+		return rewriteValueMIPS64_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueMIPS64_OpLsh8x8(v)
+		return rewriteValueMIPS64_OpLsh8x8_0(v)
 	case OpMIPS64ADDV:
-		return rewriteValueMIPS64_OpMIPS64ADDV(v)
+		return rewriteValueMIPS64_OpMIPS64ADDV_0(v)
 	case OpMIPS64ADDVconst:
-		return rewriteValueMIPS64_OpMIPS64ADDVconst(v)
+		return rewriteValueMIPS64_OpMIPS64ADDVconst_0(v)
 	case OpMIPS64AND:
-		return rewriteValueMIPS64_OpMIPS64AND(v)
+		return rewriteValueMIPS64_OpMIPS64AND_0(v)
 	case OpMIPS64ANDconst:
-		return rewriteValueMIPS64_OpMIPS64ANDconst(v)
+		return rewriteValueMIPS64_OpMIPS64ANDconst_0(v)
 	case OpMIPS64MOVBUload:
-		return rewriteValueMIPS64_OpMIPS64MOVBUload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBUload_0(v)
 	case OpMIPS64MOVBUreg:
-		return rewriteValueMIPS64_OpMIPS64MOVBUreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v)
 	case OpMIPS64MOVBload:
-		return rewriteValueMIPS64_OpMIPS64MOVBload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBload_0(v)
 	case OpMIPS64MOVBreg:
-		return rewriteValueMIPS64_OpMIPS64MOVBreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBreg_0(v)
 	case OpMIPS64MOVBstore:
-		return rewriteValueMIPS64_OpMIPS64MOVBstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBstore_0(v)
 	case OpMIPS64MOVBstorezero:
-		return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v)
+		return rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v)
 	case OpMIPS64MOVDload:
-		return rewriteValueMIPS64_OpMIPS64MOVDload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVDload_0(v)
 	case OpMIPS64MOVDstore:
-		return rewriteValueMIPS64_OpMIPS64MOVDstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVDstore_0(v)
 	case OpMIPS64MOVFload:
-		return rewriteValueMIPS64_OpMIPS64MOVFload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVFload_0(v)
 	case OpMIPS64MOVFstore:
-		return rewriteValueMIPS64_OpMIPS64MOVFstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVFstore_0(v)
 	case OpMIPS64MOVHUload:
-		return rewriteValueMIPS64_OpMIPS64MOVHUload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHUload_0(v)
 	case OpMIPS64MOVHUreg:
-		return rewriteValueMIPS64_OpMIPS64MOVHUreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v)
 	case OpMIPS64MOVHload:
-		return rewriteValueMIPS64_OpMIPS64MOVHload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHload_0(v)
 	case OpMIPS64MOVHreg:
-		return rewriteValueMIPS64_OpMIPS64MOVHreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHreg_0(v)
 	case OpMIPS64MOVHstore:
-		return rewriteValueMIPS64_OpMIPS64MOVHstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHstore_0(v)
 	case OpMIPS64MOVHstorezero:
-		return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v)
+		return rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v)
 	case OpMIPS64MOVVload:
-		return rewriteValueMIPS64_OpMIPS64MOVVload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVVload_0(v)
 	case OpMIPS64MOVVreg:
-		return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVVreg_0(v)
 	case OpMIPS64MOVVstore:
-		return rewriteValueMIPS64_OpMIPS64MOVVstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVVstore_0(v)
 	case OpMIPS64MOVVstorezero:
-		return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v)
+		return rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v)
 	case OpMIPS64MOVWUload:
-		return rewriteValueMIPS64_OpMIPS64MOVWUload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWUload_0(v)
 	case OpMIPS64MOVWUreg:
-		return rewriteValueMIPS64_OpMIPS64MOVWUreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v)
 	case OpMIPS64MOVWload:
-		return rewriteValueMIPS64_OpMIPS64MOVWload(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWload_0(v)
 	case OpMIPS64MOVWreg:
-		return rewriteValueMIPS64_OpMIPS64MOVWreg(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWreg_0(v) || rewriteValueMIPS64_OpMIPS64MOVWreg_10(v)
 	case OpMIPS64MOVWstore:
-		return rewriteValueMIPS64_OpMIPS64MOVWstore(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWstore_0(v)
 	case OpMIPS64MOVWstorezero:
-		return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v)
+		return rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v)
 	case OpMIPS64NEGV:
-		return rewriteValueMIPS64_OpMIPS64NEGV(v)
+		return rewriteValueMIPS64_OpMIPS64NEGV_0(v)
 	case OpMIPS64NOR:
-		return rewriteValueMIPS64_OpMIPS64NOR(v)
+		return rewriteValueMIPS64_OpMIPS64NOR_0(v)
 	case OpMIPS64NORconst:
-		return rewriteValueMIPS64_OpMIPS64NORconst(v)
+		return rewriteValueMIPS64_OpMIPS64NORconst_0(v)
 	case OpMIPS64OR:
-		return rewriteValueMIPS64_OpMIPS64OR(v)
+		return rewriteValueMIPS64_OpMIPS64OR_0(v)
 	case OpMIPS64ORconst:
-		return rewriteValueMIPS64_OpMIPS64ORconst(v)
+		return rewriteValueMIPS64_OpMIPS64ORconst_0(v)
 	case OpMIPS64SGT:
-		return rewriteValueMIPS64_OpMIPS64SGT(v)
+		return rewriteValueMIPS64_OpMIPS64SGT_0(v)
 	case OpMIPS64SGTU:
-		return rewriteValueMIPS64_OpMIPS64SGTU(v)
+		return rewriteValueMIPS64_OpMIPS64SGTU_0(v)
 	case OpMIPS64SGTUconst:
-		return rewriteValueMIPS64_OpMIPS64SGTUconst(v)
+		return rewriteValueMIPS64_OpMIPS64SGTUconst_0(v)
 	case OpMIPS64SGTconst:
-		return rewriteValueMIPS64_OpMIPS64SGTconst(v)
+		return rewriteValueMIPS64_OpMIPS64SGTconst_0(v) || rewriteValueMIPS64_OpMIPS64SGTconst_10(v)
 	case OpMIPS64SLLV:
-		return rewriteValueMIPS64_OpMIPS64SLLV(v)
+		return rewriteValueMIPS64_OpMIPS64SLLV_0(v)
 	case OpMIPS64SLLVconst:
-		return rewriteValueMIPS64_OpMIPS64SLLVconst(v)
+		return rewriteValueMIPS64_OpMIPS64SLLVconst_0(v)
 	case OpMIPS64SRAV:
-		return rewriteValueMIPS64_OpMIPS64SRAV(v)
+		return rewriteValueMIPS64_OpMIPS64SRAV_0(v)
 	case OpMIPS64SRAVconst:
-		return rewriteValueMIPS64_OpMIPS64SRAVconst(v)
+		return rewriteValueMIPS64_OpMIPS64SRAVconst_0(v)
 	case OpMIPS64SRLV:
-		return rewriteValueMIPS64_OpMIPS64SRLV(v)
+		return rewriteValueMIPS64_OpMIPS64SRLV_0(v)
 	case OpMIPS64SRLVconst:
-		return rewriteValueMIPS64_OpMIPS64SRLVconst(v)
+		return rewriteValueMIPS64_OpMIPS64SRLVconst_0(v)
 	case OpMIPS64SUBV:
-		return rewriteValueMIPS64_OpMIPS64SUBV(v)
+		return rewriteValueMIPS64_OpMIPS64SUBV_0(v)
 	case OpMIPS64SUBVconst:
-		return rewriteValueMIPS64_OpMIPS64SUBVconst(v)
+		return rewriteValueMIPS64_OpMIPS64SUBVconst_0(v)
 	case OpMIPS64XOR:
-		return rewriteValueMIPS64_OpMIPS64XOR(v)
+		return rewriteValueMIPS64_OpMIPS64XOR_0(v)
 	case OpMIPS64XORconst:
-		return rewriteValueMIPS64_OpMIPS64XORconst(v)
+		return rewriteValueMIPS64_OpMIPS64XORconst_0(v)
 	case OpMod16:
-		return rewriteValueMIPS64_OpMod16(v)
+		return rewriteValueMIPS64_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueMIPS64_OpMod16u(v)
+		return rewriteValueMIPS64_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueMIPS64_OpMod32(v)
+		return rewriteValueMIPS64_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueMIPS64_OpMod32u(v)
+		return rewriteValueMIPS64_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValueMIPS64_OpMod64(v)
+		return rewriteValueMIPS64_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValueMIPS64_OpMod64u(v)
+		return rewriteValueMIPS64_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValueMIPS64_OpMod8(v)
+		return rewriteValueMIPS64_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueMIPS64_OpMod8u(v)
+		return rewriteValueMIPS64_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueMIPS64_OpMove(v)
+		return rewriteValueMIPS64_OpMove_0(v) || rewriteValueMIPS64_OpMove_10(v)
 	case OpMul16:
-		return rewriteValueMIPS64_OpMul16(v)
+		return rewriteValueMIPS64_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueMIPS64_OpMul32(v)
+		return rewriteValueMIPS64_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueMIPS64_OpMul32F(v)
+		return rewriteValueMIPS64_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValueMIPS64_OpMul64(v)
+		return rewriteValueMIPS64_OpMul64_0(v)
 	case OpMul64F:
-		return rewriteValueMIPS64_OpMul64F(v)
+		return rewriteValueMIPS64_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValueMIPS64_OpMul8(v)
+		return rewriteValueMIPS64_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueMIPS64_OpNeg16(v)
+		return rewriteValueMIPS64_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueMIPS64_OpNeg32(v)
+		return rewriteValueMIPS64_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueMIPS64_OpNeg32F(v)
+		return rewriteValueMIPS64_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValueMIPS64_OpNeg64(v)
+		return rewriteValueMIPS64_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValueMIPS64_OpNeg64F(v)
+		return rewriteValueMIPS64_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueMIPS64_OpNeg8(v)
+		return rewriteValueMIPS64_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueMIPS64_OpNeq16(v)
+		return rewriteValueMIPS64_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueMIPS64_OpNeq32(v)
+		return rewriteValueMIPS64_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueMIPS64_OpNeq32F(v)
+		return rewriteValueMIPS64_OpNeq32F_0(v)
 	case OpNeq64:
-		return rewriteValueMIPS64_OpNeq64(v)
+		return rewriteValueMIPS64_OpNeq64_0(v)
 	case OpNeq64F:
-		return rewriteValueMIPS64_OpNeq64F(v)
+		return rewriteValueMIPS64_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueMIPS64_OpNeq8(v)
+		return rewriteValueMIPS64_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueMIPS64_OpNeqB(v)
+		return rewriteValueMIPS64_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueMIPS64_OpNeqPtr(v)
+		return rewriteValueMIPS64_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueMIPS64_OpNilCheck(v)
+		return rewriteValueMIPS64_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueMIPS64_OpNot(v)
+		return rewriteValueMIPS64_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueMIPS64_OpOffPtr(v)
+		return rewriteValueMIPS64_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueMIPS64_OpOr16(v)
+		return rewriteValueMIPS64_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueMIPS64_OpOr32(v)
+		return rewriteValueMIPS64_OpOr32_0(v)
 	case OpOr64:
-		return rewriteValueMIPS64_OpOr64(v)
+		return rewriteValueMIPS64_OpOr64_0(v)
 	case OpOr8:
-		return rewriteValueMIPS64_OpOr8(v)
+		return rewriteValueMIPS64_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueMIPS64_OpOrB(v)
+		return rewriteValueMIPS64_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValueMIPS64_OpRound32F(v)
+		return rewriteValueMIPS64_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueMIPS64_OpRound64F(v)
+		return rewriteValueMIPS64_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueMIPS64_OpRsh16Ux16(v)
+		return rewriteValueMIPS64_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueMIPS64_OpRsh16Ux32(v)
+		return rewriteValueMIPS64_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueMIPS64_OpRsh16Ux64(v)
+		return rewriteValueMIPS64_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueMIPS64_OpRsh16Ux8(v)
+		return rewriteValueMIPS64_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueMIPS64_OpRsh16x16(v)
+		return rewriteValueMIPS64_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueMIPS64_OpRsh16x32(v)
+		return rewriteValueMIPS64_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueMIPS64_OpRsh16x64(v)
+		return rewriteValueMIPS64_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueMIPS64_OpRsh16x8(v)
+		return rewriteValueMIPS64_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueMIPS64_OpRsh32Ux16(v)
+		return rewriteValueMIPS64_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueMIPS64_OpRsh32Ux32(v)
+		return rewriteValueMIPS64_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueMIPS64_OpRsh32Ux64(v)
+		return rewriteValueMIPS64_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueMIPS64_OpRsh32Ux8(v)
+		return rewriteValueMIPS64_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueMIPS64_OpRsh32x16(v)
+		return rewriteValueMIPS64_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueMIPS64_OpRsh32x32(v)
+		return rewriteValueMIPS64_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueMIPS64_OpRsh32x64(v)
+		return rewriteValueMIPS64_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueMIPS64_OpRsh32x8(v)
+		return rewriteValueMIPS64_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValueMIPS64_OpRsh64Ux16(v)
+		return rewriteValueMIPS64_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValueMIPS64_OpRsh64Ux32(v)
+		return rewriteValueMIPS64_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValueMIPS64_OpRsh64Ux64(v)
+		return rewriteValueMIPS64_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValueMIPS64_OpRsh64Ux8(v)
+		return rewriteValueMIPS64_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValueMIPS64_OpRsh64x16(v)
+		return rewriteValueMIPS64_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValueMIPS64_OpRsh64x32(v)
+		return rewriteValueMIPS64_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValueMIPS64_OpRsh64x64(v)
+		return rewriteValueMIPS64_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValueMIPS64_OpRsh64x8(v)
+		return rewriteValueMIPS64_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueMIPS64_OpRsh8Ux16(v)
+		return rewriteValueMIPS64_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueMIPS64_OpRsh8Ux32(v)
+		return rewriteValueMIPS64_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueMIPS64_OpRsh8Ux64(v)
+		return rewriteValueMIPS64_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueMIPS64_OpRsh8Ux8(v)
+		return rewriteValueMIPS64_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueMIPS64_OpRsh8x16(v)
+		return rewriteValueMIPS64_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueMIPS64_OpRsh8x32(v)
+		return rewriteValueMIPS64_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueMIPS64_OpRsh8x64(v)
+		return rewriteValueMIPS64_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueMIPS64_OpRsh8x8(v)
+		return rewriteValueMIPS64_OpRsh8x8_0(v)
 	case OpSelect0:
-		return rewriteValueMIPS64_OpSelect0(v)
+		return rewriteValueMIPS64_OpSelect0_0(v)
 	case OpSelect1:
-		return rewriteValueMIPS64_OpSelect1(v)
+		return rewriteValueMIPS64_OpSelect1_0(v) || rewriteValueMIPS64_OpSelect1_10(v) || rewriteValueMIPS64_OpSelect1_20(v)
 	case OpSignExt16to32:
-		return rewriteValueMIPS64_OpSignExt16to32(v)
+		return rewriteValueMIPS64_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValueMIPS64_OpSignExt16to64(v)
+		return rewriteValueMIPS64_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValueMIPS64_OpSignExt32to64(v)
+		return rewriteValueMIPS64_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValueMIPS64_OpSignExt8to16(v)
+		return rewriteValueMIPS64_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueMIPS64_OpSignExt8to32(v)
+		return rewriteValueMIPS64_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValueMIPS64_OpSignExt8to64(v)
+		return rewriteValueMIPS64_OpSignExt8to64_0(v)
 	case OpSlicemask:
-		return rewriteValueMIPS64_OpSlicemask(v)
+		return rewriteValueMIPS64_OpSlicemask_0(v)
 	case OpStaticCall:
-		return rewriteValueMIPS64_OpStaticCall(v)
+		return rewriteValueMIPS64_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueMIPS64_OpStore(v)
+		return rewriteValueMIPS64_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueMIPS64_OpSub16(v)
+		return rewriteValueMIPS64_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueMIPS64_OpSub32(v)
+		return rewriteValueMIPS64_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueMIPS64_OpSub32F(v)
+		return rewriteValueMIPS64_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValueMIPS64_OpSub64(v)
+		return rewriteValueMIPS64_OpSub64_0(v)
 	case OpSub64F:
-		return rewriteValueMIPS64_OpSub64F(v)
+		return rewriteValueMIPS64_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueMIPS64_OpSub8(v)
+		return rewriteValueMIPS64_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueMIPS64_OpSubPtr(v)
+		return rewriteValueMIPS64_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueMIPS64_OpTrunc16to8(v)
+		return rewriteValueMIPS64_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueMIPS64_OpTrunc32to16(v)
+		return rewriteValueMIPS64_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueMIPS64_OpTrunc32to8(v)
+		return rewriteValueMIPS64_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValueMIPS64_OpTrunc64to16(v)
+		return rewriteValueMIPS64_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValueMIPS64_OpTrunc64to32(v)
+		return rewriteValueMIPS64_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValueMIPS64_OpTrunc64to8(v)
+		return rewriteValueMIPS64_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValueMIPS64_OpXor16(v)
+		return rewriteValueMIPS64_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueMIPS64_OpXor32(v)
+		return rewriteValueMIPS64_OpXor32_0(v)
 	case OpXor64:
-		return rewriteValueMIPS64_OpXor64(v)
+		return rewriteValueMIPS64_OpXor64_0(v)
 	case OpXor8:
-		return rewriteValueMIPS64_OpXor8(v)
+		return rewriteValueMIPS64_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueMIPS64_OpZero(v)
+		return rewriteValueMIPS64_OpZero_0(v) || rewriteValueMIPS64_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValueMIPS64_OpZeroExt16to32(v)
+		return rewriteValueMIPS64_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValueMIPS64_OpZeroExt16to64(v)
+		return rewriteValueMIPS64_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValueMIPS64_OpZeroExt32to64(v)
+		return rewriteValueMIPS64_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueMIPS64_OpZeroExt8to16(v)
+		return rewriteValueMIPS64_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueMIPS64_OpZeroExt8to32(v)
+		return rewriteValueMIPS64_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValueMIPS64_OpZeroExt8to64(v)
+		return rewriteValueMIPS64_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValueMIPS64_OpAdd16(v *Value) bool {
+func rewriteValueMIPS64_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADDV x y)
@@ -583,7 +583,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAdd32(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADDV x y)
@@ -596,7 +596,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAdd32F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (ADDF x y)
@@ -609,7 +609,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAdd64(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64_0(v *Value) bool {
 	// match: (Add64 x y)
 	// cond:
 	// result: (ADDV x y)
@@ -622,7 +622,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAdd64F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (ADDD x y)
@@ -635,7 +635,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAdd8(v *Value) bool {
+func rewriteValueMIPS64_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADDV x y)
@@ -648,7 +648,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAddPtr(v *Value) bool {
+func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADDV x y)
@@ -661,7 +661,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAddr(v *Value) bool {
+func rewriteValueMIPS64_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVVaddr {sym} base)
@@ -674,7 +674,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAnd16(v *Value) bool {
+func rewriteValueMIPS64_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (AND x y)
@@ -687,7 +687,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAnd32(v *Value) bool {
+func rewriteValueMIPS64_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (AND x y)
@@ -700,7 +700,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAnd64(v *Value) bool {
+func rewriteValueMIPS64_OpAnd64_0(v *Value) bool {
 	// match: (And64 x y)
 	// cond:
 	// result: (AND x y)
@@ -713,7 +713,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAnd8(v *Value) bool {
+func rewriteValueMIPS64_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (AND x y)
@@ -726,7 +726,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAndB(v *Value) bool {
+func rewriteValueMIPS64_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (AND x y)
@@ -739,7 +739,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpAvg64u(v *Value) bool {
+func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg64u <t> x y)
@@ -761,7 +761,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpClosureCall(v *Value) bool {
+func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -778,7 +778,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCom16(v *Value) bool {
+func rewriteValueMIPS64_OpCom16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -796,7 +796,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCom32(v *Value) bool {
+func rewriteValueMIPS64_OpCom32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -814,7 +814,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCom64(v *Value) bool {
+func rewriteValueMIPS64_OpCom64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -832,7 +832,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCom8(v *Value) bool {
+func rewriteValueMIPS64_OpCom8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -850,7 +850,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst16(v *Value) bool {
+func rewriteValueMIPS64_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVVconst [val])
@@ -861,7 +861,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst32(v *Value) bool {
+func rewriteValueMIPS64_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVVconst [val])
@@ -872,7 +872,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst32F(v *Value) bool {
+func rewriteValueMIPS64_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (MOVFconst [val])
@@ -883,7 +883,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst64(v *Value) bool {
+func rewriteValueMIPS64_OpConst64_0(v *Value) bool {
 	// match: (Const64 [val])
 	// cond:
 	// result: (MOVVconst [val])
@@ -894,7 +894,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst64F(v *Value) bool {
+func rewriteValueMIPS64_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -905,7 +905,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConst8(v *Value) bool {
+func rewriteValueMIPS64_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVVconst [val])
@@ -916,7 +916,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConstBool(v *Value) bool {
+func rewriteValueMIPS64_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVVconst [b])
@@ -927,7 +927,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConstNil(v *Value) bool {
+func rewriteValueMIPS64_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVVconst [0])
@@ -937,7 +937,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpConvert(v *Value) bool {
+func rewriteValueMIPS64_OpConvert_0(v *Value) bool {
 	// match: (Convert x mem)
 	// cond:
 	// result: (MOVVconvert x mem)
@@ -950,7 +950,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (TRUNCFW x)
@@ -961,7 +961,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool {
 	// match: (Cvt32Fto64 x)
 	// cond:
 	// result: (TRUNCFV x)
@@ -972,7 +972,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (MOVFD x)
@@ -983,7 +983,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (MOVWF x)
@@ -994,7 +994,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (MOVWD x)
@@ -1005,7 +1005,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (TRUNCDW x)
@@ -1016,7 +1016,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (MOVDF x)
@@ -1027,7 +1027,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool {
 	// match: (Cvt64Fto64 x)
 	// cond:
 	// result: (TRUNCDV x)
@@ -1038,7 +1038,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool {
 	// match: (Cvt64to32F x)
 	// cond:
 	// result: (MOVVF x)
@@ -1049,7 +1049,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool {
 	// match: (Cvt64to64F x)
 	// cond:
 	// result: (MOVVD x)
@@ -1060,7 +1060,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv16(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1083,7 +1083,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv16u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1106,7 +1106,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv32(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1129,7 +1129,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv32F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (DIVF x y)
@@ -1142,7 +1142,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv32u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1165,7 +1165,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv64(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1184,7 +1184,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv64F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (DIVD x y)
@@ -1197,7 +1197,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv64u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1216,7 +1216,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv8(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1239,7 +1239,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpDiv8u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1262,7 +1262,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq16(v *Value) bool {
+func rewriteValueMIPS64_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1288,7 +1288,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq32(v *Value) bool {
+func rewriteValueMIPS64_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1314,7 +1314,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq32F(v *Value) bool {
+func rewriteValueMIPS64_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -1331,7 +1331,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq64(v *Value) bool {
+func rewriteValueMIPS64_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1353,7 +1353,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq64F(v *Value) bool {
+func rewriteValueMIPS64_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -1370,7 +1370,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEq8(v *Value) bool {
+func rewriteValueMIPS64_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1396,7 +1396,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEqB(v *Value) bool {
+func rewriteValueMIPS64_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1418,7 +1418,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpEqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1440,7 +1440,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq16(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1466,7 +1466,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1492,7 +1492,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq32(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1518,7 +1518,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -1535,7 +1535,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1561,7 +1561,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq64(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1583,7 +1583,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -1600,7 +1600,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1622,7 +1622,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq8(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1648,7 +1648,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1674,7 +1674,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -1683,7 +1683,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater16(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1704,7 +1704,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater16U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1725,7 +1725,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater32(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1746,7 +1746,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater32F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -1763,7 +1763,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater32U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1784,7 +1784,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater64(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64_0(v *Value) bool {
 	// match: (Greater64 x y)
 	// cond:
 	// result: (SGT x y)
@@ -1797,7 +1797,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater64F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -1814,7 +1814,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater64U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool {
 	// match: (Greater64U x y)
 	// cond:
 	// result: (SGTU x y)
@@ -1827,7 +1827,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater8(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1848,7 +1848,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpGreater8U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1869,7 +1869,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpHmul32(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1895,7 +1895,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpHmul32u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1921,7 +1921,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpHmul64(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1940,7 +1940,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpHmul64u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1959,7 +1959,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpInterCall(v *Value) bool {
+func rewriteValueMIPS64_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -1974,7 +1974,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpIsInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool {
 	// match: (IsInBounds idx len)
 	// cond:
 	// result: (SGTU len idx)
@@ -1987,7 +1987,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
+func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2005,7 +2005,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2027,7 +2027,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq16(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2053,7 +2053,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2079,7 +2079,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq32(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2105,7 +2105,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -2122,7 +2122,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2148,7 +2148,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq64(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2170,7 +2170,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -2187,7 +2187,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2209,7 +2209,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq8(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2235,7 +2235,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2261,7 +2261,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess16(v *Value) bool {
+func rewriteValueMIPS64_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2282,7 +2282,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess16U(v *Value) bool {
+func rewriteValueMIPS64_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2303,7 +2303,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess32(v *Value) bool {
+func rewriteValueMIPS64_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2324,7 +2324,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess32F(v *Value) bool {
+func rewriteValueMIPS64_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -2341,7 +2341,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess32U(v *Value) bool {
+func rewriteValueMIPS64_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2362,7 +2362,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess64(v *Value) bool {
+func rewriteValueMIPS64_OpLess64_0(v *Value) bool {
 	// match: (Less64 x y)
 	// cond:
 	// result: (SGT y x)
@@ -2375,7 +2375,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess64F(v *Value) bool {
+func rewriteValueMIPS64_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -2392,7 +2392,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess64U(v *Value) bool {
+func rewriteValueMIPS64_OpLess64U_0(v *Value) bool {
 	// match: (Less64U x y)
 	// cond:
 	// result: (SGTU y x)
@@ -2405,7 +2405,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess8(v *Value) bool {
+func rewriteValueMIPS64_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2426,7 +2426,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLess8U(v *Value) bool {
+func rewriteValueMIPS64_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2447,7 +2447,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLoad(v *Value) bool {
+func rewriteValueMIPS64_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: t.IsBoolean()
 	// result: (MOVBUload ptr mem)
@@ -2600,7 +2600,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpLsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2632,7 +2632,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2664,7 +2664,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2692,7 +2692,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2724,7 +2724,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2756,7 +2756,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2788,7 +2788,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2816,7 +2816,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2848,7 +2848,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2880,7 +2880,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2912,7 +2912,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2940,7 +2940,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2972,7 +2972,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3004,7 +3004,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3036,7 +3036,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3064,7 +3064,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpLsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3096,7 +3096,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool {
 	// match: (ADDV x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (ADDVconst [c] x)
@@ -3165,7 +3165,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool {
 	// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
 	// cond:
 	// result: (MOVVaddr [off1+off2] {sym} ptr)
@@ -3251,7 +3251,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool {
 	// match: (AND x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (ANDconst [c] x)
@@ -3303,7 +3303,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool {
 	// match: (ANDconst [0] _)
 	// cond:
 	// result: (MOVVconst [0])
@@ -3360,7 +3360,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool {
 	// match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -3410,7 +3410,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool {
 	// match: (MOVBUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -3450,7 +3450,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool {
 	// match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVBload  [off1+off2] {sym} ptr mem)
@@ -3500,7 +3500,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool {
 	// match: (MOVBreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -3540,7 +3540,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -3742,7 +3742,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool {
 	// match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
@@ -3792,7 +3792,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool {
 	// match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVDload  [off1+off2] {sym} ptr mem)
@@ -3842,7 +3842,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -3896,7 +3896,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool {
 	// match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVFload  [off1+off2] {sym} ptr mem)
@@ -3946,7 +3946,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool {
 	// match: (MOVFstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVFstore [off1+off2] {sym} ptr val mem)
@@ -4000,7 +4000,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool {
 	// match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -4050,7 +4050,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool {
 	// match: (MOVHUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -4114,7 +4114,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVHload  [off1+off2] {sym} ptr mem)
@@ -4164,7 +4164,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool {
 	// match: (MOVHreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -4252,7 +4252,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -4412,7 +4412,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool {
 	// match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
@@ -4462,7 +4462,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool {
 	// match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVVload  [off1+off2] {sym} ptr mem)
@@ -4512,7 +4512,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool {
 	// match: (MOVVreg x)
 	// cond: x.Uses == 1
 	// result: (MOVVnop x)
@@ -4540,7 +4540,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool {
 	// match: (MOVVstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVVstore [off1+off2] {sym} ptr val mem)
@@ -4616,7 +4616,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool {
 	// match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVVstorezero [off1+off2] {sym} ptr mem)
@@ -4666,7 +4666,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool {
 	// match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVWUload [off1+off2] {sym} ptr mem)
@@ -4716,7 +4716,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool {
 	// match: (MOVWUreg x:(MOVBUload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -4804,7 +4804,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool {
 	// match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVWload  [off1+off2] {sym} ptr mem)
@@ -4854,7 +4854,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool {
 	// match: (MOVWreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVVreg x)
@@ -4975,6 +4975,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpMIPS64MOVWreg_10(v *Value) bool {
 	// match: (MOVWreg (MOVVconst [c]))
 	// cond:
 	// result: (MOVVconst [int64(int32(c))])
@@ -4990,7 +4993,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVWstore [off1+off2] {sym} ptr val mem)
@@ -5108,7 +5111,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool {
 	// match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
 	// cond: is32Bit(off1+off2)
 	// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
@@ -5158,7 +5161,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool {
 	// match: (NEGV (MOVVconst [c]))
 	// cond:
 	// result: (MOVVconst [-c])
@@ -5174,7 +5177,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool {
 	// match: (NOR x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (NORconst [c] x)
@@ -5213,7 +5216,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool {
 	// match: (NORconst [c] (MOVVconst [d]))
 	// cond:
 	// result: (MOVVconst [^(c|d)])
@@ -5230,7 +5233,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool {
 	// match: (OR x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (ORconst  [c] x)
@@ -5282,7 +5285,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool {
 	// match: (ORconst [0] x)
 	// cond:
 	// result: x
@@ -5342,7 +5345,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool {
 	// match: (SGT (MOVVconst [c]) x)
 	// cond: is32Bit(c)
 	// result: (SGTconst  [c] x)
@@ -5363,7 +5366,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool {
 	// match: (SGTU (MOVVconst [c]) x)
 	// cond: is32Bit(c)
 	// result: (SGTUconst [c] x)
@@ -5384,7 +5387,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool {
 	// match: (SGTUconst [c] (MOVVconst [d]))
 	// cond: uint64(c)>uint64(d)
 	// result: (MOVVconst [1])
@@ -5487,7 +5490,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool {
 	// match: (SGTconst [c] (MOVVconst [d]))
 	// cond: int64(c)>int64(d)
 	// result: (MOVVconst [1])
@@ -5650,6 +5653,9 @@
 		v.AuxInt = 0
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool {
 	// match: (SGTconst [c] (MOVWUreg _))
 	// cond: int64(c) < 0
 	// result: (MOVVconst [0])
@@ -5702,7 +5708,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool {
 	// match: (SLLV _ (MOVVconst [c]))
 	// cond: uint64(c)>=64
 	// result: (MOVVconst [0])
@@ -5736,7 +5742,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLVconst_0(v *Value) bool {
 	// match: (SLLVconst [c] (MOVVconst [d]))
 	// cond:
 	// result: (MOVVconst [int64(d)<<uint64(c)])
@@ -5753,7 +5759,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAV_0(v *Value) bool {
 	// match: (SRAV x (MOVVconst [c]))
 	// cond: uint64(c)>=64
 	// result: (SRAVconst x [63])
@@ -5789,7 +5795,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool {
 	// match: (SRAVconst [c] (MOVVconst [d]))
 	// cond:
 	// result: (MOVVconst [int64(d)>>uint64(c)])
@@ -5806,7 +5812,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool {
 	// match: (SRLV _ (MOVVconst [c]))
 	// cond: uint64(c)>=64
 	// result: (MOVVconst [0])
@@ -5840,7 +5846,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool {
 	// match: (SRLVconst [c] (MOVVconst [d]))
 	// cond:
 	// result: (MOVVconst [int64(uint64(d)>>uint64(c))])
@@ -5857,7 +5863,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool {
 	// match: (SUBV x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (SUBVconst [c] x)
@@ -5906,7 +5912,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool {
 	// match: (SUBVconst [0] x)
 	// cond:
 	// result: x
@@ -5974,7 +5980,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool {
 	// match: (XOR x (MOVVconst [c]))
 	// cond: is32Bit(c)
 	// result: (XORconst [c] x)
@@ -6025,7 +6031,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool {
 	// match: (XORconst [0] x)
 	// cond:
 	// result: x
@@ -6087,7 +6093,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMod16(v *Value) bool {
+func rewriteValueMIPS64_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6110,7 +6116,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod16u(v *Value) bool {
+func rewriteValueMIPS64_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6133,7 +6139,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod32(v *Value) bool {
+func rewriteValueMIPS64_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6156,7 +6162,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod32u(v *Value) bool {
+func rewriteValueMIPS64_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6179,7 +6185,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod64(v *Value) bool {
+func rewriteValueMIPS64_OpMod64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6198,7 +6204,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod64u(v *Value) bool {
+func rewriteValueMIPS64_OpMod64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6217,7 +6223,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod8(v *Value) bool {
+func rewriteValueMIPS64_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6240,7 +6246,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMod8u(v *Value) bool {
+func rewriteValueMIPS64_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6263,11 +6269,9 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMove(v *Value) bool {
+func rewriteValueMIPS64_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Move [0] _ _ mem)
@@ -6559,6 +6563,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [3] dst src mem)
 	// cond:
 	// result: (MOVBstore [2] dst (MOVBload [2] src mem) 		(MOVBstore [1] dst (MOVBload [1] src mem) 			(MOVBstore dst (MOVBload src mem) mem)))
@@ -6776,7 +6789,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpMul16(v *Value) bool {
+func rewriteValueMIPS64_OpMul16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6795,7 +6808,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMul32(v *Value) bool {
+func rewriteValueMIPS64_OpMul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6814,7 +6827,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMul32F(v *Value) bool {
+func rewriteValueMIPS64_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (MULF x y)
@@ -6827,7 +6840,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMul64(v *Value) bool {
+func rewriteValueMIPS64_OpMul64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6846,7 +6859,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMul64F(v *Value) bool {
+func rewriteValueMIPS64_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (MULD x y)
@@ -6859,7 +6872,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpMul8(v *Value) bool {
+func rewriteValueMIPS64_OpMul8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6878,7 +6891,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg16(v *Value) bool {
+func rewriteValueMIPS64_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEGV x)
@@ -6889,7 +6902,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg32(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEGV x)
@@ -6900,7 +6913,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (NEGF x)
@@ -6911,7 +6924,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg64(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 x)
 	// cond:
 	// result: (NEGV x)
@@ -6922,7 +6935,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (NEGD x)
@@ -6933,7 +6946,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeg8(v *Value) bool {
+func rewriteValueMIPS64_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEGV x)
@@ -6944,7 +6957,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq16(v *Value) bool {
+func rewriteValueMIPS64_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6970,7 +6983,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq32(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6996,7 +7009,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -7013,7 +7026,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq64(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7035,7 +7048,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -7052,7 +7065,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeq8(v *Value) bool {
+func rewriteValueMIPS64_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7078,7 +7091,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeqB(v *Value) bool {
+func rewriteValueMIPS64_OpNeqB_0(v *Value) bool {
 	// match: (NeqB x y)
 	// cond:
 	// result: (XOR x y)
@@ -7091,7 +7104,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNeqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7113,7 +7126,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNilCheck(v *Value) bool {
+func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -7126,7 +7139,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpNot(v *Value) bool {
+func rewriteValueMIPS64_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORconst [1] x)
@@ -7138,7 +7151,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOffPtr(v *Value) bool {
+func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr [off] ptr:(SP))
 	// cond:
 	// result: (MOVVaddr [off] ptr)
@@ -7165,7 +7178,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOr16(v *Value) bool {
+func rewriteValueMIPS64_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (OR x y)
@@ -7178,7 +7191,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOr32(v *Value) bool {
+func rewriteValueMIPS64_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (OR x y)
@@ -7191,7 +7204,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOr64(v *Value) bool {
+func rewriteValueMIPS64_OpOr64_0(v *Value) bool {
 	// match: (Or64 x y)
 	// cond:
 	// result: (OR x y)
@@ -7204,7 +7217,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOr8(v *Value) bool {
+func rewriteValueMIPS64_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (OR x y)
@@ -7217,7 +7230,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpOrB(v *Value) bool {
+func rewriteValueMIPS64_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (OR x y)
@@ -7230,7 +7243,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRound32F(v *Value) bool {
+func rewriteValueMIPS64_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: x
@@ -7242,7 +7255,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRound64F(v *Value) bool {
+func rewriteValueMIPS64_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: x
@@ -7254,7 +7267,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7288,7 +7301,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7322,7 +7335,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7352,7 +7365,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7386,7 +7399,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7420,7 +7433,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7454,7 +7467,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7484,7 +7497,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7518,7 +7531,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7552,7 +7565,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7586,7 +7599,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7616,7 +7629,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7650,7 +7663,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7684,7 +7697,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7718,7 +7731,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7748,7 +7761,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7782,7 +7795,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7814,7 +7827,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7846,7 +7859,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7874,7 +7887,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7906,7 +7919,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7938,7 +7951,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7970,7 +7983,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7998,7 +8011,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8030,7 +8043,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8064,7 +8077,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8098,7 +8111,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8128,7 +8141,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8162,7 +8175,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8196,7 +8209,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8230,7 +8243,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8260,7 +8273,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpRsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8294,7 +8307,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSelect0(v *Value) bool {
+func rewriteValueMIPS64_OpSelect0_0(v *Value) bool {
 	// match: (Select0 (DIVVU _ (MOVVconst [1])))
 	// cond:
 	// result: (MOVVconst [0])
@@ -8382,7 +8395,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpSelect1(v *Value) bool {
+func rewriteValueMIPS64_OpSelect1_0(v *Value) bool {
 	// match: (Select1 (MULVU x (MOVVconst [-1])))
 	// cond:
 	// result: (NEGV x)
@@ -8587,6 +8600,9 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpSelect1_10(v *Value) bool {
 	// match: (Select1 (MULVU (MOVVconst [0]) _))
 	// cond:
 	// result: (MOVVconst [0])
@@ -8798,6 +8814,9 @@
 		v.AuxInt = c * d
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpSelect1_20(v *Value) bool {
 	// match: (Select1 (DIVV (MOVVconst [c]) (MOVVconst [d])))
 	// cond:
 	// result: (MOVVconst [int64(c)/int64(d)])
@@ -8844,7 +8863,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -8855,7 +8874,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -8866,7 +8885,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 x)
 	// cond:
 	// result: (MOVWreg x)
@@ -8877,7 +8896,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -8888,7 +8907,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -8899,7 +8918,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -8910,7 +8929,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSlicemask(v *Value) bool {
+func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -8927,7 +8946,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpStaticCall(v *Value) bool {
+func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -8942,7 +8961,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpStore(v *Value) bool {
+func rewriteValueMIPS64_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 1
 	// result: (MOVBstore ptr val mem)
@@ -9047,7 +9066,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpSub16(v *Value) bool {
+func rewriteValueMIPS64_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUBV x y)
@@ -9060,7 +9079,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSub32(v *Value) bool {
+func rewriteValueMIPS64_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUBV x y)
@@ -9073,7 +9092,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSub32F(v *Value) bool {
+func rewriteValueMIPS64_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (SUBF x y)
@@ -9086,7 +9105,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSub64(v *Value) bool {
+func rewriteValueMIPS64_OpSub64_0(v *Value) bool {
 	// match: (Sub64 x y)
 	// cond:
 	// result: (SUBV x y)
@@ -9099,7 +9118,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSub64F(v *Value) bool {
+func rewriteValueMIPS64_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (SUBD x y)
@@ -9112,7 +9131,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSub8(v *Value) bool {
+func rewriteValueMIPS64_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUBV x y)
@@ -9125,7 +9144,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpSubPtr(v *Value) bool {
+func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUBV x y)
@@ -9138,7 +9157,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -9150,7 +9169,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -9162,7 +9181,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -9174,7 +9193,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 x)
 	// cond:
 	// result: x
@@ -9186,7 +9205,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 x)
 	// cond:
 	// result: x
@@ -9198,7 +9217,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 x)
 	// cond:
 	// result: x
@@ -9210,7 +9229,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpXor16(v *Value) bool {
+func rewriteValueMIPS64_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XOR x y)
@@ -9223,7 +9242,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpXor32(v *Value) bool {
+func rewriteValueMIPS64_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XOR x y)
@@ -9236,7 +9255,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpXor64(v *Value) bool {
+func rewriteValueMIPS64_OpXor64_0(v *Value) bool {
 	// match: (Xor64 x y)
 	// cond:
 	// result: (XOR x y)
@@ -9249,7 +9268,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpXor8(v *Value) bool {
+func rewriteValueMIPS64_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XOR x y)
@@ -9262,11 +9281,9 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZero(v *Value) bool {
+func rewriteValueMIPS64_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
-	config := b.Func.Config
-	_ = config
 	types := &b.Func.Config.Types
 	_ = types
 	// match: (Zero [0] _ mem)
@@ -9527,6 +9544,15 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueMIPS64_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Zero [3] ptr mem)
 	// cond:
 	// result: (MOVBstore [2] ptr (MOVVconst [0]) 		(MOVBstore [1] ptr (MOVVconst [0]) 			(MOVBstore [0] ptr (MOVVconst [0]) mem)))
@@ -9736,7 +9762,7 @@
 	}
 	return false
 }
-func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -9747,7 +9773,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 x)
 	// cond:
 	// result: (MOVHUreg x)
@@ -9758,7 +9784,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 x)
 	// cond:
 	// result: (MOVWUreg x)
@@ -9769,7 +9795,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -9780,7 +9806,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBUreg x)
@@ -9791,7 +9817,7 @@
 		return true
 	}
 }
-func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 x)
 	// cond:
 	// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 8788020..70f8de1 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -14,595 +14,595 @@
 func rewriteValuePPC64(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValuePPC64_OpAdd16(v)
+		return rewriteValuePPC64_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValuePPC64_OpAdd32(v)
+		return rewriteValuePPC64_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValuePPC64_OpAdd32F(v)
+		return rewriteValuePPC64_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValuePPC64_OpAdd64(v)
+		return rewriteValuePPC64_OpAdd64_0(v)
 	case OpAdd64F:
-		return rewriteValuePPC64_OpAdd64F(v)
+		return rewriteValuePPC64_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValuePPC64_OpAdd8(v)
+		return rewriteValuePPC64_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValuePPC64_OpAddPtr(v)
+		return rewriteValuePPC64_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValuePPC64_OpAddr(v)
+		return rewriteValuePPC64_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValuePPC64_OpAnd16(v)
+		return rewriteValuePPC64_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValuePPC64_OpAnd32(v)
+		return rewriteValuePPC64_OpAnd32_0(v)
 	case OpAnd64:
-		return rewriteValuePPC64_OpAnd64(v)
+		return rewriteValuePPC64_OpAnd64_0(v)
 	case OpAnd8:
-		return rewriteValuePPC64_OpAnd8(v)
+		return rewriteValuePPC64_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValuePPC64_OpAndB(v)
+		return rewriteValuePPC64_OpAndB_0(v)
 	case OpAtomicAdd32:
-		return rewriteValuePPC64_OpAtomicAdd32(v)
+		return rewriteValuePPC64_OpAtomicAdd32_0(v)
 	case OpAtomicAdd64:
-		return rewriteValuePPC64_OpAtomicAdd64(v)
+		return rewriteValuePPC64_OpAtomicAdd64_0(v)
 	case OpAtomicAnd8:
-		return rewriteValuePPC64_OpAtomicAnd8(v)
+		return rewriteValuePPC64_OpAtomicAnd8_0(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValuePPC64_OpAtomicCompareAndSwap32(v)
+		return rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v)
 	case OpAtomicCompareAndSwap64:
-		return rewriteValuePPC64_OpAtomicCompareAndSwap64(v)
+		return rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v)
 	case OpAtomicExchange32:
-		return rewriteValuePPC64_OpAtomicExchange32(v)
+		return rewriteValuePPC64_OpAtomicExchange32_0(v)
 	case OpAtomicExchange64:
-		return rewriteValuePPC64_OpAtomicExchange64(v)
+		return rewriteValuePPC64_OpAtomicExchange64_0(v)
 	case OpAtomicLoad32:
-		return rewriteValuePPC64_OpAtomicLoad32(v)
+		return rewriteValuePPC64_OpAtomicLoad32_0(v)
 	case OpAtomicLoad64:
-		return rewriteValuePPC64_OpAtomicLoad64(v)
+		return rewriteValuePPC64_OpAtomicLoad64_0(v)
 	case OpAtomicLoadPtr:
-		return rewriteValuePPC64_OpAtomicLoadPtr(v)
+		return rewriteValuePPC64_OpAtomicLoadPtr_0(v)
 	case OpAtomicOr8:
-		return rewriteValuePPC64_OpAtomicOr8(v)
+		return rewriteValuePPC64_OpAtomicOr8_0(v)
 	case OpAtomicStore32:
-		return rewriteValuePPC64_OpAtomicStore32(v)
+		return rewriteValuePPC64_OpAtomicStore32_0(v)
 	case OpAtomicStore64:
-		return rewriteValuePPC64_OpAtomicStore64(v)
+		return rewriteValuePPC64_OpAtomicStore64_0(v)
 	case OpAvg64u:
-		return rewriteValuePPC64_OpAvg64u(v)
+		return rewriteValuePPC64_OpAvg64u_0(v)
 	case OpClosureCall:
-		return rewriteValuePPC64_OpClosureCall(v)
+		return rewriteValuePPC64_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValuePPC64_OpCom16(v)
+		return rewriteValuePPC64_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValuePPC64_OpCom32(v)
+		return rewriteValuePPC64_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValuePPC64_OpCom64(v)
+		return rewriteValuePPC64_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValuePPC64_OpCom8(v)
+		return rewriteValuePPC64_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValuePPC64_OpConst16(v)
+		return rewriteValuePPC64_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValuePPC64_OpConst32(v)
+		return rewriteValuePPC64_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValuePPC64_OpConst32F(v)
+		return rewriteValuePPC64_OpConst32F_0(v)
 	case OpConst64:
-		return rewriteValuePPC64_OpConst64(v)
+		return rewriteValuePPC64_OpConst64_0(v)
 	case OpConst64F:
-		return rewriteValuePPC64_OpConst64F(v)
+		return rewriteValuePPC64_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValuePPC64_OpConst8(v)
+		return rewriteValuePPC64_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValuePPC64_OpConstBool(v)
+		return rewriteValuePPC64_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValuePPC64_OpConstNil(v)
+		return rewriteValuePPC64_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValuePPC64_OpConvert(v)
+		return rewriteValuePPC64_OpConvert_0(v)
 	case OpCvt32Fto32:
-		return rewriteValuePPC64_OpCvt32Fto32(v)
+		return rewriteValuePPC64_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64:
-		return rewriteValuePPC64_OpCvt32Fto64(v)
+		return rewriteValuePPC64_OpCvt32Fto64_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValuePPC64_OpCvt32Fto64F(v)
+		return rewriteValuePPC64_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValuePPC64_OpCvt32to32F(v)
+		return rewriteValuePPC64_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValuePPC64_OpCvt32to64F(v)
+		return rewriteValuePPC64_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValuePPC64_OpCvt64Fto32(v)
+		return rewriteValuePPC64_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValuePPC64_OpCvt64Fto32F(v)
+		return rewriteValuePPC64_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto64:
-		return rewriteValuePPC64_OpCvt64Fto64(v)
+		return rewriteValuePPC64_OpCvt64Fto64_0(v)
 	case OpCvt64to32F:
-		return rewriteValuePPC64_OpCvt64to32F(v)
+		return rewriteValuePPC64_OpCvt64to32F_0(v)
 	case OpCvt64to64F:
-		return rewriteValuePPC64_OpCvt64to64F(v)
+		return rewriteValuePPC64_OpCvt64to64F_0(v)
 	case OpDiv16:
-		return rewriteValuePPC64_OpDiv16(v)
+		return rewriteValuePPC64_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValuePPC64_OpDiv16u(v)
+		return rewriteValuePPC64_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValuePPC64_OpDiv32(v)
+		return rewriteValuePPC64_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValuePPC64_OpDiv32F(v)
+		return rewriteValuePPC64_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValuePPC64_OpDiv32u(v)
+		return rewriteValuePPC64_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValuePPC64_OpDiv64(v)
+		return rewriteValuePPC64_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValuePPC64_OpDiv64F(v)
+		return rewriteValuePPC64_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValuePPC64_OpDiv64u(v)
+		return rewriteValuePPC64_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValuePPC64_OpDiv8(v)
+		return rewriteValuePPC64_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValuePPC64_OpDiv8u(v)
+		return rewriteValuePPC64_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValuePPC64_OpEq16(v)
+		return rewriteValuePPC64_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValuePPC64_OpEq32(v)
+		return rewriteValuePPC64_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValuePPC64_OpEq32F(v)
+		return rewriteValuePPC64_OpEq32F_0(v)
 	case OpEq64:
-		return rewriteValuePPC64_OpEq64(v)
+		return rewriteValuePPC64_OpEq64_0(v)
 	case OpEq64F:
-		return rewriteValuePPC64_OpEq64F(v)
+		return rewriteValuePPC64_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValuePPC64_OpEq8(v)
+		return rewriteValuePPC64_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValuePPC64_OpEqB(v)
+		return rewriteValuePPC64_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValuePPC64_OpEqPtr(v)
+		return rewriteValuePPC64_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValuePPC64_OpGeq16(v)
+		return rewriteValuePPC64_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValuePPC64_OpGeq16U(v)
+		return rewriteValuePPC64_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValuePPC64_OpGeq32(v)
+		return rewriteValuePPC64_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValuePPC64_OpGeq32F(v)
+		return rewriteValuePPC64_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValuePPC64_OpGeq32U(v)
+		return rewriteValuePPC64_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValuePPC64_OpGeq64(v)
+		return rewriteValuePPC64_OpGeq64_0(v)
 	case OpGeq64F:
-		return rewriteValuePPC64_OpGeq64F(v)
+		return rewriteValuePPC64_OpGeq64F_0(v)
 	case OpGeq64U:
-		return rewriteValuePPC64_OpGeq64U(v)
+		return rewriteValuePPC64_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValuePPC64_OpGeq8(v)
+		return rewriteValuePPC64_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValuePPC64_OpGeq8U(v)
+		return rewriteValuePPC64_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValuePPC64_OpGetClosurePtr(v)
+		return rewriteValuePPC64_OpGetClosurePtr_0(v)
 	case OpGreater16:
-		return rewriteValuePPC64_OpGreater16(v)
+		return rewriteValuePPC64_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValuePPC64_OpGreater16U(v)
+		return rewriteValuePPC64_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValuePPC64_OpGreater32(v)
+		return rewriteValuePPC64_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValuePPC64_OpGreater32F(v)
+		return rewriteValuePPC64_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValuePPC64_OpGreater32U(v)
+		return rewriteValuePPC64_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValuePPC64_OpGreater64(v)
+		return rewriteValuePPC64_OpGreater64_0(v)
 	case OpGreater64F:
-		return rewriteValuePPC64_OpGreater64F(v)
+		return rewriteValuePPC64_OpGreater64F_0(v)
 	case OpGreater64U:
-		return rewriteValuePPC64_OpGreater64U(v)
+		return rewriteValuePPC64_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValuePPC64_OpGreater8(v)
+		return rewriteValuePPC64_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValuePPC64_OpGreater8U(v)
+		return rewriteValuePPC64_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValuePPC64_OpHmul32(v)
+		return rewriteValuePPC64_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValuePPC64_OpHmul32u(v)
+		return rewriteValuePPC64_OpHmul32u_0(v)
 	case OpHmul64:
-		return rewriteValuePPC64_OpHmul64(v)
+		return rewriteValuePPC64_OpHmul64_0(v)
 	case OpHmul64u:
-		return rewriteValuePPC64_OpHmul64u(v)
+		return rewriteValuePPC64_OpHmul64u_0(v)
 	case OpInterCall:
-		return rewriteValuePPC64_OpInterCall(v)
+		return rewriteValuePPC64_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValuePPC64_OpIsInBounds(v)
+		return rewriteValuePPC64_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValuePPC64_OpIsNonNil(v)
+		return rewriteValuePPC64_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValuePPC64_OpIsSliceInBounds(v)
+		return rewriteValuePPC64_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValuePPC64_OpLeq16(v)
+		return rewriteValuePPC64_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValuePPC64_OpLeq16U(v)
+		return rewriteValuePPC64_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValuePPC64_OpLeq32(v)
+		return rewriteValuePPC64_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValuePPC64_OpLeq32F(v)
+		return rewriteValuePPC64_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValuePPC64_OpLeq32U(v)
+		return rewriteValuePPC64_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValuePPC64_OpLeq64(v)
+		return rewriteValuePPC64_OpLeq64_0(v)
 	case OpLeq64F:
-		return rewriteValuePPC64_OpLeq64F(v)
+		return rewriteValuePPC64_OpLeq64F_0(v)
 	case OpLeq64U:
-		return rewriteValuePPC64_OpLeq64U(v)
+		return rewriteValuePPC64_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValuePPC64_OpLeq8(v)
+		return rewriteValuePPC64_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValuePPC64_OpLeq8U(v)
+		return rewriteValuePPC64_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValuePPC64_OpLess16(v)
+		return rewriteValuePPC64_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValuePPC64_OpLess16U(v)
+		return rewriteValuePPC64_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValuePPC64_OpLess32(v)
+		return rewriteValuePPC64_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValuePPC64_OpLess32F(v)
+		return rewriteValuePPC64_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValuePPC64_OpLess32U(v)
+		return rewriteValuePPC64_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValuePPC64_OpLess64(v)
+		return rewriteValuePPC64_OpLess64_0(v)
 	case OpLess64F:
-		return rewriteValuePPC64_OpLess64F(v)
+		return rewriteValuePPC64_OpLess64F_0(v)
 	case OpLess64U:
-		return rewriteValuePPC64_OpLess64U(v)
+		return rewriteValuePPC64_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValuePPC64_OpLess8(v)
+		return rewriteValuePPC64_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValuePPC64_OpLess8U(v)
+		return rewriteValuePPC64_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValuePPC64_OpLoad(v)
+		return rewriteValuePPC64_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValuePPC64_OpLsh16x16(v)
+		return rewriteValuePPC64_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValuePPC64_OpLsh16x32(v)
+		return rewriteValuePPC64_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValuePPC64_OpLsh16x64(v)
+		return rewriteValuePPC64_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValuePPC64_OpLsh16x8(v)
+		return rewriteValuePPC64_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValuePPC64_OpLsh32x16(v)
+		return rewriteValuePPC64_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValuePPC64_OpLsh32x32(v)
+		return rewriteValuePPC64_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValuePPC64_OpLsh32x64(v)
+		return rewriteValuePPC64_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValuePPC64_OpLsh32x8(v)
+		return rewriteValuePPC64_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValuePPC64_OpLsh64x16(v)
+		return rewriteValuePPC64_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValuePPC64_OpLsh64x32(v)
+		return rewriteValuePPC64_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValuePPC64_OpLsh64x64(v)
+		return rewriteValuePPC64_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValuePPC64_OpLsh64x8(v)
+		return rewriteValuePPC64_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValuePPC64_OpLsh8x16(v)
+		return rewriteValuePPC64_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValuePPC64_OpLsh8x32(v)
+		return rewriteValuePPC64_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValuePPC64_OpLsh8x64(v)
+		return rewriteValuePPC64_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValuePPC64_OpLsh8x8(v)
+		return rewriteValuePPC64_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValuePPC64_OpMod16(v)
+		return rewriteValuePPC64_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValuePPC64_OpMod16u(v)
+		return rewriteValuePPC64_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValuePPC64_OpMod32(v)
+		return rewriteValuePPC64_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValuePPC64_OpMod32u(v)
+		return rewriteValuePPC64_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValuePPC64_OpMod64(v)
+		return rewriteValuePPC64_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValuePPC64_OpMod64u(v)
+		return rewriteValuePPC64_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValuePPC64_OpMod8(v)
+		return rewriteValuePPC64_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValuePPC64_OpMod8u(v)
+		return rewriteValuePPC64_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValuePPC64_OpMove(v)
+		return rewriteValuePPC64_OpMove_0(v) || rewriteValuePPC64_OpMove_10(v)
 	case OpMul16:
-		return rewriteValuePPC64_OpMul16(v)
+		return rewriteValuePPC64_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValuePPC64_OpMul32(v)
+		return rewriteValuePPC64_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValuePPC64_OpMul32F(v)
+		return rewriteValuePPC64_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValuePPC64_OpMul64(v)
+		return rewriteValuePPC64_OpMul64_0(v)
 	case OpMul64F:
-		return rewriteValuePPC64_OpMul64F(v)
+		return rewriteValuePPC64_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValuePPC64_OpMul8(v)
+		return rewriteValuePPC64_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValuePPC64_OpNeg16(v)
+		return rewriteValuePPC64_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValuePPC64_OpNeg32(v)
+		return rewriteValuePPC64_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValuePPC64_OpNeg32F(v)
+		return rewriteValuePPC64_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValuePPC64_OpNeg64(v)
+		return rewriteValuePPC64_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValuePPC64_OpNeg64F(v)
+		return rewriteValuePPC64_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValuePPC64_OpNeg8(v)
+		return rewriteValuePPC64_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValuePPC64_OpNeq16(v)
+		return rewriteValuePPC64_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValuePPC64_OpNeq32(v)
+		return rewriteValuePPC64_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValuePPC64_OpNeq32F(v)
+		return rewriteValuePPC64_OpNeq32F_0(v)
 	case OpNeq64:
-		return rewriteValuePPC64_OpNeq64(v)
+		return rewriteValuePPC64_OpNeq64_0(v)
 	case OpNeq64F:
-		return rewriteValuePPC64_OpNeq64F(v)
+		return rewriteValuePPC64_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValuePPC64_OpNeq8(v)
+		return rewriteValuePPC64_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValuePPC64_OpNeqB(v)
+		return rewriteValuePPC64_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValuePPC64_OpNeqPtr(v)
+		return rewriteValuePPC64_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValuePPC64_OpNilCheck(v)
+		return rewriteValuePPC64_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValuePPC64_OpNot(v)
+		return rewriteValuePPC64_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValuePPC64_OpOffPtr(v)
+		return rewriteValuePPC64_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValuePPC64_OpOr16(v)
+		return rewriteValuePPC64_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValuePPC64_OpOr32(v)
+		return rewriteValuePPC64_OpOr32_0(v)
 	case OpOr64:
-		return rewriteValuePPC64_OpOr64(v)
+		return rewriteValuePPC64_OpOr64_0(v)
 	case OpOr8:
-		return rewriteValuePPC64_OpOr8(v)
+		return rewriteValuePPC64_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValuePPC64_OpOrB(v)
+		return rewriteValuePPC64_OpOrB_0(v)
 	case OpPPC64ADD:
-		return rewriteValuePPC64_OpPPC64ADD(v)
+		return rewriteValuePPC64_OpPPC64ADD_0(v)
 	case OpPPC64ADDconst:
-		return rewriteValuePPC64_OpPPC64ADDconst(v)
+		return rewriteValuePPC64_OpPPC64ADDconst_0(v)
 	case OpPPC64AND:
-		return rewriteValuePPC64_OpPPC64AND(v)
+		return rewriteValuePPC64_OpPPC64AND_0(v)
 	case OpPPC64ANDconst:
-		return rewriteValuePPC64_OpPPC64ANDconst(v)
+		return rewriteValuePPC64_OpPPC64ANDconst_0(v)
 	case OpPPC64CMP:
-		return rewriteValuePPC64_OpPPC64CMP(v)
+		return rewriteValuePPC64_OpPPC64CMP_0(v)
 	case OpPPC64CMPU:
-		return rewriteValuePPC64_OpPPC64CMPU(v)
+		return rewriteValuePPC64_OpPPC64CMPU_0(v)
 	case OpPPC64CMPUconst:
-		return rewriteValuePPC64_OpPPC64CMPUconst(v)
+		return rewriteValuePPC64_OpPPC64CMPUconst_0(v)
 	case OpPPC64CMPW:
-		return rewriteValuePPC64_OpPPC64CMPW(v)
+		return rewriteValuePPC64_OpPPC64CMPW_0(v)
 	case OpPPC64CMPWU:
-		return rewriteValuePPC64_OpPPC64CMPWU(v)
+		return rewriteValuePPC64_OpPPC64CMPWU_0(v)
 	case OpPPC64CMPWUconst:
-		return rewriteValuePPC64_OpPPC64CMPWUconst(v)
+		return rewriteValuePPC64_OpPPC64CMPWUconst_0(v)
 	case OpPPC64CMPWconst:
-		return rewriteValuePPC64_OpPPC64CMPWconst(v)
+		return rewriteValuePPC64_OpPPC64CMPWconst_0(v)
 	case OpPPC64CMPconst:
-		return rewriteValuePPC64_OpPPC64CMPconst(v)
+		return rewriteValuePPC64_OpPPC64CMPconst_0(v)
 	case OpPPC64Equal:
-		return rewriteValuePPC64_OpPPC64Equal(v)
+		return rewriteValuePPC64_OpPPC64Equal_0(v)
 	case OpPPC64FADD:
-		return rewriteValuePPC64_OpPPC64FADD(v)
+		return rewriteValuePPC64_OpPPC64FADD_0(v)
 	case OpPPC64FADDS:
-		return rewriteValuePPC64_OpPPC64FADDS(v)
+		return rewriteValuePPC64_OpPPC64FADDS_0(v)
 	case OpPPC64FMOVDload:
-		return rewriteValuePPC64_OpPPC64FMOVDload(v)
+		return rewriteValuePPC64_OpPPC64FMOVDload_0(v)
 	case OpPPC64FMOVDstore:
-		return rewriteValuePPC64_OpPPC64FMOVDstore(v)
+		return rewriteValuePPC64_OpPPC64FMOVDstore_0(v)
 	case OpPPC64FMOVSload:
-		return rewriteValuePPC64_OpPPC64FMOVSload(v)
+		return rewriteValuePPC64_OpPPC64FMOVSload_0(v)
 	case OpPPC64FMOVSstore:
-		return rewriteValuePPC64_OpPPC64FMOVSstore(v)
+		return rewriteValuePPC64_OpPPC64FMOVSstore_0(v)
 	case OpPPC64FSUB:
-		return rewriteValuePPC64_OpPPC64FSUB(v)
+		return rewriteValuePPC64_OpPPC64FSUB_0(v)
 	case OpPPC64FSUBS:
-		return rewriteValuePPC64_OpPPC64FSUBS(v)
+		return rewriteValuePPC64_OpPPC64FSUBS_0(v)
 	case OpPPC64GreaterEqual:
-		return rewriteValuePPC64_OpPPC64GreaterEqual(v)
+		return rewriteValuePPC64_OpPPC64GreaterEqual_0(v)
 	case OpPPC64GreaterThan:
-		return rewriteValuePPC64_OpPPC64GreaterThan(v)
+		return rewriteValuePPC64_OpPPC64GreaterThan_0(v)
 	case OpPPC64LessEqual:
-		return rewriteValuePPC64_OpPPC64LessEqual(v)
+		return rewriteValuePPC64_OpPPC64LessEqual_0(v)
 	case OpPPC64LessThan:
-		return rewriteValuePPC64_OpPPC64LessThan(v)
+		return rewriteValuePPC64_OpPPC64LessThan_0(v)
 	case OpPPC64MOVBZload:
-		return rewriteValuePPC64_OpPPC64MOVBZload(v)
+		return rewriteValuePPC64_OpPPC64MOVBZload_0(v)
 	case OpPPC64MOVBZreg:
-		return rewriteValuePPC64_OpPPC64MOVBZreg(v)
+		return rewriteValuePPC64_OpPPC64MOVBZreg_0(v)
 	case OpPPC64MOVBreg:
-		return rewriteValuePPC64_OpPPC64MOVBreg(v)
+		return rewriteValuePPC64_OpPPC64MOVBreg_0(v)
 	case OpPPC64MOVBstore:
-		return rewriteValuePPC64_OpPPC64MOVBstore(v)
+		return rewriteValuePPC64_OpPPC64MOVBstore_0(v)
 	case OpPPC64MOVBstorezero:
-		return rewriteValuePPC64_OpPPC64MOVBstorezero(v)
+		return rewriteValuePPC64_OpPPC64MOVBstorezero_0(v)
 	case OpPPC64MOVDload:
-		return rewriteValuePPC64_OpPPC64MOVDload(v)
+		return rewriteValuePPC64_OpPPC64MOVDload_0(v)
 	case OpPPC64MOVDstore:
-		return rewriteValuePPC64_OpPPC64MOVDstore(v)
+		return rewriteValuePPC64_OpPPC64MOVDstore_0(v)
 	case OpPPC64MOVDstorezero:
-		return rewriteValuePPC64_OpPPC64MOVDstorezero(v)
+		return rewriteValuePPC64_OpPPC64MOVDstorezero_0(v)
 	case OpPPC64MOVHZload:
-		return rewriteValuePPC64_OpPPC64MOVHZload(v)
+		return rewriteValuePPC64_OpPPC64MOVHZload_0(v)
 	case OpPPC64MOVHZreg:
-		return rewriteValuePPC64_OpPPC64MOVHZreg(v)
+		return rewriteValuePPC64_OpPPC64MOVHZreg_0(v)
 	case OpPPC64MOVHload:
-		return rewriteValuePPC64_OpPPC64MOVHload(v)
+		return rewriteValuePPC64_OpPPC64MOVHload_0(v)
 	case OpPPC64MOVHreg:
-		return rewriteValuePPC64_OpPPC64MOVHreg(v)
+		return rewriteValuePPC64_OpPPC64MOVHreg_0(v)
 	case OpPPC64MOVHstore:
-		return rewriteValuePPC64_OpPPC64MOVHstore(v)
+		return rewriteValuePPC64_OpPPC64MOVHstore_0(v)
 	case OpPPC64MOVHstorezero:
-		return rewriteValuePPC64_OpPPC64MOVHstorezero(v)
+		return rewriteValuePPC64_OpPPC64MOVHstorezero_0(v)
 	case OpPPC64MOVWZload:
-		return rewriteValuePPC64_OpPPC64MOVWZload(v)
+		return rewriteValuePPC64_OpPPC64MOVWZload_0(v)
 	case OpPPC64MOVWZreg:
-		return rewriteValuePPC64_OpPPC64MOVWZreg(v)
+		return rewriteValuePPC64_OpPPC64MOVWZreg_0(v)
 	case OpPPC64MOVWload:
-		return rewriteValuePPC64_OpPPC64MOVWload(v)
+		return rewriteValuePPC64_OpPPC64MOVWload_0(v)
 	case OpPPC64MOVWreg:
-		return rewriteValuePPC64_OpPPC64MOVWreg(v)
+		return rewriteValuePPC64_OpPPC64MOVWreg_0(v)
 	case OpPPC64MOVWstore:
-		return rewriteValuePPC64_OpPPC64MOVWstore(v)
+		return rewriteValuePPC64_OpPPC64MOVWstore_0(v)
 	case OpPPC64MOVWstorezero:
-		return rewriteValuePPC64_OpPPC64MOVWstorezero(v)
+		return rewriteValuePPC64_OpPPC64MOVWstorezero_0(v)
 	case OpPPC64MaskIfNotCarry:
-		return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v)
+		return rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v)
 	case OpPPC64NotEqual:
-		return rewriteValuePPC64_OpPPC64NotEqual(v)
+		return rewriteValuePPC64_OpPPC64NotEqual_0(v)
 	case OpPPC64OR:
-		return rewriteValuePPC64_OpPPC64OR(v)
+		return rewriteValuePPC64_OpPPC64OR_0(v)
 	case OpPPC64ORN:
-		return rewriteValuePPC64_OpPPC64ORN(v)
+		return rewriteValuePPC64_OpPPC64ORN_0(v)
 	case OpPPC64ORconst:
-		return rewriteValuePPC64_OpPPC64ORconst(v)
+		return rewriteValuePPC64_OpPPC64ORconst_0(v)
 	case OpPPC64SUB:
-		return rewriteValuePPC64_OpPPC64SUB(v)
+		return rewriteValuePPC64_OpPPC64SUB_0(v)
 	case OpPPC64XOR:
-		return rewriteValuePPC64_OpPPC64XOR(v)
+		return rewriteValuePPC64_OpPPC64XOR_0(v)
 	case OpPPC64XORconst:
-		return rewriteValuePPC64_OpPPC64XORconst(v)
+		return rewriteValuePPC64_OpPPC64XORconst_0(v)
 	case OpRound32F:
-		return rewriteValuePPC64_OpRound32F(v)
+		return rewriteValuePPC64_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValuePPC64_OpRound64F(v)
+		return rewriteValuePPC64_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValuePPC64_OpRsh16Ux16(v)
+		return rewriteValuePPC64_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValuePPC64_OpRsh16Ux32(v)
+		return rewriteValuePPC64_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValuePPC64_OpRsh16Ux64(v)
+		return rewriteValuePPC64_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValuePPC64_OpRsh16Ux8(v)
+		return rewriteValuePPC64_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValuePPC64_OpRsh16x16(v)
+		return rewriteValuePPC64_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValuePPC64_OpRsh16x32(v)
+		return rewriteValuePPC64_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValuePPC64_OpRsh16x64(v)
+		return rewriteValuePPC64_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValuePPC64_OpRsh16x8(v)
+		return rewriteValuePPC64_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValuePPC64_OpRsh32Ux16(v)
+		return rewriteValuePPC64_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValuePPC64_OpRsh32Ux32(v)
+		return rewriteValuePPC64_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValuePPC64_OpRsh32Ux64(v)
+		return rewriteValuePPC64_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValuePPC64_OpRsh32Ux8(v)
+		return rewriteValuePPC64_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValuePPC64_OpRsh32x16(v)
+		return rewriteValuePPC64_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValuePPC64_OpRsh32x32(v)
+		return rewriteValuePPC64_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValuePPC64_OpRsh32x64(v)
+		return rewriteValuePPC64_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValuePPC64_OpRsh32x8(v)
+		return rewriteValuePPC64_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValuePPC64_OpRsh64Ux16(v)
+		return rewriteValuePPC64_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValuePPC64_OpRsh64Ux32(v)
+		return rewriteValuePPC64_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValuePPC64_OpRsh64Ux64(v)
+		return rewriteValuePPC64_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValuePPC64_OpRsh64Ux8(v)
+		return rewriteValuePPC64_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValuePPC64_OpRsh64x16(v)
+		return rewriteValuePPC64_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValuePPC64_OpRsh64x32(v)
+		return rewriteValuePPC64_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValuePPC64_OpRsh64x64(v)
+		return rewriteValuePPC64_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValuePPC64_OpRsh64x8(v)
+		return rewriteValuePPC64_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValuePPC64_OpRsh8Ux16(v)
+		return rewriteValuePPC64_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValuePPC64_OpRsh8Ux32(v)
+		return rewriteValuePPC64_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValuePPC64_OpRsh8Ux64(v)
+		return rewriteValuePPC64_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValuePPC64_OpRsh8Ux8(v)
+		return rewriteValuePPC64_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValuePPC64_OpRsh8x16(v)
+		return rewriteValuePPC64_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValuePPC64_OpRsh8x32(v)
+		return rewriteValuePPC64_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValuePPC64_OpRsh8x64(v)
+		return rewriteValuePPC64_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValuePPC64_OpRsh8x8(v)
+		return rewriteValuePPC64_OpRsh8x8_0(v)
 	case OpSignExt16to32:
-		return rewriteValuePPC64_OpSignExt16to32(v)
+		return rewriteValuePPC64_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValuePPC64_OpSignExt16to64(v)
+		return rewriteValuePPC64_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValuePPC64_OpSignExt32to64(v)
+		return rewriteValuePPC64_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValuePPC64_OpSignExt8to16(v)
+		return rewriteValuePPC64_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValuePPC64_OpSignExt8to32(v)
+		return rewriteValuePPC64_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValuePPC64_OpSignExt8to64(v)
+		return rewriteValuePPC64_OpSignExt8to64_0(v)
 	case OpSlicemask:
-		return rewriteValuePPC64_OpSlicemask(v)
+		return rewriteValuePPC64_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValuePPC64_OpSqrt(v)
+		return rewriteValuePPC64_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValuePPC64_OpStaticCall(v)
+		return rewriteValuePPC64_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValuePPC64_OpStore(v)
+		return rewriteValuePPC64_OpStore_0(v)
 	case OpSub16:
-		return rewriteValuePPC64_OpSub16(v)
+		return rewriteValuePPC64_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValuePPC64_OpSub32(v)
+		return rewriteValuePPC64_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValuePPC64_OpSub32F(v)
+		return rewriteValuePPC64_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValuePPC64_OpSub64(v)
+		return rewriteValuePPC64_OpSub64_0(v)
 	case OpSub64F:
-		return rewriteValuePPC64_OpSub64F(v)
+		return rewriteValuePPC64_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValuePPC64_OpSub8(v)
+		return rewriteValuePPC64_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValuePPC64_OpSubPtr(v)
+		return rewriteValuePPC64_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValuePPC64_OpTrunc16to8(v)
+		return rewriteValuePPC64_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValuePPC64_OpTrunc32to16(v)
+		return rewriteValuePPC64_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValuePPC64_OpTrunc32to8(v)
+		return rewriteValuePPC64_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValuePPC64_OpTrunc64to16(v)
+		return rewriteValuePPC64_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValuePPC64_OpTrunc64to32(v)
+		return rewriteValuePPC64_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValuePPC64_OpTrunc64to8(v)
+		return rewriteValuePPC64_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValuePPC64_OpXor16(v)
+		return rewriteValuePPC64_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValuePPC64_OpXor32(v)
+		return rewriteValuePPC64_OpXor32_0(v)
 	case OpXor64:
-		return rewriteValuePPC64_OpXor64(v)
+		return rewriteValuePPC64_OpXor64_0(v)
 	case OpXor8:
-		return rewriteValuePPC64_OpXor8(v)
+		return rewriteValuePPC64_OpXor8_0(v)
 	case OpZero:
-		return rewriteValuePPC64_OpZero(v)
+		return rewriteValuePPC64_OpZero_0(v) || rewriteValuePPC64_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValuePPC64_OpZeroExt16to32(v)
+		return rewriteValuePPC64_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValuePPC64_OpZeroExt16to64(v)
+		return rewriteValuePPC64_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValuePPC64_OpZeroExt32to64(v)
+		return rewriteValuePPC64_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValuePPC64_OpZeroExt8to16(v)
+		return rewriteValuePPC64_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValuePPC64_OpZeroExt8to32(v)
+		return rewriteValuePPC64_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValuePPC64_OpZeroExt8to64(v)
+		return rewriteValuePPC64_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValuePPC64_OpAdd16(v *Value) bool {
+func rewriteValuePPC64_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADD x y)
@@ -615,7 +615,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADD x y)
@@ -628,7 +628,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAdd32F(v *Value) bool {
+func rewriteValuePPC64_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (FADDS x y)
@@ -641,7 +641,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAdd64_0(v *Value) bool {
 	// match: (Add64 x y)
 	// cond:
 	// result: (ADD  x y)
@@ -654,7 +654,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAdd64F(v *Value) bool {
+func rewriteValuePPC64_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (FADD x y)
@@ -667,7 +667,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAdd8(v *Value) bool {
+func rewriteValuePPC64_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADD x y)
@@ -680,7 +680,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAddPtr(v *Value) bool {
+func rewriteValuePPC64_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADD  x y)
@@ -693,7 +693,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAddr(v *Value) bool {
+func rewriteValuePPC64_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVDaddr {sym} base)
@@ -706,7 +706,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAnd16(v *Value) bool {
+func rewriteValuePPC64_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (AND x y)
@@ -719,7 +719,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAnd32(v *Value) bool {
+func rewriteValuePPC64_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (AND x y)
@@ -732,7 +732,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAnd64(v *Value) bool {
+func rewriteValuePPC64_OpAnd64_0(v *Value) bool {
 	// match: (And64 x y)
 	// cond:
 	// result: (AND x y)
@@ -745,7 +745,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (AND x y)
@@ -758,7 +758,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAndB(v *Value) bool {
+func rewriteValuePPC64_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (AND x y)
@@ -771,7 +771,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool {
 	// match: (AtomicAdd32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAdd32 ptr val mem)
@@ -786,7 +786,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool {
 	// match: (AtomicAdd64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAdd64 ptr val mem)
@@ -801,7 +801,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool {
 	// match: (AtomicAnd8 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicAnd8 ptr val mem)
@@ -816,7 +816,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -833,7 +833,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -850,7 +850,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool {
 	// match: (AtomicExchange32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange32 ptr val mem)
@@ -865,7 +865,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool {
 	// match: (AtomicExchange64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange64 ptr val mem)
@@ -880,7 +880,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool {
 	// match: (AtomicLoad32 ptr mem)
 	// cond:
 	// result: (LoweredAtomicLoad32 ptr mem)
@@ -893,7 +893,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool {
 	// match: (AtomicLoad64 ptr mem)
 	// cond:
 	// result: (LoweredAtomicLoad64 ptr mem)
@@ -906,7 +906,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool {
 	// match: (AtomicLoadPtr ptr mem)
 	// cond:
 	// result: (LoweredAtomicLoadPtr ptr mem)
@@ -919,7 +919,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicOr8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool {
 	// match: (AtomicOr8 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicOr8  ptr val mem)
@@ -934,7 +934,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicStore32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool {
 	// match: (AtomicStore32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicStore32 ptr val mem)
@@ -949,7 +949,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAtomicStore64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool {
 	// match: (AtomicStore64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicStore64 ptr val mem)
@@ -964,7 +964,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpAvg64u(v *Value) bool {
+func rewriteValuePPC64_OpAvg64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg64u <t> x y)
@@ -986,7 +986,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpClosureCall(v *Value) bool {
+func rewriteValuePPC64_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -1003,7 +1003,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCom16(v *Value) bool {
+func rewriteValuePPC64_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (NOR x x)
@@ -1015,7 +1015,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCom32(v *Value) bool {
+func rewriteValuePPC64_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (NOR x x)
@@ -1027,7 +1027,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCom64(v *Value) bool {
+func rewriteValuePPC64_OpCom64_0(v *Value) bool {
 	// match: (Com64 x)
 	// cond:
 	// result: (NOR x x)
@@ -1039,7 +1039,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCom8(v *Value) bool {
+func rewriteValuePPC64_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (NOR x x)
@@ -1051,7 +1051,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst16(v *Value) bool {
+func rewriteValuePPC64_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1062,7 +1062,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst32(v *Value) bool {
+func rewriteValuePPC64_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1073,7 +1073,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst32F(v *Value) bool {
+func rewriteValuePPC64_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (FMOVSconst [val])
@@ -1084,7 +1084,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst64(v *Value) bool {
+func rewriteValuePPC64_OpConst64_0(v *Value) bool {
 	// match: (Const64 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1095,7 +1095,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst64F(v *Value) bool {
+func rewriteValuePPC64_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (FMOVDconst [val])
@@ -1106,7 +1106,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConst8(v *Value) bool {
+func rewriteValuePPC64_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1117,7 +1117,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConstBool(v *Value) bool {
+func rewriteValuePPC64_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVDconst [b])
@@ -1128,7 +1128,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConstNil(v *Value) bool {
+func rewriteValuePPC64_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVDconst [0])
@@ -1138,7 +1138,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpConvert(v *Value) bool {
+func rewriteValuePPC64_OpConvert_0(v *Value) bool {
 	// match: (Convert <t> x mem)
 	// cond:
 	// result: (MOVDconvert <t> x mem)
@@ -1153,7 +1153,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1170,7 +1170,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1187,7 +1187,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: x
@@ -1199,7 +1199,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt32to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1220,7 +1220,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt32to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1239,7 +1239,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1256,7 +1256,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (FRSP x)
@@ -1267,7 +1267,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1284,7 +1284,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt64to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1303,7 +1303,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpCvt64to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1320,7 +1320,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv16(v *Value) bool {
+func rewriteValuePPC64_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1341,7 +1341,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv16u(v *Value) bool {
+func rewriteValuePPC64_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1362,7 +1362,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv32(v *Value) bool {
+func rewriteValuePPC64_OpDiv32_0(v *Value) bool {
 	// match: (Div32 x y)
 	// cond:
 	// result: (DIVW  x y)
@@ -1375,7 +1375,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv32F(v *Value) bool {
+func rewriteValuePPC64_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (FDIVS x y)
@@ -1388,7 +1388,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv32u(v *Value) bool {
+func rewriteValuePPC64_OpDiv32u_0(v *Value) bool {
 	// match: (Div32u x y)
 	// cond:
 	// result: (DIVWU x y)
@@ -1401,7 +1401,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv64(v *Value) bool {
+func rewriteValuePPC64_OpDiv64_0(v *Value) bool {
 	// match: (Div64 x y)
 	// cond:
 	// result: (DIVD  x y)
@@ -1414,7 +1414,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv64F(v *Value) bool {
+func rewriteValuePPC64_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (FDIV x y)
@@ -1427,7 +1427,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv64u(v *Value) bool {
+func rewriteValuePPC64_OpDiv64u_0(v *Value) bool {
 	// match: (Div64u x y)
 	// cond:
 	// result: (DIVDU x y)
@@ -1440,7 +1440,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv8(v *Value) bool {
+func rewriteValuePPC64_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1461,7 +1461,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpDiv8u(v *Value) bool {
+func rewriteValuePPC64_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1482,7 +1482,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq16(v *Value) bool {
+func rewriteValuePPC64_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1525,7 +1525,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq32(v *Value) bool {
+func rewriteValuePPC64_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x y)
@@ -1542,7 +1542,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq32F(v *Value) bool {
+func rewriteValuePPC64_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32F x y)
@@ -1559,7 +1559,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq64(v *Value) bool {
+func rewriteValuePPC64_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64 x y)
@@ -1576,7 +1576,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq64F(v *Value) bool {
+func rewriteValuePPC64_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64F x y)
@@ -1593,7 +1593,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEq8(v *Value) bool {
+func rewriteValuePPC64_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1636,7 +1636,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEqB(v *Value) bool {
+func rewriteValuePPC64_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1656,7 +1656,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpEqPtr(v *Value) bool {
+func rewriteValuePPC64_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (EqPtr x y)
@@ -1673,7 +1673,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq16(v *Value) bool {
+func rewriteValuePPC64_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1696,7 +1696,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq16U(v *Value) bool {
+func rewriteValuePPC64_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1719,7 +1719,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq32(v *Value) bool {
+func rewriteValuePPC64_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32 x y)
@@ -1736,7 +1736,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq32F(v *Value) bool {
+func rewriteValuePPC64_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32F x y)
@@ -1753,7 +1753,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq32U(v *Value) bool {
+func rewriteValuePPC64_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq32U x y)
@@ -1770,7 +1770,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq64(v *Value) bool {
+func rewriteValuePPC64_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64 x y)
@@ -1787,7 +1787,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq64F(v *Value) bool {
+func rewriteValuePPC64_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64F x y)
@@ -1804,7 +1804,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq64U(v *Value) bool {
+func rewriteValuePPC64_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Geq64U x y)
@@ -1821,7 +1821,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq8(v *Value) bool {
+func rewriteValuePPC64_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1844,7 +1844,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGeq8U(v *Value) bool {
+func rewriteValuePPC64_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1867,7 +1867,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool {
+func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -1876,7 +1876,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater16(v *Value) bool {
+func rewriteValuePPC64_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1899,7 +1899,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater16U(v *Value) bool {
+func rewriteValuePPC64_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1922,7 +1922,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater32(v *Value) bool {
+func rewriteValuePPC64_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32 x y)
@@ -1939,7 +1939,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater32F(v *Value) bool {
+func rewriteValuePPC64_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32F x y)
@@ -1956,7 +1956,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater32U(v *Value) bool {
+func rewriteValuePPC64_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater32U x y)
@@ -1973,7 +1973,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater64(v *Value) bool {
+func rewriteValuePPC64_OpGreater64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64 x y)
@@ -1990,7 +1990,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater64F(v *Value) bool {
+func rewriteValuePPC64_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64F x y)
@@ -2007,7 +2007,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater64U(v *Value) bool {
+func rewriteValuePPC64_OpGreater64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Greater64U x y)
@@ -2024,7 +2024,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater8(v *Value) bool {
+func rewriteValuePPC64_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2047,7 +2047,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpGreater8U(v *Value) bool {
+func rewriteValuePPC64_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2070,7 +2070,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpHmul32(v *Value) bool {
+func rewriteValuePPC64_OpHmul32_0(v *Value) bool {
 	// match: (Hmul32 x y)
 	// cond:
 	// result: (MULHW  x y)
@@ -2083,7 +2083,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpHmul32u(v *Value) bool {
+func rewriteValuePPC64_OpHmul32u_0(v *Value) bool {
 	// match: (Hmul32u x y)
 	// cond:
 	// result: (MULHWU x y)
@@ -2096,7 +2096,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpHmul64(v *Value) bool {
+func rewriteValuePPC64_OpHmul64_0(v *Value) bool {
 	// match: (Hmul64 x y)
 	// cond:
 	// result: (MULHD  x y)
@@ -2109,7 +2109,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpHmul64u(v *Value) bool {
+func rewriteValuePPC64_OpHmul64u_0(v *Value) bool {
 	// match: (Hmul64u x y)
 	// cond:
 	// result: (MULHDU x y)
@@ -2122,7 +2122,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpInterCall(v *Value) bool {
+func rewriteValuePPC64_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -2137,7 +2137,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpIsInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsInBounds idx len)
@@ -2154,7 +2154,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpIsNonNil(v *Value) bool {
+func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsNonNil ptr)
@@ -2170,7 +2170,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (IsSliceInBounds idx len)
@@ -2187,7 +2187,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq16(v *Value) bool {
+func rewriteValuePPC64_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2210,7 +2210,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq16U(v *Value) bool {
+func rewriteValuePPC64_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2233,7 +2233,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq32(v *Value) bool {
+func rewriteValuePPC64_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32 x y)
@@ -2250,7 +2250,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq32F(v *Value) bool {
+func rewriteValuePPC64_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32F x y)
@@ -2267,7 +2267,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq32U(v *Value) bool {
+func rewriteValuePPC64_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq32U x y)
@@ -2284,7 +2284,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq64(v *Value) bool {
+func rewriteValuePPC64_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64 x y)
@@ -2301,7 +2301,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq64F(v *Value) bool {
+func rewriteValuePPC64_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64F x y)
@@ -2318,7 +2318,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq64U(v *Value) bool {
+func rewriteValuePPC64_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Leq64U x y)
@@ -2335,7 +2335,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq8(v *Value) bool {
+func rewriteValuePPC64_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2358,7 +2358,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLeq8U(v *Value) bool {
+func rewriteValuePPC64_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2381,7 +2381,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess16(v *Value) bool {
+func rewriteValuePPC64_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2404,7 +2404,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess16U(v *Value) bool {
+func rewriteValuePPC64_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2427,7 +2427,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess32(v *Value) bool {
+func rewriteValuePPC64_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32 x y)
@@ -2444,7 +2444,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess32F(v *Value) bool {
+func rewriteValuePPC64_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32F x y)
@@ -2461,7 +2461,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess32U(v *Value) bool {
+func rewriteValuePPC64_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less32U x y)
@@ -2478,7 +2478,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess64(v *Value) bool {
+func rewriteValuePPC64_OpLess64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64 x y)
@@ -2495,7 +2495,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess64F(v *Value) bool {
+func rewriteValuePPC64_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64F x y)
@@ -2512,7 +2512,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess64U(v *Value) bool {
+func rewriteValuePPC64_OpLess64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Less64U x y)
@@ -2529,7 +2529,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess8(v *Value) bool {
+func rewriteValuePPC64_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2552,7 +2552,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLess8U(v *Value) bool {
+func rewriteValuePPC64_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2575,7 +2575,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLoad(v *Value) bool {
+func rewriteValuePPC64_OpLoad_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2734,7 +2734,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpLsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2761,7 +2761,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2824,7 +2824,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2901,7 +2901,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2928,7 +2928,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2955,7 +2955,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3018,7 +3018,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3095,7 +3095,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3122,7 +3122,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3149,7 +3149,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3212,7 +3212,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3289,7 +3289,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3316,7 +3316,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3343,7 +3343,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3406,7 +3406,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3483,7 +3483,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpLsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3510,7 +3510,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod16(v *Value) bool {
+func rewriteValuePPC64_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3531,7 +3531,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod16u(v *Value) bool {
+func rewriteValuePPC64_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3552,7 +3552,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod32(v *Value) bool {
+func rewriteValuePPC64_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3575,7 +3575,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod32u(v *Value) bool {
+func rewriteValuePPC64_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3598,7 +3598,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod64(v *Value) bool {
+func rewriteValuePPC64_OpMod64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3621,7 +3621,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod64u(v *Value) bool {
+func rewriteValuePPC64_OpMod64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3644,7 +3644,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod8(v *Value) bool {
+func rewriteValuePPC64_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3665,7 +3665,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMod8u(v *Value) bool {
+func rewriteValuePPC64_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3686,7 +3686,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMove(v *Value) bool {
+func rewriteValuePPC64_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3933,6 +3933,9 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValuePPC64_OpMove_10(v *Value) bool {
 	// match: (Move [s] dst src mem)
 	// cond: s > 8
 	// result: (LoweredMove [s] dst src mem)
@@ -3953,7 +3956,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpMul16(v *Value) bool {
+func rewriteValuePPC64_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MULLW x y)
@@ -3966,7 +3969,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMul32(v *Value) bool {
+func rewriteValuePPC64_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MULLW  x y)
@@ -3979,7 +3982,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMul32F(v *Value) bool {
+func rewriteValuePPC64_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (FMULS x y)
@@ -3992,7 +3995,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMul64(v *Value) bool {
+func rewriteValuePPC64_OpMul64_0(v *Value) bool {
 	// match: (Mul64 x y)
 	// cond:
 	// result: (MULLD  x y)
@@ -4005,7 +4008,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMul64F(v *Value) bool {
+func rewriteValuePPC64_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (FMUL x y)
@@ -4018,7 +4021,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpMul8(v *Value) bool {
+func rewriteValuePPC64_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MULLW x y)
@@ -4031,7 +4034,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg16(v *Value) bool {
+func rewriteValuePPC64_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 x)
 	// cond:
 	// result: (NEG x)
@@ -4042,7 +4045,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg32(v *Value) bool {
+func rewriteValuePPC64_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEG x)
@@ -4053,7 +4056,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg32F(v *Value) bool {
+func rewriteValuePPC64_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (FNEG x)
@@ -4064,7 +4067,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg64(v *Value) bool {
+func rewriteValuePPC64_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 x)
 	// cond:
 	// result: (NEG x)
@@ -4075,7 +4078,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg64F(v *Value) bool {
+func rewriteValuePPC64_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (FNEG x)
@@ -4086,7 +4089,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeg8(v *Value) bool {
+func rewriteValuePPC64_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 x)
 	// cond:
 	// result: (NEG x)
@@ -4097,7 +4100,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq16(v *Value) bool {
+func rewriteValuePPC64_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4140,7 +4143,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq32(v *Value) bool {
+func rewriteValuePPC64_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x y)
@@ -4157,7 +4160,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq32F(v *Value) bool {
+func rewriteValuePPC64_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32F x y)
@@ -4174,7 +4177,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq64(v *Value) bool {
+func rewriteValuePPC64_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64 x y)
@@ -4191,7 +4194,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq64F(v *Value) bool {
+func rewriteValuePPC64_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64F x y)
@@ -4208,7 +4211,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeq8(v *Value) bool {
+func rewriteValuePPC64_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4251,7 +4254,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeqB(v *Value) bool {
+func rewriteValuePPC64_OpNeqB_0(v *Value) bool {
 	// match: (NeqB x y)
 	// cond:
 	// result: (XOR x y)
@@ -4264,7 +4267,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNeqPtr(v *Value) bool {
+func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (NeqPtr x y)
@@ -4281,7 +4284,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNilCheck(v *Value) bool {
+func rewriteValuePPC64_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -4294,7 +4297,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpNot(v *Value) bool {
+func rewriteValuePPC64_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORconst [1] x)
@@ -4306,7 +4309,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOffPtr(v *Value) bool {
+func rewriteValuePPC64_OpOffPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4325,7 +4328,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOr16(v *Value) bool {
+func rewriteValuePPC64_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (OR x y)
@@ -4338,7 +4341,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOr32(v *Value) bool {
+func rewriteValuePPC64_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (OR x y)
@@ -4351,7 +4354,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOr64(v *Value) bool {
+func rewriteValuePPC64_OpOr64_0(v *Value) bool {
 	// match: (Or64 x y)
 	// cond:
 	// result: (OR x y)
@@ -4364,7 +4367,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOr8(v *Value) bool {
+func rewriteValuePPC64_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (OR x y)
@@ -4377,7 +4380,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpOrB(v *Value) bool {
+func rewriteValuePPC64_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (OR x y)
@@ -4390,7 +4393,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool {
 	// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
 	// cond: d == 64-c
 	// result: (ROTLconst [c] x)
@@ -4533,7 +4536,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool {
 	// match: (ADDconst [c] (ADDconst [d] x))
 	// cond: is32Bit(c+d)
 	// result: (ADDconst [c+d] x)
@@ -4586,7 +4589,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64AND(v *Value) bool {
+func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool {
 	// match: (AND x (NOR y y))
 	// cond:
 	// result: (ANDN x y)
@@ -4769,7 +4772,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool {
 	// match: (ANDconst [c] (ANDconst [d] x))
 	// cond:
 	// result: (ANDconst [c&d] x)
@@ -4908,7 +4911,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMP x (MOVDconst [c]))
@@ -4951,7 +4954,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPU x (MOVDconst [c]))
@@ -4994,7 +4997,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool {
 	// match: (CMPUconst (MOVDconst [x]) [y])
 	// cond: int64(x)==int64(y)
 	// result: (FlagEQ)
@@ -5045,7 +5048,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPW x (MOVWreg y))
@@ -5118,7 +5121,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPWU x (MOVWZreg y))
@@ -5191,7 +5194,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool {
 	// match: (CMPWUconst (MOVDconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -5242,7 +5245,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool {
 	// match: (CMPWconst (MOVDconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -5293,7 +5296,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool {
 	// match: (CMPconst (MOVDconst [x]) [y])
 	// cond: int64(x)==int64(y)
 	// result: (FlagEQ)
@@ -5344,7 +5347,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64Equal(v *Value) bool {
+func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool {
 	// match: (Equal (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -5396,7 +5399,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool {
 	// match: (FADD (FMUL x y) z)
 	// cond:
 	// result: (FMADD x y z)
@@ -5433,7 +5436,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool {
 	// match: (FADDS (FMULS x y) z)
 	// cond:
 	// result: (FMADDS x y z)
@@ -5470,7 +5473,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool {
 	// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5520,7 +5523,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool {
 	// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -5574,7 +5577,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool {
 	// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5624,7 +5627,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool {
 	// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -5678,7 +5681,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool {
 	// match: (FSUB (FMUL x y) z)
 	// cond:
 	// result: (FMSUB x y z)
@@ -5698,7 +5701,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool {
 	// match: (FSUBS (FMULS x y) z)
 	// cond:
 	// result: (FMSUBS x y z)
@@ -5718,7 +5721,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool {
 	// match: (GreaterEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -5770,7 +5773,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool {
 	// match: (GreaterThan (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -5822,7 +5825,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool {
 	// match: (LessEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [1])
@@ -5874,7 +5877,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool {
 	// match: (LessThan (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -5926,7 +5929,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool {
 	// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5976,7 +5979,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool {
 	// match: (MOVBZreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0xFF
 	// result: y
@@ -6048,7 +6051,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool {
 	// match: (MOVBreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0x7F
 	// result: y
@@ -6107,7 +6110,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVBstore [off1+off2] {sym} x val mem)
@@ -6226,7 +6229,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool {
 	// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVBstorezero [off1+off2] {sym} x mem)
@@ -6276,7 +6279,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool {
 	// match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6326,7 +6329,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVDstore [off1+off2] {sym} x val mem)
@@ -6403,7 +6406,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool {
 	// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVDstorezero [off1+off2] {sym} x mem)
@@ -6453,7 +6456,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool {
 	// match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6503,7 +6506,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool {
 	// match: (MOVHZreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0xFFFF
 	// result: y
@@ -6588,7 +6591,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6638,7 +6641,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool {
 	// match: (MOVHreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0x7FFF
 	// result: y
@@ -6723,7 +6726,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVHstore [off1+off2] {sym} x val mem)
@@ -6842,7 +6845,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool {
 	// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVHstorezero [off1+off2] {sym} x mem)
@@ -6892,7 +6895,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool {
 	// match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6942,7 +6945,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool {
 	// match: (MOVWZreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0xFFFFFFFF
 	// result: y
@@ -7056,7 +7059,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool {
 	// match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
 	// cond: canMergeSym(sym1,sym2)
 	// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -7106,7 +7109,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool {
 	// match: (MOVWreg y:(ANDconst [c] _))
 	// cond: uint64(c) <= 0xFFFF
 	// result: y
@@ -7220,7 +7223,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVWstore [off1+off2] {sym} x val mem)
@@ -7339,7 +7342,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool {
 	// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
 	// cond: is16Bit(off1+off2)
 	// result: (MOVWstorezero [off1+off2] {sym} x mem)
@@ -7389,7 +7392,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool {
 	// match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _)))
 	// cond: c < 0 && d > 0 && c + d < 0
 	// result: (MOVDconst [-1])
@@ -7413,7 +7416,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool {
 	// match: (NotEqual (FlagEQ))
 	// cond:
 	// result: (MOVDconst [0])
@@ -7465,7 +7468,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool {
 	// match: (OR (SLDconst x [c]) (SRDconst x [d]))
 	// cond: d == 64-c
 	// result: (ROTLconst [c] x)
@@ -7644,7 +7647,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64ORN(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool {
 	// match: (ORN x (MOVDconst [-1]))
 	// cond:
 	// result: x
@@ -7664,7 +7667,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool {
 	// match: (ORconst [c] (ORconst [d] x))
 	// cond:
 	// result: (ORconst [c|d] x)
@@ -7707,7 +7710,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64SUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool {
 	// match: (SUB x (MOVDconst [c]))
 	// cond: is32Bit(-c)
 	// result: (ADDconst [-c] x)
@@ -7728,7 +7731,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64XOR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool {
 	// match: (XOR (SLDconst x [c]) (SRDconst x [d]))
 	// cond: d == 64-c
 	// result: (ROTLconst [c] x)
@@ -7907,7 +7910,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool {
 	// match: (XORconst [c] (XORconst [d] x))
 	// cond:
 	// result: (XORconst [c^d] x)
@@ -7939,7 +7942,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpRound32F(v *Value) bool {
+func rewriteValuePPC64_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: (LoweredRound32F x)
@@ -7950,7 +7953,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRound64F(v *Value) bool {
+func rewriteValuePPC64_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: (LoweredRound64F x)
@@ -7961,7 +7964,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7990,7 +7993,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8059,7 +8062,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8142,7 +8145,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8171,7 +8174,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8200,7 +8203,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8269,7 +8272,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8356,7 +8359,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8385,7 +8388,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8412,7 +8415,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8475,7 +8478,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8552,7 +8555,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8579,7 +8582,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8606,7 +8609,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8669,7 +8672,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8748,7 +8751,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8775,7 +8778,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8802,7 +8805,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8865,7 +8868,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8942,7 +8945,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8969,7 +8972,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -8996,7 +8999,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9059,7 +9062,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9138,7 +9141,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9165,7 +9168,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9194,7 +9197,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9263,7 +9266,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9346,7 +9349,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9375,7 +9378,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9404,7 +9407,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9473,7 +9476,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9560,7 +9563,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpRsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -9589,7 +9592,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -9600,7 +9603,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -9611,7 +9614,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 x)
 	// cond:
 	// result: (MOVWreg x)
@@ -9622,7 +9625,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9633,7 +9636,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9644,7 +9647,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSignExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9655,7 +9658,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSlicemask(v *Value) bool {
+func rewriteValuePPC64_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -9672,7 +9675,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSqrt(v *Value) bool {
+func rewriteValuePPC64_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (FSQRT x)
@@ -9683,7 +9686,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpStaticCall(v *Value) bool {
+func rewriteValuePPC64_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -9698,7 +9701,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpStore(v *Value) bool {
+func rewriteValuePPC64_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
 	// result: (FMOVDstore ptr val mem)
@@ -9820,7 +9823,7 @@
 	}
 	return false
 }
-func rewriteValuePPC64_OpSub16(v *Value) bool {
+func rewriteValuePPC64_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUB x y)
@@ -9833,7 +9836,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSub32(v *Value) bool {
+func rewriteValuePPC64_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUB x y)
@@ -9846,7 +9849,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSub32F(v *Value) bool {
+func rewriteValuePPC64_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (FSUBS x y)
@@ -9859,7 +9862,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSub64(v *Value) bool {
+func rewriteValuePPC64_OpSub64_0(v *Value) bool {
 	// match: (Sub64 x y)
 	// cond:
 	// result: (SUB  x y)
@@ -9872,7 +9875,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSub64F(v *Value) bool {
+func rewriteValuePPC64_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (FSUB x y)
@@ -9885,7 +9888,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSub8(v *Value) bool {
+func rewriteValuePPC64_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUB x y)
@@ -9898,7 +9901,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpSubPtr(v *Value) bool {
+func rewriteValuePPC64_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUB  x y)
@@ -9911,7 +9914,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc16to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9922,7 +9925,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc32to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -9933,7 +9936,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc32to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9944,7 +9947,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc64to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -9955,7 +9958,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc64to32(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 x)
 	// cond:
 	// result: (MOVWreg x)
@@ -9966,7 +9969,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpTrunc64to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -9977,7 +9980,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpXor16(v *Value) bool {
+func rewriteValuePPC64_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XOR x y)
@@ -9990,7 +9993,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpXor32(v *Value) bool {
+func rewriteValuePPC64_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XOR x y)
@@ -10003,7 +10006,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpXor64(v *Value) bool {
+func rewriteValuePPC64_OpXor64_0(v *Value) bool {
 	// match: (Xor64 x y)
 	// cond:
 	// result: (XOR x y)
@@ -10016,7 +10019,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpXor8(v *Value) bool {
+func rewriteValuePPC64_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XOR x y)
@@ -10029,7 +10032,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZero(v *Value) bool {
+func rewriteValuePPC64_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Zero [0] _ mem)
@@ -10196,6 +10199,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuePPC64_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Zero [16] destptr mem)
 	// cond:
 	// result: (MOVDstorezero [8] destptr                 (MOVDstorezero [0] destptr mem))
@@ -10384,7 +10392,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHZreg x)
@@ -10395,7 +10403,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 x)
 	// cond:
 	// result: (MOVHZreg x)
@@ -10406,7 +10414,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 x)
 	// cond:
 	// result: (MOVWZreg x)
@@ -10417,7 +10425,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBZreg x)
@@ -10428,7 +10436,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBZreg x)
@@ -10439,7 +10447,7 @@
 		return true
 	}
 }
-func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 x)
 	// cond:
 	// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 6946e54..d8e8bd7 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -14,713 +14,713 @@
 func rewriteValueS390X(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValueS390X_OpAdd16(v)
+		return rewriteValueS390X_OpAdd16_0(v)
 	case OpAdd32:
-		return rewriteValueS390X_OpAdd32(v)
+		return rewriteValueS390X_OpAdd32_0(v)
 	case OpAdd32F:
-		return rewriteValueS390X_OpAdd32F(v)
+		return rewriteValueS390X_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValueS390X_OpAdd64(v)
+		return rewriteValueS390X_OpAdd64_0(v)
 	case OpAdd64F:
-		return rewriteValueS390X_OpAdd64F(v)
+		return rewriteValueS390X_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValueS390X_OpAdd8(v)
+		return rewriteValueS390X_OpAdd8_0(v)
 	case OpAddPtr:
-		return rewriteValueS390X_OpAddPtr(v)
+		return rewriteValueS390X_OpAddPtr_0(v)
 	case OpAddr:
-		return rewriteValueS390X_OpAddr(v)
+		return rewriteValueS390X_OpAddr_0(v)
 	case OpAnd16:
-		return rewriteValueS390X_OpAnd16(v)
+		return rewriteValueS390X_OpAnd16_0(v)
 	case OpAnd32:
-		return rewriteValueS390X_OpAnd32(v)
+		return rewriteValueS390X_OpAnd32_0(v)
 	case OpAnd64:
-		return rewriteValueS390X_OpAnd64(v)
+		return rewriteValueS390X_OpAnd64_0(v)
 	case OpAnd8:
-		return rewriteValueS390X_OpAnd8(v)
+		return rewriteValueS390X_OpAnd8_0(v)
 	case OpAndB:
-		return rewriteValueS390X_OpAndB(v)
+		return rewriteValueS390X_OpAndB_0(v)
 	case OpAtomicAdd32:
-		return rewriteValueS390X_OpAtomicAdd32(v)
+		return rewriteValueS390X_OpAtomicAdd32_0(v)
 	case OpAtomicAdd64:
-		return rewriteValueS390X_OpAtomicAdd64(v)
+		return rewriteValueS390X_OpAtomicAdd64_0(v)
 	case OpAtomicCompareAndSwap32:
-		return rewriteValueS390X_OpAtomicCompareAndSwap32(v)
+		return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
 	case OpAtomicCompareAndSwap64:
-		return rewriteValueS390X_OpAtomicCompareAndSwap64(v)
+		return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
 	case OpAtomicExchange32:
-		return rewriteValueS390X_OpAtomicExchange32(v)
+		return rewriteValueS390X_OpAtomicExchange32_0(v)
 	case OpAtomicExchange64:
-		return rewriteValueS390X_OpAtomicExchange64(v)
+		return rewriteValueS390X_OpAtomicExchange64_0(v)
 	case OpAtomicLoad32:
-		return rewriteValueS390X_OpAtomicLoad32(v)
+		return rewriteValueS390X_OpAtomicLoad32_0(v)
 	case OpAtomicLoad64:
-		return rewriteValueS390X_OpAtomicLoad64(v)
+		return rewriteValueS390X_OpAtomicLoad64_0(v)
 	case OpAtomicLoadPtr:
-		return rewriteValueS390X_OpAtomicLoadPtr(v)
+		return rewriteValueS390X_OpAtomicLoadPtr_0(v)
 	case OpAtomicStore32:
-		return rewriteValueS390X_OpAtomicStore32(v)
+		return rewriteValueS390X_OpAtomicStore32_0(v)
 	case OpAtomicStore64:
-		return rewriteValueS390X_OpAtomicStore64(v)
+		return rewriteValueS390X_OpAtomicStore64_0(v)
 	case OpAtomicStorePtrNoWB:
-		return rewriteValueS390X_OpAtomicStorePtrNoWB(v)
+		return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
 	case OpAvg64u:
-		return rewriteValueS390X_OpAvg64u(v)
+		return rewriteValueS390X_OpAvg64u_0(v)
 	case OpBitLen64:
-		return rewriteValueS390X_OpBitLen64(v)
+		return rewriteValueS390X_OpBitLen64_0(v)
 	case OpBswap32:
-		return rewriteValueS390X_OpBswap32(v)
+		return rewriteValueS390X_OpBswap32_0(v)
 	case OpBswap64:
-		return rewriteValueS390X_OpBswap64(v)
+		return rewriteValueS390X_OpBswap64_0(v)
 	case OpClosureCall:
-		return rewriteValueS390X_OpClosureCall(v)
+		return rewriteValueS390X_OpClosureCall_0(v)
 	case OpCom16:
-		return rewriteValueS390X_OpCom16(v)
+		return rewriteValueS390X_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValueS390X_OpCom32(v)
+		return rewriteValueS390X_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValueS390X_OpCom64(v)
+		return rewriteValueS390X_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValueS390X_OpCom8(v)
+		return rewriteValueS390X_OpCom8_0(v)
 	case OpConst16:
-		return rewriteValueS390X_OpConst16(v)
+		return rewriteValueS390X_OpConst16_0(v)
 	case OpConst32:
-		return rewriteValueS390X_OpConst32(v)
+		return rewriteValueS390X_OpConst32_0(v)
 	case OpConst32F:
-		return rewriteValueS390X_OpConst32F(v)
+		return rewriteValueS390X_OpConst32F_0(v)
 	case OpConst64:
-		return rewriteValueS390X_OpConst64(v)
+		return rewriteValueS390X_OpConst64_0(v)
 	case OpConst64F:
-		return rewriteValueS390X_OpConst64F(v)
+		return rewriteValueS390X_OpConst64F_0(v)
 	case OpConst8:
-		return rewriteValueS390X_OpConst8(v)
+		return rewriteValueS390X_OpConst8_0(v)
 	case OpConstBool:
-		return rewriteValueS390X_OpConstBool(v)
+		return rewriteValueS390X_OpConstBool_0(v)
 	case OpConstNil:
-		return rewriteValueS390X_OpConstNil(v)
+		return rewriteValueS390X_OpConstNil_0(v)
 	case OpConvert:
-		return rewriteValueS390X_OpConvert(v)
+		return rewriteValueS390X_OpConvert_0(v)
 	case OpCtz32:
-		return rewriteValueS390X_OpCtz32(v)
+		return rewriteValueS390X_OpCtz32_0(v)
 	case OpCtz64:
-		return rewriteValueS390X_OpCtz64(v)
+		return rewriteValueS390X_OpCtz64_0(v)
 	case OpCvt32Fto32:
-		return rewriteValueS390X_OpCvt32Fto32(v)
+		return rewriteValueS390X_OpCvt32Fto32_0(v)
 	case OpCvt32Fto64:
-		return rewriteValueS390X_OpCvt32Fto64(v)
+		return rewriteValueS390X_OpCvt32Fto64_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValueS390X_OpCvt32Fto64F(v)
+		return rewriteValueS390X_OpCvt32Fto64F_0(v)
 	case OpCvt32to32F:
-		return rewriteValueS390X_OpCvt32to32F(v)
+		return rewriteValueS390X_OpCvt32to32F_0(v)
 	case OpCvt32to64F:
-		return rewriteValueS390X_OpCvt32to64F(v)
+		return rewriteValueS390X_OpCvt32to64F_0(v)
 	case OpCvt64Fto32:
-		return rewriteValueS390X_OpCvt64Fto32(v)
+		return rewriteValueS390X_OpCvt64Fto32_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValueS390X_OpCvt64Fto32F(v)
+		return rewriteValueS390X_OpCvt64Fto32F_0(v)
 	case OpCvt64Fto64:
-		return rewriteValueS390X_OpCvt64Fto64(v)
+		return rewriteValueS390X_OpCvt64Fto64_0(v)
 	case OpCvt64to32F:
-		return rewriteValueS390X_OpCvt64to32F(v)
+		return rewriteValueS390X_OpCvt64to32F_0(v)
 	case OpCvt64to64F:
-		return rewriteValueS390X_OpCvt64to64F(v)
+		return rewriteValueS390X_OpCvt64to64F_0(v)
 	case OpDiv16:
-		return rewriteValueS390X_OpDiv16(v)
+		return rewriteValueS390X_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValueS390X_OpDiv16u(v)
+		return rewriteValueS390X_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValueS390X_OpDiv32(v)
+		return rewriteValueS390X_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValueS390X_OpDiv32F(v)
+		return rewriteValueS390X_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValueS390X_OpDiv32u(v)
+		return rewriteValueS390X_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValueS390X_OpDiv64(v)
+		return rewriteValueS390X_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValueS390X_OpDiv64F(v)
+		return rewriteValueS390X_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValueS390X_OpDiv64u(v)
+		return rewriteValueS390X_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValueS390X_OpDiv8(v)
+		return rewriteValueS390X_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValueS390X_OpDiv8u(v)
+		return rewriteValueS390X_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValueS390X_OpEq16(v)
+		return rewriteValueS390X_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValueS390X_OpEq32(v)
+		return rewriteValueS390X_OpEq32_0(v)
 	case OpEq32F:
-		return rewriteValueS390X_OpEq32F(v)
+		return rewriteValueS390X_OpEq32F_0(v)
 	case OpEq64:
-		return rewriteValueS390X_OpEq64(v)
+		return rewriteValueS390X_OpEq64_0(v)
 	case OpEq64F:
-		return rewriteValueS390X_OpEq64F(v)
+		return rewriteValueS390X_OpEq64F_0(v)
 	case OpEq8:
-		return rewriteValueS390X_OpEq8(v)
+		return rewriteValueS390X_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValueS390X_OpEqB(v)
+		return rewriteValueS390X_OpEqB_0(v)
 	case OpEqPtr:
-		return rewriteValueS390X_OpEqPtr(v)
+		return rewriteValueS390X_OpEqPtr_0(v)
 	case OpGeq16:
-		return rewriteValueS390X_OpGeq16(v)
+		return rewriteValueS390X_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValueS390X_OpGeq16U(v)
+		return rewriteValueS390X_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValueS390X_OpGeq32(v)
+		return rewriteValueS390X_OpGeq32_0(v)
 	case OpGeq32F:
-		return rewriteValueS390X_OpGeq32F(v)
+		return rewriteValueS390X_OpGeq32F_0(v)
 	case OpGeq32U:
-		return rewriteValueS390X_OpGeq32U(v)
+		return rewriteValueS390X_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValueS390X_OpGeq64(v)
+		return rewriteValueS390X_OpGeq64_0(v)
 	case OpGeq64F:
-		return rewriteValueS390X_OpGeq64F(v)
+		return rewriteValueS390X_OpGeq64F_0(v)
 	case OpGeq64U:
-		return rewriteValueS390X_OpGeq64U(v)
+		return rewriteValueS390X_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValueS390X_OpGeq8(v)
+		return rewriteValueS390X_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValueS390X_OpGeq8U(v)
+		return rewriteValueS390X_OpGeq8U_0(v)
 	case OpGetClosurePtr:
-		return rewriteValueS390X_OpGetClosurePtr(v)
+		return rewriteValueS390X_OpGetClosurePtr_0(v)
 	case OpGetG:
-		return rewriteValueS390X_OpGetG(v)
+		return rewriteValueS390X_OpGetG_0(v)
 	case OpGreater16:
-		return rewriteValueS390X_OpGreater16(v)
+		return rewriteValueS390X_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValueS390X_OpGreater16U(v)
+		return rewriteValueS390X_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValueS390X_OpGreater32(v)
+		return rewriteValueS390X_OpGreater32_0(v)
 	case OpGreater32F:
-		return rewriteValueS390X_OpGreater32F(v)
+		return rewriteValueS390X_OpGreater32F_0(v)
 	case OpGreater32U:
-		return rewriteValueS390X_OpGreater32U(v)
+		return rewriteValueS390X_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValueS390X_OpGreater64(v)
+		return rewriteValueS390X_OpGreater64_0(v)
 	case OpGreater64F:
-		return rewriteValueS390X_OpGreater64F(v)
+		return rewriteValueS390X_OpGreater64F_0(v)
 	case OpGreater64U:
-		return rewriteValueS390X_OpGreater64U(v)
+		return rewriteValueS390X_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValueS390X_OpGreater8(v)
+		return rewriteValueS390X_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValueS390X_OpGreater8U(v)
+		return rewriteValueS390X_OpGreater8U_0(v)
 	case OpHmul32:
-		return rewriteValueS390X_OpHmul32(v)
+		return rewriteValueS390X_OpHmul32_0(v)
 	case OpHmul32u:
-		return rewriteValueS390X_OpHmul32u(v)
+		return rewriteValueS390X_OpHmul32u_0(v)
 	case OpHmul64:
-		return rewriteValueS390X_OpHmul64(v)
+		return rewriteValueS390X_OpHmul64_0(v)
 	case OpHmul64u:
-		return rewriteValueS390X_OpHmul64u(v)
+		return rewriteValueS390X_OpHmul64u_0(v)
 	case OpITab:
-		return rewriteValueS390X_OpITab(v)
+		return rewriteValueS390X_OpITab_0(v)
 	case OpInterCall:
-		return rewriteValueS390X_OpInterCall(v)
+		return rewriteValueS390X_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValueS390X_OpIsInBounds(v)
+		return rewriteValueS390X_OpIsInBounds_0(v)
 	case OpIsNonNil:
-		return rewriteValueS390X_OpIsNonNil(v)
+		return rewriteValueS390X_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValueS390X_OpIsSliceInBounds(v)
+		return rewriteValueS390X_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValueS390X_OpLeq16(v)
+		return rewriteValueS390X_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValueS390X_OpLeq16U(v)
+		return rewriteValueS390X_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValueS390X_OpLeq32(v)
+		return rewriteValueS390X_OpLeq32_0(v)
 	case OpLeq32F:
-		return rewriteValueS390X_OpLeq32F(v)
+		return rewriteValueS390X_OpLeq32F_0(v)
 	case OpLeq32U:
-		return rewriteValueS390X_OpLeq32U(v)
+		return rewriteValueS390X_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValueS390X_OpLeq64(v)
+		return rewriteValueS390X_OpLeq64_0(v)
 	case OpLeq64F:
-		return rewriteValueS390X_OpLeq64F(v)
+		return rewriteValueS390X_OpLeq64F_0(v)
 	case OpLeq64U:
-		return rewriteValueS390X_OpLeq64U(v)
+		return rewriteValueS390X_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValueS390X_OpLeq8(v)
+		return rewriteValueS390X_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValueS390X_OpLeq8U(v)
+		return rewriteValueS390X_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValueS390X_OpLess16(v)
+		return rewriteValueS390X_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValueS390X_OpLess16U(v)
+		return rewriteValueS390X_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValueS390X_OpLess32(v)
+		return rewriteValueS390X_OpLess32_0(v)
 	case OpLess32F:
-		return rewriteValueS390X_OpLess32F(v)
+		return rewriteValueS390X_OpLess32F_0(v)
 	case OpLess32U:
-		return rewriteValueS390X_OpLess32U(v)
+		return rewriteValueS390X_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValueS390X_OpLess64(v)
+		return rewriteValueS390X_OpLess64_0(v)
 	case OpLess64F:
-		return rewriteValueS390X_OpLess64F(v)
+		return rewriteValueS390X_OpLess64F_0(v)
 	case OpLess64U:
-		return rewriteValueS390X_OpLess64U(v)
+		return rewriteValueS390X_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValueS390X_OpLess8(v)
+		return rewriteValueS390X_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValueS390X_OpLess8U(v)
+		return rewriteValueS390X_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValueS390X_OpLoad(v)
+		return rewriteValueS390X_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValueS390X_OpLsh16x16(v)
+		return rewriteValueS390X_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValueS390X_OpLsh16x32(v)
+		return rewriteValueS390X_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValueS390X_OpLsh16x64(v)
+		return rewriteValueS390X_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValueS390X_OpLsh16x8(v)
+		return rewriteValueS390X_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValueS390X_OpLsh32x16(v)
+		return rewriteValueS390X_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValueS390X_OpLsh32x32(v)
+		return rewriteValueS390X_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValueS390X_OpLsh32x64(v)
+		return rewriteValueS390X_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValueS390X_OpLsh32x8(v)
+		return rewriteValueS390X_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValueS390X_OpLsh64x16(v)
+		return rewriteValueS390X_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValueS390X_OpLsh64x32(v)
+		return rewriteValueS390X_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValueS390X_OpLsh64x64(v)
+		return rewriteValueS390X_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValueS390X_OpLsh64x8(v)
+		return rewriteValueS390X_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValueS390X_OpLsh8x16(v)
+		return rewriteValueS390X_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValueS390X_OpLsh8x32(v)
+		return rewriteValueS390X_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValueS390X_OpLsh8x64(v)
+		return rewriteValueS390X_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValueS390X_OpLsh8x8(v)
+		return rewriteValueS390X_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValueS390X_OpMod16(v)
+		return rewriteValueS390X_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValueS390X_OpMod16u(v)
+		return rewriteValueS390X_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValueS390X_OpMod32(v)
+		return rewriteValueS390X_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValueS390X_OpMod32u(v)
+		return rewriteValueS390X_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValueS390X_OpMod64(v)
+		return rewriteValueS390X_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValueS390X_OpMod64u(v)
+		return rewriteValueS390X_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValueS390X_OpMod8(v)
+		return rewriteValueS390X_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValueS390X_OpMod8u(v)
+		return rewriteValueS390X_OpMod8u_0(v)
 	case OpMove:
-		return rewriteValueS390X_OpMove(v)
+		return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
 	case OpMul16:
-		return rewriteValueS390X_OpMul16(v)
+		return rewriteValueS390X_OpMul16_0(v)
 	case OpMul32:
-		return rewriteValueS390X_OpMul32(v)
+		return rewriteValueS390X_OpMul32_0(v)
 	case OpMul32F:
-		return rewriteValueS390X_OpMul32F(v)
+		return rewriteValueS390X_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValueS390X_OpMul64(v)
+		return rewriteValueS390X_OpMul64_0(v)
 	case OpMul64F:
-		return rewriteValueS390X_OpMul64F(v)
+		return rewriteValueS390X_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValueS390X_OpMul8(v)
+		return rewriteValueS390X_OpMul8_0(v)
 	case OpNeg16:
-		return rewriteValueS390X_OpNeg16(v)
+		return rewriteValueS390X_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValueS390X_OpNeg32(v)
+		return rewriteValueS390X_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValueS390X_OpNeg32F(v)
+		return rewriteValueS390X_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValueS390X_OpNeg64(v)
+		return rewriteValueS390X_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValueS390X_OpNeg64F(v)
+		return rewriteValueS390X_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValueS390X_OpNeg8(v)
+		return rewriteValueS390X_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValueS390X_OpNeq16(v)
+		return rewriteValueS390X_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValueS390X_OpNeq32(v)
+		return rewriteValueS390X_OpNeq32_0(v)
 	case OpNeq32F:
-		return rewriteValueS390X_OpNeq32F(v)
+		return rewriteValueS390X_OpNeq32F_0(v)
 	case OpNeq64:
-		return rewriteValueS390X_OpNeq64(v)
+		return rewriteValueS390X_OpNeq64_0(v)
 	case OpNeq64F:
-		return rewriteValueS390X_OpNeq64F(v)
+		return rewriteValueS390X_OpNeq64F_0(v)
 	case OpNeq8:
-		return rewriteValueS390X_OpNeq8(v)
+		return rewriteValueS390X_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValueS390X_OpNeqB(v)
+		return rewriteValueS390X_OpNeqB_0(v)
 	case OpNeqPtr:
-		return rewriteValueS390X_OpNeqPtr(v)
+		return rewriteValueS390X_OpNeqPtr_0(v)
 	case OpNilCheck:
-		return rewriteValueS390X_OpNilCheck(v)
+		return rewriteValueS390X_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValueS390X_OpNot(v)
+		return rewriteValueS390X_OpNot_0(v)
 	case OpOffPtr:
-		return rewriteValueS390X_OpOffPtr(v)
+		return rewriteValueS390X_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValueS390X_OpOr16(v)
+		return rewriteValueS390X_OpOr16_0(v)
 	case OpOr32:
-		return rewriteValueS390X_OpOr32(v)
+		return rewriteValueS390X_OpOr32_0(v)
 	case OpOr64:
-		return rewriteValueS390X_OpOr64(v)
+		return rewriteValueS390X_OpOr64_0(v)
 	case OpOr8:
-		return rewriteValueS390X_OpOr8(v)
+		return rewriteValueS390X_OpOr8_0(v)
 	case OpOrB:
-		return rewriteValueS390X_OpOrB(v)
+		return rewriteValueS390X_OpOrB_0(v)
 	case OpRound32F:
-		return rewriteValueS390X_OpRound32F(v)
+		return rewriteValueS390X_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValueS390X_OpRound64F(v)
+		return rewriteValueS390X_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValueS390X_OpRsh16Ux16(v)
+		return rewriteValueS390X_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValueS390X_OpRsh16Ux32(v)
+		return rewriteValueS390X_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValueS390X_OpRsh16Ux64(v)
+		return rewriteValueS390X_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValueS390X_OpRsh16Ux8(v)
+		return rewriteValueS390X_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValueS390X_OpRsh16x16(v)
+		return rewriteValueS390X_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValueS390X_OpRsh16x32(v)
+		return rewriteValueS390X_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValueS390X_OpRsh16x64(v)
+		return rewriteValueS390X_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValueS390X_OpRsh16x8(v)
+		return rewriteValueS390X_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValueS390X_OpRsh32Ux16(v)
+		return rewriteValueS390X_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValueS390X_OpRsh32Ux32(v)
+		return rewriteValueS390X_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValueS390X_OpRsh32Ux64(v)
+		return rewriteValueS390X_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValueS390X_OpRsh32Ux8(v)
+		return rewriteValueS390X_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValueS390X_OpRsh32x16(v)
+		return rewriteValueS390X_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValueS390X_OpRsh32x32(v)
+		return rewriteValueS390X_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValueS390X_OpRsh32x64(v)
+		return rewriteValueS390X_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValueS390X_OpRsh32x8(v)
+		return rewriteValueS390X_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValueS390X_OpRsh64Ux16(v)
+		return rewriteValueS390X_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValueS390X_OpRsh64Ux32(v)
+		return rewriteValueS390X_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValueS390X_OpRsh64Ux64(v)
+		return rewriteValueS390X_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValueS390X_OpRsh64Ux8(v)
+		return rewriteValueS390X_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValueS390X_OpRsh64x16(v)
+		return rewriteValueS390X_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValueS390X_OpRsh64x32(v)
+		return rewriteValueS390X_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValueS390X_OpRsh64x64(v)
+		return rewriteValueS390X_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValueS390X_OpRsh64x8(v)
+		return rewriteValueS390X_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValueS390X_OpRsh8Ux16(v)
+		return rewriteValueS390X_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValueS390X_OpRsh8Ux32(v)
+		return rewriteValueS390X_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValueS390X_OpRsh8Ux64(v)
+		return rewriteValueS390X_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValueS390X_OpRsh8Ux8(v)
+		return rewriteValueS390X_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValueS390X_OpRsh8x16(v)
+		return rewriteValueS390X_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValueS390X_OpRsh8x32(v)
+		return rewriteValueS390X_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValueS390X_OpRsh8x64(v)
+		return rewriteValueS390X_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValueS390X_OpRsh8x8(v)
+		return rewriteValueS390X_OpRsh8x8_0(v)
 	case OpS390XADD:
-		return rewriteValueS390X_OpS390XADD(v)
+		return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
 	case OpS390XADDW:
-		return rewriteValueS390X_OpS390XADDW(v)
+		return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
 	case OpS390XADDWconst:
-		return rewriteValueS390X_OpS390XADDWconst(v)
+		return rewriteValueS390X_OpS390XADDWconst_0(v)
 	case OpS390XADDconst:
-		return rewriteValueS390X_OpS390XADDconst(v)
+		return rewriteValueS390X_OpS390XADDconst_0(v)
 	case OpS390XAND:
-		return rewriteValueS390X_OpS390XAND(v)
+		return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
 	case OpS390XANDW:
-		return rewriteValueS390X_OpS390XANDW(v)
+		return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
 	case OpS390XANDWconst:
-		return rewriteValueS390X_OpS390XANDWconst(v)
+		return rewriteValueS390X_OpS390XANDWconst_0(v)
 	case OpS390XANDconst:
-		return rewriteValueS390X_OpS390XANDconst(v)
+		return rewriteValueS390X_OpS390XANDconst_0(v)
 	case OpS390XCMP:
-		return rewriteValueS390X_OpS390XCMP(v)
+		return rewriteValueS390X_OpS390XCMP_0(v)
 	case OpS390XCMPU:
-		return rewriteValueS390X_OpS390XCMPU(v)
+		return rewriteValueS390X_OpS390XCMPU_0(v)
 	case OpS390XCMPUconst:
-		return rewriteValueS390X_OpS390XCMPUconst(v)
+		return rewriteValueS390X_OpS390XCMPUconst_0(v)
 	case OpS390XCMPW:
-		return rewriteValueS390X_OpS390XCMPW(v)
+		return rewriteValueS390X_OpS390XCMPW_0(v)
 	case OpS390XCMPWU:
-		return rewriteValueS390X_OpS390XCMPWU(v)
+		return rewriteValueS390X_OpS390XCMPWU_0(v)
 	case OpS390XCMPWUconst:
-		return rewriteValueS390X_OpS390XCMPWUconst(v)
+		return rewriteValueS390X_OpS390XCMPWUconst_0(v)
 	case OpS390XCMPWconst:
-		return rewriteValueS390X_OpS390XCMPWconst(v)
+		return rewriteValueS390X_OpS390XCMPWconst_0(v)
 	case OpS390XCMPconst:
-		return rewriteValueS390X_OpS390XCMPconst(v)
+		return rewriteValueS390X_OpS390XCMPconst_0(v)
 	case OpS390XFADD:
-		return rewriteValueS390X_OpS390XFADD(v)
+		return rewriteValueS390X_OpS390XFADD_0(v)
 	case OpS390XFADDS:
-		return rewriteValueS390X_OpS390XFADDS(v)
+		return rewriteValueS390X_OpS390XFADDS_0(v)
 	case OpS390XFMOVDload:
-		return rewriteValueS390X_OpS390XFMOVDload(v)
+		return rewriteValueS390X_OpS390XFMOVDload_0(v)
 	case OpS390XFMOVDloadidx:
-		return rewriteValueS390X_OpS390XFMOVDloadidx(v)
+		return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
 	case OpS390XFMOVDstore:
-		return rewriteValueS390X_OpS390XFMOVDstore(v)
+		return rewriteValueS390X_OpS390XFMOVDstore_0(v)
 	case OpS390XFMOVDstoreidx:
-		return rewriteValueS390X_OpS390XFMOVDstoreidx(v)
+		return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
 	case OpS390XFMOVSload:
-		return rewriteValueS390X_OpS390XFMOVSload(v)
+		return rewriteValueS390X_OpS390XFMOVSload_0(v)
 	case OpS390XFMOVSloadidx:
-		return rewriteValueS390X_OpS390XFMOVSloadidx(v)
+		return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
 	case OpS390XFMOVSstore:
-		return rewriteValueS390X_OpS390XFMOVSstore(v)
+		return rewriteValueS390X_OpS390XFMOVSstore_0(v)
 	case OpS390XFMOVSstoreidx:
-		return rewriteValueS390X_OpS390XFMOVSstoreidx(v)
+		return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
 	case OpS390XFSUB:
-		return rewriteValueS390X_OpS390XFSUB(v)
+		return rewriteValueS390X_OpS390XFSUB_0(v)
 	case OpS390XFSUBS:
-		return rewriteValueS390X_OpS390XFSUBS(v)
+		return rewriteValueS390X_OpS390XFSUBS_0(v)
 	case OpS390XLoweredRound32F:
-		return rewriteValueS390X_OpS390XLoweredRound32F(v)
+		return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
 	case OpS390XLoweredRound64F:
-		return rewriteValueS390X_OpS390XLoweredRound64F(v)
+		return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
 	case OpS390XMOVBZload:
-		return rewriteValueS390X_OpS390XMOVBZload(v)
+		return rewriteValueS390X_OpS390XMOVBZload_0(v)
 	case OpS390XMOVBZloadidx:
-		return rewriteValueS390X_OpS390XMOVBZloadidx(v)
+		return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
 	case OpS390XMOVBZreg:
-		return rewriteValueS390X_OpS390XMOVBZreg(v)
+		return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
 	case OpS390XMOVBload:
-		return rewriteValueS390X_OpS390XMOVBload(v)
+		return rewriteValueS390X_OpS390XMOVBload_0(v)
 	case OpS390XMOVBreg:
-		return rewriteValueS390X_OpS390XMOVBreg(v)
+		return rewriteValueS390X_OpS390XMOVBreg_0(v)
 	case OpS390XMOVBstore:
-		return rewriteValueS390X_OpS390XMOVBstore(v)
+		return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
 	case OpS390XMOVBstoreconst:
-		return rewriteValueS390X_OpS390XMOVBstoreconst(v)
+		return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
 	case OpS390XMOVBstoreidx:
-		return rewriteValueS390X_OpS390XMOVBstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
 	case OpS390XMOVDEQ:
-		return rewriteValueS390X_OpS390XMOVDEQ(v)
+		return rewriteValueS390X_OpS390XMOVDEQ_0(v)
 	case OpS390XMOVDGE:
-		return rewriteValueS390X_OpS390XMOVDGE(v)
+		return rewriteValueS390X_OpS390XMOVDGE_0(v)
 	case OpS390XMOVDGT:
-		return rewriteValueS390X_OpS390XMOVDGT(v)
+		return rewriteValueS390X_OpS390XMOVDGT_0(v)
 	case OpS390XMOVDLE:
-		return rewriteValueS390X_OpS390XMOVDLE(v)
+		return rewriteValueS390X_OpS390XMOVDLE_0(v)
 	case OpS390XMOVDLT:
-		return rewriteValueS390X_OpS390XMOVDLT(v)
+		return rewriteValueS390X_OpS390XMOVDLT_0(v)
 	case OpS390XMOVDNE:
-		return rewriteValueS390X_OpS390XMOVDNE(v)
+		return rewriteValueS390X_OpS390XMOVDNE_0(v)
 	case OpS390XMOVDaddridx:
-		return rewriteValueS390X_OpS390XMOVDaddridx(v)
+		return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
 	case OpS390XMOVDload:
-		return rewriteValueS390X_OpS390XMOVDload(v)
+		return rewriteValueS390X_OpS390XMOVDload_0(v)
 	case OpS390XMOVDloadidx:
-		return rewriteValueS390X_OpS390XMOVDloadidx(v)
+		return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
 	case OpS390XMOVDnop:
-		return rewriteValueS390X_OpS390XMOVDnop(v)
+		return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
 	case OpS390XMOVDreg:
-		return rewriteValueS390X_OpS390XMOVDreg(v)
+		return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
 	case OpS390XMOVDstore:
-		return rewriteValueS390X_OpS390XMOVDstore(v)
+		return rewriteValueS390X_OpS390XMOVDstore_0(v)
 	case OpS390XMOVDstoreconst:
-		return rewriteValueS390X_OpS390XMOVDstoreconst(v)
+		return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
 	case OpS390XMOVDstoreidx:
-		return rewriteValueS390X_OpS390XMOVDstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
 	case OpS390XMOVHBRstore:
-		return rewriteValueS390X_OpS390XMOVHBRstore(v)
+		return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
 	case OpS390XMOVHBRstoreidx:
-		return rewriteValueS390X_OpS390XMOVHBRstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
 	case OpS390XMOVHZload:
-		return rewriteValueS390X_OpS390XMOVHZload(v)
+		return rewriteValueS390X_OpS390XMOVHZload_0(v)
 	case OpS390XMOVHZloadidx:
-		return rewriteValueS390X_OpS390XMOVHZloadidx(v)
+		return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
 	case OpS390XMOVHZreg:
-		return rewriteValueS390X_OpS390XMOVHZreg(v)
+		return rewriteValueS390X_OpS390XMOVHZreg_0(v)
 	case OpS390XMOVHload:
-		return rewriteValueS390X_OpS390XMOVHload(v)
+		return rewriteValueS390X_OpS390XMOVHload_0(v)
 	case OpS390XMOVHreg:
-		return rewriteValueS390X_OpS390XMOVHreg(v)
+		return rewriteValueS390X_OpS390XMOVHreg_0(v)
 	case OpS390XMOVHstore:
-		return rewriteValueS390X_OpS390XMOVHstore(v)
+		return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
 	case OpS390XMOVHstoreconst:
-		return rewriteValueS390X_OpS390XMOVHstoreconst(v)
+		return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
 	case OpS390XMOVHstoreidx:
-		return rewriteValueS390X_OpS390XMOVHstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
 	case OpS390XMOVWBRstore:
-		return rewriteValueS390X_OpS390XMOVWBRstore(v)
+		return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
 	case OpS390XMOVWBRstoreidx:
-		return rewriteValueS390X_OpS390XMOVWBRstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
 	case OpS390XMOVWZload:
-		return rewriteValueS390X_OpS390XMOVWZload(v)
+		return rewriteValueS390X_OpS390XMOVWZload_0(v)
 	case OpS390XMOVWZloadidx:
-		return rewriteValueS390X_OpS390XMOVWZloadidx(v)
+		return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
 	case OpS390XMOVWZreg:
-		return rewriteValueS390X_OpS390XMOVWZreg(v)
+		return rewriteValueS390X_OpS390XMOVWZreg_0(v)
 	case OpS390XMOVWload:
-		return rewriteValueS390X_OpS390XMOVWload(v)
+		return rewriteValueS390X_OpS390XMOVWload_0(v)
 	case OpS390XMOVWreg:
-		return rewriteValueS390X_OpS390XMOVWreg(v)
+		return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
 	case OpS390XMOVWstore:
-		return rewriteValueS390X_OpS390XMOVWstore(v)
+		return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
 	case OpS390XMOVWstoreconst:
-		return rewriteValueS390X_OpS390XMOVWstoreconst(v)
+		return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
 	case OpS390XMOVWstoreidx:
-		return rewriteValueS390X_OpS390XMOVWstoreidx(v)
+		return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
 	case OpS390XMULLD:
-		return rewriteValueS390X_OpS390XMULLD(v)
+		return rewriteValueS390X_OpS390XMULLD_0(v)
 	case OpS390XMULLDconst:
-		return rewriteValueS390X_OpS390XMULLDconst(v)
+		return rewriteValueS390X_OpS390XMULLDconst_0(v)
 	case OpS390XMULLW:
-		return rewriteValueS390X_OpS390XMULLW(v)
+		return rewriteValueS390X_OpS390XMULLW_0(v)
 	case OpS390XMULLWconst:
-		return rewriteValueS390X_OpS390XMULLWconst(v)
+		return rewriteValueS390X_OpS390XMULLWconst_0(v)
 	case OpS390XNEG:
-		return rewriteValueS390X_OpS390XNEG(v)
+		return rewriteValueS390X_OpS390XNEG_0(v)
 	case OpS390XNEGW:
-		return rewriteValueS390X_OpS390XNEGW(v)
+		return rewriteValueS390X_OpS390XNEGW_0(v)
 	case OpS390XNOT:
-		return rewriteValueS390X_OpS390XNOT(v)
+		return rewriteValueS390X_OpS390XNOT_0(v)
 	case OpS390XNOTW:
-		return rewriteValueS390X_OpS390XNOTW(v)
+		return rewriteValueS390X_OpS390XNOTW_0(v)
 	case OpS390XOR:
-		return rewriteValueS390X_OpS390XOR(v)
+		return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
 	case OpS390XORW:
-		return rewriteValueS390X_OpS390XORW(v)
+		return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
 	case OpS390XORWconst:
-		return rewriteValueS390X_OpS390XORWconst(v)
+		return rewriteValueS390X_OpS390XORWconst_0(v)
 	case OpS390XORconst:
-		return rewriteValueS390X_OpS390XORconst(v)
+		return rewriteValueS390X_OpS390XORconst_0(v)
 	case OpS390XSLD:
-		return rewriteValueS390X_OpS390XSLD(v)
+		return rewriteValueS390X_OpS390XSLD_0(v)
 	case OpS390XSLW:
-		return rewriteValueS390X_OpS390XSLW(v)
+		return rewriteValueS390X_OpS390XSLW_0(v)
 	case OpS390XSRAD:
-		return rewriteValueS390X_OpS390XSRAD(v)
+		return rewriteValueS390X_OpS390XSRAD_0(v)
 	case OpS390XSRADconst:
-		return rewriteValueS390X_OpS390XSRADconst(v)
+		return rewriteValueS390X_OpS390XSRADconst_0(v)
 	case OpS390XSRAW:
-		return rewriteValueS390X_OpS390XSRAW(v)
+		return rewriteValueS390X_OpS390XSRAW_0(v)
 	case OpS390XSRAWconst:
-		return rewriteValueS390X_OpS390XSRAWconst(v)
+		return rewriteValueS390X_OpS390XSRAWconst_0(v)
 	case OpS390XSRD:
-		return rewriteValueS390X_OpS390XSRD(v)
+		return rewriteValueS390X_OpS390XSRD_0(v)
 	case OpS390XSRW:
-		return rewriteValueS390X_OpS390XSRW(v)
+		return rewriteValueS390X_OpS390XSRW_0(v)
 	case OpS390XSTM2:
-		return rewriteValueS390X_OpS390XSTM2(v)
+		return rewriteValueS390X_OpS390XSTM2_0(v)
 	case OpS390XSTMG2:
-		return rewriteValueS390X_OpS390XSTMG2(v)
+		return rewriteValueS390X_OpS390XSTMG2_0(v)
 	case OpS390XSUB:
-		return rewriteValueS390X_OpS390XSUB(v)
+		return rewriteValueS390X_OpS390XSUB_0(v)
 	case OpS390XSUBEWcarrymask:
-		return rewriteValueS390X_OpS390XSUBEWcarrymask(v)
+		return rewriteValueS390X_OpS390XSUBEWcarrymask_0(v)
 	case OpS390XSUBEcarrymask:
-		return rewriteValueS390X_OpS390XSUBEcarrymask(v)
+		return rewriteValueS390X_OpS390XSUBEcarrymask_0(v)
 	case OpS390XSUBW:
-		return rewriteValueS390X_OpS390XSUBW(v)
+		return rewriteValueS390X_OpS390XSUBW_0(v)
 	case OpS390XSUBWconst:
-		return rewriteValueS390X_OpS390XSUBWconst(v)
+		return rewriteValueS390X_OpS390XSUBWconst_0(v)
 	case OpS390XSUBconst:
-		return rewriteValueS390X_OpS390XSUBconst(v)
+		return rewriteValueS390X_OpS390XSUBconst_0(v)
 	case OpS390XXOR:
-		return rewriteValueS390X_OpS390XXOR(v)
+		return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
 	case OpS390XXORW:
-		return rewriteValueS390X_OpS390XXORW(v)
+		return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
 	case OpS390XXORWconst:
-		return rewriteValueS390X_OpS390XXORWconst(v)
+		return rewriteValueS390X_OpS390XXORWconst_0(v)
 	case OpS390XXORconst:
-		return rewriteValueS390X_OpS390XXORconst(v)
+		return rewriteValueS390X_OpS390XXORconst_0(v)
 	case OpSelect0:
-		return rewriteValueS390X_OpSelect0(v)
+		return rewriteValueS390X_OpSelect0_0(v)
 	case OpSelect1:
-		return rewriteValueS390X_OpSelect1(v)
+		return rewriteValueS390X_OpSelect1_0(v)
 	case OpSignExt16to32:
-		return rewriteValueS390X_OpSignExt16to32(v)
+		return rewriteValueS390X_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValueS390X_OpSignExt16to64(v)
+		return rewriteValueS390X_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValueS390X_OpSignExt32to64(v)
+		return rewriteValueS390X_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValueS390X_OpSignExt8to16(v)
+		return rewriteValueS390X_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValueS390X_OpSignExt8to32(v)
+		return rewriteValueS390X_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValueS390X_OpSignExt8to64(v)
+		return rewriteValueS390X_OpSignExt8to64_0(v)
 	case OpSlicemask:
-		return rewriteValueS390X_OpSlicemask(v)
+		return rewriteValueS390X_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValueS390X_OpSqrt(v)
+		return rewriteValueS390X_OpSqrt_0(v)
 	case OpStaticCall:
-		return rewriteValueS390X_OpStaticCall(v)
+		return rewriteValueS390X_OpStaticCall_0(v)
 	case OpStore:
-		return rewriteValueS390X_OpStore(v)
+		return rewriteValueS390X_OpStore_0(v)
 	case OpSub16:
-		return rewriteValueS390X_OpSub16(v)
+		return rewriteValueS390X_OpSub16_0(v)
 	case OpSub32:
-		return rewriteValueS390X_OpSub32(v)
+		return rewriteValueS390X_OpSub32_0(v)
 	case OpSub32F:
-		return rewriteValueS390X_OpSub32F(v)
+		return rewriteValueS390X_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValueS390X_OpSub64(v)
+		return rewriteValueS390X_OpSub64_0(v)
 	case OpSub64F:
-		return rewriteValueS390X_OpSub64F(v)
+		return rewriteValueS390X_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValueS390X_OpSub8(v)
+		return rewriteValueS390X_OpSub8_0(v)
 	case OpSubPtr:
-		return rewriteValueS390X_OpSubPtr(v)
+		return rewriteValueS390X_OpSubPtr_0(v)
 	case OpTrunc16to8:
-		return rewriteValueS390X_OpTrunc16to8(v)
+		return rewriteValueS390X_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValueS390X_OpTrunc32to16(v)
+		return rewriteValueS390X_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValueS390X_OpTrunc32to8(v)
+		return rewriteValueS390X_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValueS390X_OpTrunc64to16(v)
+		return rewriteValueS390X_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValueS390X_OpTrunc64to32(v)
+		return rewriteValueS390X_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValueS390X_OpTrunc64to8(v)
+		return rewriteValueS390X_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValueS390X_OpXor16(v)
+		return rewriteValueS390X_OpXor16_0(v)
 	case OpXor32:
-		return rewriteValueS390X_OpXor32(v)
+		return rewriteValueS390X_OpXor32_0(v)
 	case OpXor64:
-		return rewriteValueS390X_OpXor64(v)
+		return rewriteValueS390X_OpXor64_0(v)
 	case OpXor8:
-		return rewriteValueS390X_OpXor8(v)
+		return rewriteValueS390X_OpXor8_0(v)
 	case OpZero:
-		return rewriteValueS390X_OpZero(v)
+		return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
 	case OpZeroExt16to32:
-		return rewriteValueS390X_OpZeroExt16to32(v)
+		return rewriteValueS390X_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValueS390X_OpZeroExt16to64(v)
+		return rewriteValueS390X_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValueS390X_OpZeroExt32to64(v)
+		return rewriteValueS390X_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValueS390X_OpZeroExt8to16(v)
+		return rewriteValueS390X_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValueS390X_OpZeroExt8to32(v)
+		return rewriteValueS390X_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValueS390X_OpZeroExt8to64(v)
+		return rewriteValueS390X_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValueS390X_OpAdd16(v *Value) bool {
+func rewriteValueS390X_OpAdd16_0(v *Value) bool {
 	// match: (Add16 x y)
 	// cond:
 	// result: (ADDW  x y)
@@ -733,7 +733,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAdd32(v *Value) bool {
+func rewriteValueS390X_OpAdd32_0(v *Value) bool {
 	// match: (Add32 x y)
 	// cond:
 	// result: (ADDW  x y)
@@ -746,7 +746,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAdd32F(v *Value) bool {
+func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F x y)
 	// cond:
 	// result: (FADDS x y)
@@ -759,7 +759,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAdd64(v *Value) bool {
+func rewriteValueS390X_OpAdd64_0(v *Value) bool {
 	// match: (Add64 x y)
 	// cond:
 	// result: (ADD  x y)
@@ -772,7 +772,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAdd64F(v *Value) bool {
+func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F x y)
 	// cond:
 	// result: (FADD x y)
@@ -785,7 +785,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAdd8(v *Value) bool {
+func rewriteValueS390X_OpAdd8_0(v *Value) bool {
 	// match: (Add8 x y)
 	// cond:
 	// result: (ADDW  x y)
@@ -798,7 +798,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAddPtr(v *Value) bool {
+func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr x y)
 	// cond:
 	// result: (ADD  x y)
@@ -811,7 +811,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAddr(v *Value) bool {
+func rewriteValueS390X_OpAddr_0(v *Value) bool {
 	// match: (Addr {sym} base)
 	// cond:
 	// result: (MOVDaddr {sym} base)
@@ -824,7 +824,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAnd16(v *Value) bool {
+func rewriteValueS390X_OpAnd16_0(v *Value) bool {
 	// match: (And16 x y)
 	// cond:
 	// result: (ANDW x y)
@@ -837,7 +837,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAnd32(v *Value) bool {
+func rewriteValueS390X_OpAnd32_0(v *Value) bool {
 	// match: (And32 x y)
 	// cond:
 	// result: (ANDW x y)
@@ -850,7 +850,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAnd64(v *Value) bool {
+func rewriteValueS390X_OpAnd64_0(v *Value) bool {
 	// match: (And64 x y)
 	// cond:
 	// result: (AND x y)
@@ -863,7 +863,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAnd8(v *Value) bool {
+func rewriteValueS390X_OpAnd8_0(v *Value) bool {
 	// match: (And8 x y)
 	// cond:
 	// result: (ANDW x y)
@@ -876,7 +876,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAndB(v *Value) bool {
+func rewriteValueS390X_OpAndB_0(v *Value) bool {
 	// match: (AndB x y)
 	// cond:
 	// result: (ANDW x y)
@@ -889,7 +889,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicAdd32(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -911,7 +911,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicAdd64(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -933,7 +933,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -950,7 +950,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
 	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
 	// cond:
 	// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -967,7 +967,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicExchange32(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
 	// match: (AtomicExchange32 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange32 ptr val mem)
@@ -982,7 +982,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicExchange64(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
 	// match: (AtomicExchange64 ptr val mem)
 	// cond:
 	// result: (LoweredAtomicExchange64 ptr val mem)
@@ -997,7 +997,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicLoad32(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
 	// match: (AtomicLoad32 ptr mem)
 	// cond:
 	// result: (MOVWZatomicload ptr mem)
@@ -1010,7 +1010,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicLoad64(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
 	// match: (AtomicLoad64 ptr mem)
 	// cond:
 	// result: (MOVDatomicload ptr mem)
@@ -1023,7 +1023,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
 	// match: (AtomicLoadPtr ptr mem)
 	// cond:
 	// result: (MOVDatomicload ptr mem)
@@ -1036,7 +1036,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicStore32(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
 	// match: (AtomicStore32 ptr val mem)
 	// cond:
 	// result: (MOVWatomicstore ptr val mem)
@@ -1051,7 +1051,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicStore64(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
 	// match: (AtomicStore64 ptr val mem)
 	// cond:
 	// result: (MOVDatomicstore ptr val mem)
@@ -1066,7 +1066,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
 	// match: (AtomicStorePtrNoWB ptr val mem)
 	// cond:
 	// result: (MOVDatomicstore ptr val mem)
@@ -1081,7 +1081,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpAvg64u(v *Value) bool {
+func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Avg64u <t> x y)
@@ -1103,7 +1103,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpBitLen64(v *Value) bool {
+func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1123,7 +1123,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpBswap32(v *Value) bool {
+func rewriteValueS390X_OpBswap32_0(v *Value) bool {
 	// match: (Bswap32 x)
 	// cond:
 	// result: (MOVWBR x)
@@ -1134,7 +1134,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpBswap64(v *Value) bool {
+func rewriteValueS390X_OpBswap64_0(v *Value) bool {
 	// match: (Bswap64 x)
 	// cond:
 	// result: (MOVDBR x)
@@ -1145,7 +1145,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpClosureCall(v *Value) bool {
+func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
 	// match: (ClosureCall [argwid] entry closure mem)
 	// cond:
 	// result: (CALLclosure [argwid] entry closure mem)
@@ -1162,7 +1162,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCom16(v *Value) bool {
+func rewriteValueS390X_OpCom16_0(v *Value) bool {
 	// match: (Com16 x)
 	// cond:
 	// result: (NOTW x)
@@ -1173,7 +1173,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCom32(v *Value) bool {
+func rewriteValueS390X_OpCom32_0(v *Value) bool {
 	// match: (Com32 x)
 	// cond:
 	// result: (NOTW x)
@@ -1184,7 +1184,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCom64(v *Value) bool {
+func rewriteValueS390X_OpCom64_0(v *Value) bool {
 	// match: (Com64 x)
 	// cond:
 	// result: (NOT x)
@@ -1195,7 +1195,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCom8(v *Value) bool {
+func rewriteValueS390X_OpCom8_0(v *Value) bool {
 	// match: (Com8 x)
 	// cond:
 	// result: (NOTW x)
@@ -1206,7 +1206,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst16(v *Value) bool {
+func rewriteValueS390X_OpConst16_0(v *Value) bool {
 	// match: (Const16 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1217,7 +1217,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst32(v *Value) bool {
+func rewriteValueS390X_OpConst32_0(v *Value) bool {
 	// match: (Const32 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1228,7 +1228,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst32F(v *Value) bool {
+func rewriteValueS390X_OpConst32F_0(v *Value) bool {
 	// match: (Const32F [val])
 	// cond:
 	// result: (FMOVSconst [val])
@@ -1239,7 +1239,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst64(v *Value) bool {
+func rewriteValueS390X_OpConst64_0(v *Value) bool {
 	// match: (Const64 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1250,7 +1250,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst64F(v *Value) bool {
+func rewriteValueS390X_OpConst64F_0(v *Value) bool {
 	// match: (Const64F [val])
 	// cond:
 	// result: (FMOVDconst [val])
@@ -1261,7 +1261,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConst8(v *Value) bool {
+func rewriteValueS390X_OpConst8_0(v *Value) bool {
 	// match: (Const8 [val])
 	// cond:
 	// result: (MOVDconst [val])
@@ -1272,7 +1272,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConstBool(v *Value) bool {
+func rewriteValueS390X_OpConstBool_0(v *Value) bool {
 	// match: (ConstBool [b])
 	// cond:
 	// result: (MOVDconst [b])
@@ -1283,7 +1283,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConstNil(v *Value) bool {
+func rewriteValueS390X_OpConstNil_0(v *Value) bool {
 	// match: (ConstNil)
 	// cond:
 	// result: (MOVDconst [0])
@@ -1293,7 +1293,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpConvert(v *Value) bool {
+func rewriteValueS390X_OpConvert_0(v *Value) bool {
 	// match: (Convert <t> x mem)
 	// cond:
 	// result: (MOVDconvert <t> x mem)
@@ -1308,7 +1308,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCtz32(v *Value) bool {
+func rewriteValueS390X_OpCtz32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1339,7 +1339,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCtz64(v *Value) bool {
+func rewriteValueS390X_OpCtz64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1368,7 +1368,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt32Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
 	// match: (Cvt32Fto32 x)
 	// cond:
 	// result: (CFEBRA x)
@@ -1379,7 +1379,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt32Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
 	// match: (Cvt32Fto64 x)
 	// cond:
 	// result: (CGEBRA x)
@@ -1390,7 +1390,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F x)
 	// cond:
 	// result: (LDEBR x)
@@ -1401,7 +1401,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt32to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
 	// match: (Cvt32to32F x)
 	// cond:
 	// result: (CEFBRA x)
@@ -1412,7 +1412,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt32to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
 	// match: (Cvt32to64F x)
 	// cond:
 	// result: (CDFBRA x)
@@ -1423,7 +1423,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt64Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
 	// match: (Cvt64Fto32 x)
 	// cond:
 	// result: (CFDBRA x)
@@ -1434,7 +1434,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F x)
 	// cond:
 	// result: (LEDBR x)
@@ -1445,7 +1445,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt64Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
 	// match: (Cvt64Fto64 x)
 	// cond:
 	// result: (CGDBRA x)
@@ -1456,7 +1456,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt64to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
 	// match: (Cvt64to32F x)
 	// cond:
 	// result: (CEGBRA x)
@@ -1467,7 +1467,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpCvt64to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
 	// match: (Cvt64to64F x)
 	// cond:
 	// result: (CDGBRA x)
@@ -1478,7 +1478,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv16(v *Value) bool {
+func rewriteValueS390X_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1499,7 +1499,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv16u(v *Value) bool {
+func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1520,7 +1520,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv32(v *Value) bool {
+func rewriteValueS390X_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1539,7 +1539,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv32F(v *Value) bool {
+func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
 	// match: (Div32F x y)
 	// cond:
 	// result: (FDIVS x y)
@@ -1552,7 +1552,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv32u(v *Value) bool {
+func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1571,7 +1571,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv64(v *Value) bool {
+func rewriteValueS390X_OpDiv64_0(v *Value) bool {
 	// match: (Div64 x y)
 	// cond:
 	// result: (DIVD  x y)
@@ -1584,7 +1584,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv64F(v *Value) bool {
+func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
 	// match: (Div64F x y)
 	// cond:
 	// result: (FDIV x y)
@@ -1597,7 +1597,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv64u(v *Value) bool {
+func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
 	// match: (Div64u x y)
 	// cond:
 	// result: (DIVDU x y)
@@ -1610,7 +1610,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv8(v *Value) bool {
+func rewriteValueS390X_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1631,7 +1631,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpDiv8u(v *Value) bool {
+func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1652,7 +1652,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq16(v *Value) bool {
+func rewriteValueS390X_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1681,7 +1681,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq32(v *Value) bool {
+func rewriteValueS390X_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1706,7 +1706,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq32F(v *Value) bool {
+func rewriteValueS390X_OpEq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1731,7 +1731,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq64(v *Value) bool {
+func rewriteValueS390X_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1756,7 +1756,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq64F(v *Value) bool {
+func rewriteValueS390X_OpEq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1781,7 +1781,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEq8(v *Value) bool {
+func rewriteValueS390X_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1810,7 +1810,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEqB(v *Value) bool {
+func rewriteValueS390X_OpEqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1839,7 +1839,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpEqPtr(v *Value) bool {
+func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1864,7 +1864,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq16(v *Value) bool {
+func rewriteValueS390X_OpGeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1893,7 +1893,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq16U(v *Value) bool {
+func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1922,7 +1922,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq32(v *Value) bool {
+func rewriteValueS390X_OpGeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1947,7 +1947,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq32F(v *Value) bool {
+func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1972,7 +1972,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq32U(v *Value) bool {
+func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1997,7 +1997,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq64(v *Value) bool {
+func rewriteValueS390X_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2022,7 +2022,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq64F(v *Value) bool {
+func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2047,7 +2047,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq64U(v *Value) bool {
+func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2072,7 +2072,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq8(v *Value) bool {
+func rewriteValueS390X_OpGeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2101,7 +2101,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGeq8U(v *Value) bool {
+func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2130,7 +2130,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGetClosurePtr(v *Value) bool {
+func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
 	// match: (GetClosurePtr)
 	// cond:
 	// result: (LoweredGetClosurePtr)
@@ -2139,7 +2139,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGetG(v *Value) bool {
+func rewriteValueS390X_OpGetG_0(v *Value) bool {
 	// match: (GetG mem)
 	// cond:
 	// result: (LoweredGetG mem)
@@ -2150,7 +2150,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater16(v *Value) bool {
+func rewriteValueS390X_OpGreater16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2179,7 +2179,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater16U(v *Value) bool {
+func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2208,7 +2208,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater32(v *Value) bool {
+func rewriteValueS390X_OpGreater32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2233,7 +2233,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater32F(v *Value) bool {
+func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2258,7 +2258,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater32U(v *Value) bool {
+func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2283,7 +2283,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater64(v *Value) bool {
+func rewriteValueS390X_OpGreater64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2308,7 +2308,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater64F(v *Value) bool {
+func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2333,7 +2333,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater64U(v *Value) bool {
+func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2358,7 +2358,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater8(v *Value) bool {
+func rewriteValueS390X_OpGreater8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2387,7 +2387,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpGreater8U(v *Value) bool {
+func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2416,7 +2416,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpHmul32(v *Value) bool {
+func rewriteValueS390X_OpHmul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2440,7 +2440,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpHmul32u(v *Value) bool {
+func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2464,7 +2464,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpHmul64(v *Value) bool {
+func rewriteValueS390X_OpHmul64_0(v *Value) bool {
 	// match: (Hmul64 x y)
 	// cond:
 	// result: (MULHD  x y)
@@ -2477,7 +2477,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpHmul64u(v *Value) bool {
+func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
 	// match: (Hmul64u x y)
 	// cond:
 	// result: (MULHDU x y)
@@ -2490,7 +2490,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpITab(v *Value) bool {
+func rewriteValueS390X_OpITab_0(v *Value) bool {
 	// match: (ITab (Load ptr mem))
 	// cond:
 	// result: (MOVDload ptr mem)
@@ -2508,7 +2508,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpInterCall(v *Value) bool {
+func rewriteValueS390X_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argwid] entry mem)
 	// cond:
 	// result: (CALLinter [argwid] entry mem)
@@ -2523,7 +2523,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpIsInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2548,7 +2548,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpIsNonNil(v *Value) bool {
+func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2572,7 +2572,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2597,7 +2597,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq16(v *Value) bool {
+func rewriteValueS390X_OpLeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2626,7 +2626,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq16U(v *Value) bool {
+func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2655,7 +2655,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq32(v *Value) bool {
+func rewriteValueS390X_OpLeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2680,7 +2680,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq32F(v *Value) bool {
+func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2705,7 +2705,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq32U(v *Value) bool {
+func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2730,7 +2730,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq64(v *Value) bool {
+func rewriteValueS390X_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2755,7 +2755,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq64F(v *Value) bool {
+func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2780,7 +2780,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq64U(v *Value) bool {
+func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2805,7 +2805,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq8(v *Value) bool {
+func rewriteValueS390X_OpLeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2834,7 +2834,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLeq8U(v *Value) bool {
+func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2863,7 +2863,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess16(v *Value) bool {
+func rewriteValueS390X_OpLess16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2892,7 +2892,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess16U(v *Value) bool {
+func rewriteValueS390X_OpLess16U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2921,7 +2921,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess32(v *Value) bool {
+func rewriteValueS390X_OpLess32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2946,7 +2946,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess32F(v *Value) bool {
+func rewriteValueS390X_OpLess32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2971,7 +2971,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess32U(v *Value) bool {
+func rewriteValueS390X_OpLess32U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2996,7 +2996,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess64(v *Value) bool {
+func rewriteValueS390X_OpLess64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3021,7 +3021,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess64F(v *Value) bool {
+func rewriteValueS390X_OpLess64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3046,7 +3046,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess64U(v *Value) bool {
+func rewriteValueS390X_OpLess64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3071,7 +3071,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess8(v *Value) bool {
+func rewriteValueS390X_OpLess8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3100,7 +3100,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLess8U(v *Value) bool {
+func rewriteValueS390X_OpLess8U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3129,7 +3129,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLoad(v *Value) bool {
+func rewriteValueS390X_OpLoad_0(v *Value) bool {
 	// match: (Load <t> ptr mem)
 	// cond: (is64BitInt(t) || isPtr(t))
 	// result: (MOVDload ptr mem)
@@ -3267,7 +3267,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpLsh16x16(v *Value) bool {
+func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3295,7 +3295,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh16x32(v *Value) bool {
+func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x32 <t> x y)
@@ -3319,7 +3319,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh16x64(v *Value) bool {
+func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x64 <t> x y)
@@ -3343,7 +3343,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh16x8(v *Value) bool {
+func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3371,7 +3371,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh32x16(v *Value) bool {
+func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3399,7 +3399,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh32x32(v *Value) bool {
+func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x32 <t> x y)
@@ -3423,7 +3423,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh32x64(v *Value) bool {
+func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x64 <t> x y)
@@ -3447,7 +3447,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh32x8(v *Value) bool {
+func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3475,7 +3475,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh64x16(v *Value) bool {
+func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3503,7 +3503,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh64x32(v *Value) bool {
+func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x32 <t> x y)
@@ -3527,7 +3527,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh64x64(v *Value) bool {
+func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x64 <t> x y)
@@ -3551,7 +3551,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh64x8(v *Value) bool {
+func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3579,7 +3579,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh8x16(v *Value) bool {
+func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3607,7 +3607,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh8x32(v *Value) bool {
+func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x32 <t> x y)
@@ -3631,7 +3631,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh8x64(v *Value) bool {
+func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x64 <t> x y)
@@ -3655,7 +3655,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpLsh8x8(v *Value) bool {
+func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3683,7 +3683,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod16(v *Value) bool {
+func rewriteValueS390X_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3704,7 +3704,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod16u(v *Value) bool {
+func rewriteValueS390X_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3725,7 +3725,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod32(v *Value) bool {
+func rewriteValueS390X_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3744,7 +3744,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod32u(v *Value) bool {
+func rewriteValueS390X_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3763,7 +3763,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod64(v *Value) bool {
+func rewriteValueS390X_OpMod64_0(v *Value) bool {
 	// match: (Mod64 x y)
 	// cond:
 	// result: (MODD  x y)
@@ -3776,7 +3776,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod64u(v *Value) bool {
+func rewriteValueS390X_OpMod64u_0(v *Value) bool {
 	// match: (Mod64u x y)
 	// cond:
 	// result: (MODDU x y)
@@ -3789,7 +3789,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod8(v *Value) bool {
+func rewriteValueS390X_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3810,7 +3810,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMod8u(v *Value) bool {
+func rewriteValueS390X_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -3831,7 +3831,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMove(v *Value) bool {
+func rewriteValueS390X_OpMove_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4074,6 +4074,13 @@
 		v.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpMove_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (Move [7] dst src mem)
 	// cond:
 	// result: (MOVBstore [6] dst (MOVBZload [6] src mem) 		(MOVHstore [4] dst (MOVHZload [4] src mem) 			(MOVWstore dst (MOVWZload src mem) mem)))
@@ -4237,7 +4244,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpMul16(v *Value) bool {
+func rewriteValueS390X_OpMul16_0(v *Value) bool {
 	// match: (Mul16 x y)
 	// cond:
 	// result: (MULLW  x y)
@@ -4250,7 +4257,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMul32(v *Value) bool {
+func rewriteValueS390X_OpMul32_0(v *Value) bool {
 	// match: (Mul32 x y)
 	// cond:
 	// result: (MULLW  x y)
@@ -4263,7 +4270,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMul32F(v *Value) bool {
+func rewriteValueS390X_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F x y)
 	// cond:
 	// result: (FMULS x y)
@@ -4276,7 +4283,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMul64(v *Value) bool {
+func rewriteValueS390X_OpMul64_0(v *Value) bool {
 	// match: (Mul64 x y)
 	// cond:
 	// result: (MULLD  x y)
@@ -4289,7 +4296,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMul64F(v *Value) bool {
+func rewriteValueS390X_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F x y)
 	// cond:
 	// result: (FMUL x y)
@@ -4302,7 +4309,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpMul8(v *Value) bool {
+func rewriteValueS390X_OpMul8_0(v *Value) bool {
 	// match: (Mul8 x y)
 	// cond:
 	// result: (MULLW  x y)
@@ -4315,7 +4322,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg16(v *Value) bool {
+func rewriteValueS390X_OpNeg16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4332,7 +4339,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg32(v *Value) bool {
+func rewriteValueS390X_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 x)
 	// cond:
 	// result: (NEGW x)
@@ -4343,7 +4350,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg32F(v *Value) bool {
+func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F x)
 	// cond:
 	// result: (FNEGS x)
@@ -4354,7 +4361,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg64(v *Value) bool {
+func rewriteValueS390X_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 x)
 	// cond:
 	// result: (NEG x)
@@ -4365,7 +4372,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg64F(v *Value) bool {
+func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F x)
 	// cond:
 	// result: (FNEG x)
@@ -4376,7 +4383,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeg8(v *Value) bool {
+func rewriteValueS390X_OpNeg8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4393,7 +4400,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq16(v *Value) bool {
+func rewriteValueS390X_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4422,7 +4429,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq32(v *Value) bool {
+func rewriteValueS390X_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4447,7 +4454,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq32F(v *Value) bool {
+func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4472,7 +4479,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq64(v *Value) bool {
+func rewriteValueS390X_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4497,7 +4504,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq64F(v *Value) bool {
+func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4522,7 +4529,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeq8(v *Value) bool {
+func rewriteValueS390X_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4551,7 +4558,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeqB(v *Value) bool {
+func rewriteValueS390X_OpNeqB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4580,7 +4587,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNeqPtr(v *Value) bool {
+func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4605,7 +4612,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNilCheck(v *Value) bool {
+func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
 	// match: (NilCheck ptr mem)
 	// cond:
 	// result: (LoweredNilCheck ptr mem)
@@ -4618,7 +4625,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpNot(v *Value) bool {
+func rewriteValueS390X_OpNot_0(v *Value) bool {
 	// match: (Not x)
 	// cond:
 	// result: (XORWconst [1] x)
@@ -4630,7 +4637,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOffPtr(v *Value) bool {
+func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4677,7 +4684,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOr16(v *Value) bool {
+func rewriteValueS390X_OpOr16_0(v *Value) bool {
 	// match: (Or16 x y)
 	// cond:
 	// result: (ORW x y)
@@ -4690,7 +4697,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOr32(v *Value) bool {
+func rewriteValueS390X_OpOr32_0(v *Value) bool {
 	// match: (Or32 x y)
 	// cond:
 	// result: (ORW x y)
@@ -4703,7 +4710,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOr64(v *Value) bool {
+func rewriteValueS390X_OpOr64_0(v *Value) bool {
 	// match: (Or64 x y)
 	// cond:
 	// result: (OR x y)
@@ -4716,7 +4723,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOr8(v *Value) bool {
+func rewriteValueS390X_OpOr8_0(v *Value) bool {
 	// match: (Or8 x y)
 	// cond:
 	// result: (ORW x y)
@@ -4729,7 +4736,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpOrB(v *Value) bool {
+func rewriteValueS390X_OpOrB_0(v *Value) bool {
 	// match: (OrB x y)
 	// cond:
 	// result: (ORW x y)
@@ -4742,7 +4749,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRound32F(v *Value) bool {
+func rewriteValueS390X_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x)
 	// cond:
 	// result: (LoweredRound32F x)
@@ -4753,7 +4760,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRound64F(v *Value) bool {
+func rewriteValueS390X_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x)
 	// cond:
 	// result: (LoweredRound64F x)
@@ -4764,7 +4771,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4794,7 +4801,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4822,7 +4829,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4850,7 +4857,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4880,7 +4887,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16x16(v *Value) bool {
+func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4913,7 +4920,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16x32(v *Value) bool {
+func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4944,7 +4951,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16x64(v *Value) bool {
+func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -4975,7 +4982,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh16x8(v *Value) bool {
+func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5008,7 +5015,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5036,7 +5043,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux32 <t> x y)
@@ -5060,7 +5067,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux64 <t> x y)
@@ -5084,7 +5091,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5112,7 +5119,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32x16(v *Value) bool {
+func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5143,7 +5150,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32x32(v *Value) bool {
+func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x32 <t> x y)
@@ -5170,7 +5177,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32x64(v *Value) bool {
+func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x64 <t> x y)
@@ -5197,7 +5204,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh32x8(v *Value) bool {
+func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5228,7 +5235,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5256,7 +5263,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux32 <t> x y)
@@ -5280,7 +5287,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux64 <t> x y)
@@ -5304,7 +5311,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5332,7 +5339,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64x16(v *Value) bool {
+func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5363,7 +5370,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64x32(v *Value) bool {
+func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x32 <t> x y)
@@ -5390,7 +5397,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64x64(v *Value) bool {
+func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x64 <t> x y)
@@ -5417,7 +5424,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh64x8(v *Value) bool {
+func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5448,7 +5455,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5478,7 +5485,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5506,7 +5513,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5534,7 +5541,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5564,7 +5571,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8x16(v *Value) bool {
+func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5597,7 +5604,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8x32(v *Value) bool {
+func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5628,7 +5635,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8x64(v *Value) bool {
+func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5659,7 +5666,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpRsh8x8(v *Value) bool {
+func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5692,7 +5699,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpS390XADD(v *Value) bool {
+func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
 	// match: (ADD x (MOVDconst [c]))
 	// cond: is32Bit(c)
 	// result: (ADDconst [c] x)
@@ -5907,6 +5914,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
 	// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (ADDload <t> [off] {sym} x ptr mem)
@@ -5961,7 +5971,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XADDW(v *Value) bool {
+func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
 	// match: (ADDW x (MOVDconst [c]))
 	// cond:
 	// result: (ADDWconst [c] x)
@@ -6178,6 +6188,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
 	// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (ADDWload <t> [off] {sym} x ptr mem)
@@ -6284,7 +6297,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XADDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
 	// match: (ADDWconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -6331,7 +6344,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XADDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
 	// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
 	// cond: ((c+d)&1 == 0) && is32Bit(c+d)
 	// result: (MOVDaddr [c+d] {s} x)
@@ -6448,7 +6461,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XAND(v *Value) bool {
+func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
 	// match: (AND x (MOVDconst [c]))
 	// cond: is32Bit(c) && c < 0
 	// result: (ANDconst [c] x)
@@ -6617,6 +6630,9 @@
 		v.AuxInt = c & d
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
 	// match: (AND x x)
 	// cond:
 	// result: x
@@ -6736,7 +6752,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XANDW(v *Value) bool {
+func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
 	// match: (ANDW x (MOVDconst [c]))
 	// cond:
 	// result: (ANDWconst [c] x)
@@ -6962,6 +6978,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
 	// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (ANDWload <t> [off] {sym} x ptr mem)
@@ -6990,7 +7009,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XANDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
 	// match: (ANDWconst [c] (ANDWconst [d] x))
 	// cond:
 	// result: (ANDWconst [c & d] x)
@@ -7073,7 +7092,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XANDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
 	// match: (ANDconst [c] (ANDconst [d] x))
 	// cond:
 	// result: (ANDconst [c & d] x)
@@ -7130,7 +7149,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMP(v *Value) bool {
+func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMP x (MOVDconst [c]))
@@ -7173,7 +7192,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPU x (MOVDconst [c]))
@@ -7216,7 +7235,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
 	// match: (CMPUconst (MOVDconst [x]) [y])
 	// cond: uint64(x)==uint64(y)
 	// result: (FlagEQ)
@@ -7267,7 +7286,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPW x (MOVDconst [c]))
@@ -7304,7 +7323,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (CMPWU x (MOVDconst [c]))
@@ -7341,7 +7360,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
 	// match: (CMPWUconst (MOVDconst [x]) [y])
 	// cond: uint32(x)==uint32(y)
 	// result: (FlagEQ)
@@ -7392,7 +7411,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
 	// match: (CMPWconst (MOVDconst [x]) [y])
 	// cond: int32(x)==int32(y)
 	// result: (FlagEQ)
@@ -7475,7 +7494,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
 	// match: (CMPconst (MOVDconst [x]) [y])
 	// cond: x==y
 	// result: (FlagEQ)
@@ -7603,7 +7622,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFADD(v *Value) bool {
+func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
 	// match: (FADD (FMUL y z) x)
 	// cond:
 	// result: (FMADD x y z)
@@ -7640,7 +7659,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFADDS(v *Value) bool {
+func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
 	// match: (FADDS (FMULS y z) x)
 	// cond:
 	// result: (FMADDS x y z)
@@ -7677,7 +7696,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
 	// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: is20Bit(off1+off2)
 	// result: (FMOVDload [off1+off2] {sym} ptr mem)
@@ -7777,7 +7796,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
 	// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
@@ -7824,7 +7843,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
 	// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: is20Bit(off1+off2)
 	// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -7932,7 +7951,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
 	// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
@@ -7983,7 +8002,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
 	// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: is20Bit(off1+off2)
 	// result: (FMOVSload [off1+off2] {sym} ptr mem)
@@ -8083,7 +8102,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
 	// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
@@ -8130,7 +8149,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
 	// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: is20Bit(off1+off2)
 	// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -8238,7 +8257,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
 	// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
@@ -8289,7 +8308,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
 	// match: (FSUB (FMUL y z) x)
 	// cond:
 	// result: (FMSUB x y z)
@@ -8309,7 +8328,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XFSUBS(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
 	// match: (FSUBS (FMULS y z) x)
 	// cond:
 	// result: (FMSUBS x y z)
@@ -8329,7 +8348,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
 	// match: (LoweredRound32F x:(FMOVSconst))
 	// cond:
 	// result: x
@@ -8345,7 +8364,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
 	// match: (LoweredRound64F x:(FMOVDconst))
 	// cond:
 	// result: x
@@ -8361,7 +8380,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
 	// match: (MOVBZload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: (MOVBZreg x)
@@ -8483,7 +8502,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
 	// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
@@ -8574,9 +8593,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
 	// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 	// result: (MOVDreg x)
@@ -8805,6 +8822,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MOVBZreg x:(MOVBZreg _))
 	// cond:
 	// result: (MOVDreg x)
@@ -8884,7 +8906,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
 	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: is20Bit(off1+off2)
 	// result: (MOVBload  [off1+off2] {sym} ptr mem)
@@ -8934,7 +8956,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVBreg x:(MOVBload _ _))
@@ -9017,7 +9039,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
 	// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
 	// cond:
 	// result: (MOVBstore [off] {sym} ptr x mem)
@@ -9322,6 +9344,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
 	// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
 	// result: (MOVHstore [i-1] {s} p w0 mem)
@@ -9554,7 +9579,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
 	// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -9633,7 +9658,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
 	// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
@@ -10028,6 +10053,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
 	// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
@@ -10538,6 +10566,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool {
 	// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
@@ -11038,6 +11069,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool {
 	// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
@@ -11348,7 +11382,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool {
 	// match: (MOVDEQ x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDEQ x y cmp)
@@ -11410,7 +11444,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool {
 	// match: (MOVDGE x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDLE x y cmp)
@@ -11472,7 +11506,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool {
 	// match: (MOVDGT x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDLT x y cmp)
@@ -11534,7 +11568,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool {
 	// match: (MOVDLE x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDGE x y cmp)
@@ -11596,7 +11630,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool {
 	// match: (MOVDLT x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDGT x y cmp)
@@ -11658,7 +11692,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool {
 	// match: (MOVDNE x y (InvertFlags cmp))
 	// cond:
 	// result: (MOVDNE x y cmp)
@@ -11720,7 +11754,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
 	// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
 	// cond: is20Bit(c+d) && x.Op != OpSB
 	// result: (MOVDaddridx [c+d] {s} x y)
@@ -11817,7 +11851,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
 	// match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: (MOVDreg x)
@@ -11939,7 +11973,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
 	// match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
@@ -12030,7 +12064,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVDnop <t> x)
@@ -12270,6 +12304,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MOVDnop <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
 	// cond: x.Uses == 1 && clobber(x)
 	// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
@@ -12356,7 +12395,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVDreg <t> x)
@@ -12580,6 +12619,11 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MOVDreg <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
 	// cond: x.Uses == 1 && clobber(x)
 	// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
@@ -12694,7 +12738,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 	// cond: is20Bit(off1+off2)
 	// result: (MOVDstore  [off1+off2] {sym} ptr val mem)
@@ -12936,7 +12980,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
 	// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -12986,7 +13030,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
 	// match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
@@ -13085,7 +13129,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
 	// match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWBRstore [i-2] {s} p w mem)
@@ -13270,7 +13314,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
 	// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
@@ -13771,6 +13815,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool {
 	// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
@@ -14081,7 +14128,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
 	// match: (MOVHZload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: (MOVHZreg x)
@@ -14203,7 +14250,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
 	// match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
@@ -14294,7 +14341,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVHZreg x:(MOVBZload _ _))
@@ -14428,7 +14475,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
 	// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: is20Bit(off1+off2)
 	// result: (MOVHload  [off1+off2] {sym} ptr mem)
@@ -14478,7 +14525,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVHreg x:(MOVBload _ _))
@@ -14609,7 +14656,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
 	// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
 	// cond:
 	// result: (MOVHstore [off] {sym} ptr x mem)
@@ -14914,6 +14961,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
 	// match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem))
 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
 	// result: (MOVWstore [i-2] {s} p w0 mem)
@@ -14964,7 +15014,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
 	// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 	// cond: ValAndOff(sc).canAdd(off)
 	// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -15043,7 +15093,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
 	// match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
@@ -15438,6 +15488,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool {
 	// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
@@ -15950,7 +16003,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
 	// match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVDBRstore [i-4] {s} p w mem)
@@ -16044,7 +16097,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
 	// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
@@ -16451,7 +16504,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
 	// match: (MOVWZload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
 	// result: (MOVWZreg x)
@@ -16573,7 +16626,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
 	// match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 	// cond:
 	// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
@@ -16664,7 +16717,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MOVWZreg x:(MOVBZload _ _))
@@ -16822,7 +16875,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
 	// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
 	// cond: is20Bit(off1+off2)
 	// result: (MOVWload  [off1+off2] {sym} ptr mem)
@@ -16872,9 +16925,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
 	// match: (MOVWreg x:(MOVBload _ _))
 	// cond:
 	// result: (MOVDreg x)
@@ -16999,6 +17050,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (MOVWreg x:(MOVWreg _))
 	// cond:
 	// result: (MOVDreg x)
@@ -17051,7 +17107,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
 	// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
 	// cond:
 	// result: (MOVWstore [off] {sym} ptr x mem)
@@ -17348,6 +17404,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
 	// match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem))
 	// cond: x.Uses == 1   && is20Bit(i-8)   && clobber(x)
 	// result: (STM3 [i-8] {s} p w0 w1 w2 mem)
@@ -17426,7 +17485,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -17512,7 +17571,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
 	// match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 	// cond:
 	// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
@@ -17907,6 +17966,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool {
 	// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
 	// cond: x.Uses == 1   && clobber(x)
 	// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
@@ -18015,7 +18077,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMULLD(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
 	// match: (MULLD x (MOVDconst [c]))
 	// cond: is32Bit(c)
 	// result: (MULLDconst [c] x)
@@ -18158,7 +18220,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MULLDconst [-1] x)
@@ -18261,7 +18323,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMULLW(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
 	// match: (MULLW x (MOVDconst [c]))
 	// cond:
 	// result: (MULLWconst [c] x)
@@ -18502,7 +18564,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (MULLWconst [-1] x)
@@ -18605,7 +18667,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XNEG(v *Value) bool {
+func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
 	// match: (NEG (MOVDconst [c]))
 	// cond:
 	// result: (MOVDconst [-c])
@@ -18643,7 +18705,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XNEGW(v *Value) bool {
+func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
 	// match: (NEGW (MOVDconst [c]))
 	// cond:
 	// result: (MOVDconst [int64(int32(-c))])
@@ -18659,7 +18721,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XNOT(v *Value) bool {
+func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -18681,7 +18743,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XNOTW(v *Value) bool {
+func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
 	// match: (NOTW x)
 	// cond: true
 	// result: (XORWconst [-1] x)
@@ -18697,11 +18759,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XOR(v *Value) bool {
-	b := v.Block
-	_ = b
-	types := &b.Func.Config.Types
-	_ = types
+func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
 	// match: (OR x (MOVDconst [c]))
 	// cond: isU32Bit(c)
 	// result: (ORconst [c] x)
@@ -18917,6 +18975,13 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (ORload <t> [off] {sym} x ptr mem)
@@ -19399,6 +19464,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
@@ -19954,6 +20026,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_30(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
@@ -20464,6 +20543,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_40(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
@@ -20988,6 +21074,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_50(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -21638,6 +21731,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_60(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -22288,6 +22388,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_70(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
@@ -22938,6 +23045,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_80(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
@@ -23505,6 +23619,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_90(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
@@ -24112,6 +24233,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_100(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
@@ -24698,6 +24826,13 @@
 		v0.AddArg(v1)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_110(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
@@ -25298,6 +25433,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_120(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -25968,6 +26110,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_130(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -26678,6 +26827,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_140(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
@@ -27428,6 +27584,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XOR_150(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
@@ -27505,11 +27668,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XORW(v *Value) bool {
-	b := v.Block
-	_ = b
-	types := &b.Func.Config.Types
-	_ = types
+func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
 	// match: (ORW x (MOVDconst [c]))
 	// cond:
 	// result: (ORWconst [c] x)
@@ -27735,6 +27894,13 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (ORWload <t> [off] {sym} x ptr mem)
@@ -28177,6 +28343,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_20(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
@@ -28696,6 +28869,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_30(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
@@ -29248,6 +29428,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_40(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -29898,6 +30085,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_50(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -30483,6 +30677,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_60(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
@@ -31028,6 +31229,13 @@
 		v0.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_70(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
@@ -31642,6 +31850,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_80(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -32312,6 +32527,13 @@
 		v0.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XORW_90(v *Value) bool {
+	b := v.Block
+	_ = b
+	types := &b.Func.Config.Types
+	_ = types
 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -32515,7 +32737,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
 	// match: (ORWconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -32558,7 +32780,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
 	// match: (ORconst [0] x)
 	// cond:
 	// result: x
@@ -32599,7 +32821,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSLD(v *Value) bool {
+func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
 	// match: (SLD x (MOVDconst [c]))
 	// cond:
 	// result: (SLDconst [c&63] x)
@@ -32635,7 +32857,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSLW(v *Value) bool {
+func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
 	// match: (SLW x (MOVDconst [c]))
 	// cond:
 	// result: (SLWconst [c&63] x)
@@ -32671,7 +32893,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
 	// match: (SRAD x (MOVDconst [c]))
 	// cond:
 	// result: (SRADconst [c&63] x)
@@ -32707,7 +32929,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
 	// match: (SRADconst [c] (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [d>>uint64(c)])
@@ -32724,7 +32946,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
 	// match: (SRAW x (MOVDconst [c]))
 	// cond:
 	// result: (SRAWconst [c&63] x)
@@ -32760,7 +32982,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
 	// match: (SRAWconst [c] (MOVDconst [d]))
 	// cond:
 	// result: (MOVDconst [d>>uint64(c)])
@@ -32777,7 +32999,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
 	// match: (SRD x (MOVDconst [c]))
 	// cond:
 	// result: (SRDconst [c&63] x)
@@ -32813,7 +33035,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSRW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
 	// match: (SRW x (MOVDconst [c]))
 	// cond:
 	// result: (SRWconst [c&63] x)
@@ -32849,7 +33071,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSTM2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
 	// match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem))
 	// cond: x.Uses == 1   && is20Bit(i-8)   && clobber(x)
 	// result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem)
@@ -32918,7 +33140,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSTMG2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
 	// match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem))
 	// cond: x.Uses == 1   && is20Bit(i-16)   && clobber(x)
 	// result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem)
@@ -32960,7 +33182,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUB x (MOVDconst [c]))
@@ -33041,7 +33263,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEWcarrymask_0(v *Value) bool {
 	// match: (SUBEWcarrymask (FlagEQ))
 	// cond:
 	// result: (MOVDconst [-1])
@@ -33080,7 +33302,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEcarrymask_0(v *Value) bool {
 	// match: (SUBEcarrymask (FlagEQ))
 	// cond:
 	// result: (MOVDconst [-1])
@@ -33119,7 +33341,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSUBW(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (SUBW x (MOVDconst [c]))
@@ -33220,7 +33442,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
 	// match: (SUBWconst [c] x)
 	// cond: int32(c) == 0
 	// result: x
@@ -33247,7 +33469,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpS390XSUBconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
 	// match: (SUBconst [0] x)
 	// cond:
 	// result: x
@@ -33310,7 +33532,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XXOR(v *Value) bool {
+func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
 	// match: (XOR x (MOVDconst [c]))
 	// cond: isU32Bit(c)
 	// result: (XORconst [c] x)
@@ -33525,6 +33747,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XXOR_10(v *Value) bool {
 	// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (XORload <t> [off] {sym} x ptr mem)
@@ -33553,7 +33778,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XXORW(v *Value) bool {
+func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
 	// match: (XORW x (MOVDconst [c]))
 	// cond:
 	// result: (XORWconst [c] x)
@@ -33778,6 +34003,9 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpS390XXORW_10(v *Value) bool {
 	// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
 	// result: (XORWload <t> [off] {sym} x ptr mem)
@@ -33858,7 +34086,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XXORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
 	// match: (XORWconst [c] x)
 	// cond: int32(c)==0
 	// result: x
@@ -33889,7 +34117,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpS390XXORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
 	// match: (XORconst [0] x)
 	// cond:
 	// result: x
@@ -33919,7 +34147,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpSelect0(v *Value) bool {
+func rewriteValueS390X_OpSelect0_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Select0 <t> (AddTupleFirst32 tuple val))
@@ -33960,7 +34188,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpSelect1(v *Value) bool {
+func rewriteValueS390X_OpSelect1_0(v *Value) bool {
 	// match: (Select1 (AddTupleFirst32 tuple _))
 	// cond:
 	// result: (Select1 tuple)
@@ -33989,7 +34217,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpSignExt16to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -34000,7 +34228,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSignExt16to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 x)
 	// cond:
 	// result: (MOVHreg x)
@@ -34011,7 +34239,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSignExt32to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 x)
 	// cond:
 	// result: (MOVWreg x)
@@ -34022,7 +34250,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSignExt8to16(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -34033,7 +34261,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSignExt8to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -34044,7 +34272,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSignExt8to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 x)
 	// cond:
 	// result: (MOVBreg x)
@@ -34055,7 +34283,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSlicemask(v *Value) bool {
+func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Slicemask <t> x)
@@ -34072,7 +34300,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSqrt(v *Value) bool {
+func rewriteValueS390X_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt x)
 	// cond:
 	// result: (FSQRT x)
@@ -34083,7 +34311,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpStaticCall(v *Value) bool {
+func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
 	// match: (StaticCall [argwid] {target} mem)
 	// cond:
 	// result: (CALLstatic [argwid] {target} mem)
@@ -34098,7 +34326,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpStore(v *Value) bool {
+func rewriteValueS390X_OpStore_0(v *Value) bool {
 	// match: (Store {t} ptr val mem)
 	// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
 	// result: (FMOVDstore ptr val mem)
@@ -34203,7 +34431,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpSub16(v *Value) bool {
+func rewriteValueS390X_OpSub16_0(v *Value) bool {
 	// match: (Sub16 x y)
 	// cond:
 	// result: (SUBW  x y)
@@ -34216,7 +34444,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSub32(v *Value) bool {
+func rewriteValueS390X_OpSub32_0(v *Value) bool {
 	// match: (Sub32 x y)
 	// cond:
 	// result: (SUBW  x y)
@@ -34229,7 +34457,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSub32F(v *Value) bool {
+func rewriteValueS390X_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F x y)
 	// cond:
 	// result: (FSUBS x y)
@@ -34242,7 +34470,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSub64(v *Value) bool {
+func rewriteValueS390X_OpSub64_0(v *Value) bool {
 	// match: (Sub64 x y)
 	// cond:
 	// result: (SUB  x y)
@@ -34255,7 +34483,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSub64F(v *Value) bool {
+func rewriteValueS390X_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F x y)
 	// cond:
 	// result: (FSUB x y)
@@ -34268,7 +34496,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSub8(v *Value) bool {
+func rewriteValueS390X_OpSub8_0(v *Value) bool {
 	// match: (Sub8 x y)
 	// cond:
 	// result: (SUBW  x y)
@@ -34281,7 +34509,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpSubPtr(v *Value) bool {
+func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
 	// match: (SubPtr x y)
 	// cond:
 	// result: (SUB  x y)
@@ -34294,7 +34522,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc16to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 x)
 	// cond:
 	// result: x
@@ -34306,7 +34534,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc32to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 x)
 	// cond:
 	// result: x
@@ -34318,7 +34546,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc32to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 x)
 	// cond:
 	// result: x
@@ -34330,7 +34558,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc64to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 x)
 	// cond:
 	// result: x
@@ -34342,7 +34570,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc64to32(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 x)
 	// cond:
 	// result: x
@@ -34354,7 +34582,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpTrunc64to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 x)
 	// cond:
 	// result: x
@@ -34366,7 +34594,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpXor16(v *Value) bool {
+func rewriteValueS390X_OpXor16_0(v *Value) bool {
 	// match: (Xor16 x y)
 	// cond:
 	// result: (XORW x y)
@@ -34379,7 +34607,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpXor32(v *Value) bool {
+func rewriteValueS390X_OpXor32_0(v *Value) bool {
 	// match: (Xor32 x y)
 	// cond:
 	// result: (XORW x y)
@@ -34392,7 +34620,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpXor64(v *Value) bool {
+func rewriteValueS390X_OpXor64_0(v *Value) bool {
 	// match: (Xor64 x y)
 	// cond:
 	// result: (XOR x y)
@@ -34405,7 +34633,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpXor8(v *Value) bool {
+func rewriteValueS390X_OpXor8_0(v *Value) bool {
 	// match: (Xor8 x y)
 	// cond:
 	// result: (XORW x y)
@@ -34418,7 +34646,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZero(v *Value) bool {
+func rewriteValueS390X_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Zero [0] _ mem)
@@ -34586,6 +34814,11 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValueS390X_OpZero_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Zero [s] destptr mem)
 	// cond: s > 1024
 	// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
@@ -34608,7 +34841,7 @@
 	}
 	return false
 }
-func rewriteValueS390X_OpZeroExt16to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 x)
 	// cond:
 	// result: (MOVHZreg x)
@@ -34619,7 +34852,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZeroExt16to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 x)
 	// cond:
 	// result: (MOVHZreg x)
@@ -34630,7 +34863,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZeroExt32to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 x)
 	// cond:
 	// result: (MOVWZreg x)
@@ -34641,7 +34874,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZeroExt8to16(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 x)
 	// cond:
 	// result: (MOVBZreg x)
@@ -34652,7 +34885,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZeroExt8to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 x)
 	// cond:
 	// result: (MOVBZreg x)
@@ -34663,7 +34896,7 @@
 		return true
 	}
 }
-func rewriteValueS390X_OpZeroExt8to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 x)
 	// cond:
 	// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go
index 305fc7b..7040abb 100644
--- a/src/cmd/compile/internal/ssa/rewritedec.go
+++ b/src/cmd/compile/internal/ssa/rewritedec.go
@@ -14,31 +14,31 @@
 func rewriteValuedec(v *Value) bool {
 	switch v.Op {
 	case OpComplexImag:
-		return rewriteValuedec_OpComplexImag(v)
+		return rewriteValuedec_OpComplexImag_0(v)
 	case OpComplexReal:
-		return rewriteValuedec_OpComplexReal(v)
+		return rewriteValuedec_OpComplexReal_0(v)
 	case OpIData:
-		return rewriteValuedec_OpIData(v)
+		return rewriteValuedec_OpIData_0(v)
 	case OpITab:
-		return rewriteValuedec_OpITab(v)
+		return rewriteValuedec_OpITab_0(v)
 	case OpLoad:
-		return rewriteValuedec_OpLoad(v)
+		return rewriteValuedec_OpLoad_0(v)
 	case OpSliceCap:
-		return rewriteValuedec_OpSliceCap(v)
+		return rewriteValuedec_OpSliceCap_0(v)
 	case OpSliceLen:
-		return rewriteValuedec_OpSliceLen(v)
+		return rewriteValuedec_OpSliceLen_0(v)
 	case OpSlicePtr:
-		return rewriteValuedec_OpSlicePtr(v)
+		return rewriteValuedec_OpSlicePtr_0(v)
 	case OpStore:
-		return rewriteValuedec_OpStore(v)
+		return rewriteValuedec_OpStore_0(v)
 	case OpStringLen:
-		return rewriteValuedec_OpStringLen(v)
+		return rewriteValuedec_OpStringLen_0(v)
 	case OpStringPtr:
-		return rewriteValuedec_OpStringPtr(v)
+		return rewriteValuedec_OpStringPtr_0(v)
 	}
 	return false
 }
-func rewriteValuedec_OpComplexImag(v *Value) bool {
+func rewriteValuedec_OpComplexImag_0(v *Value) bool {
 	// match: (ComplexImag (ComplexMake _ imag))
 	// cond:
 	// result: imag
@@ -55,7 +55,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpComplexReal(v *Value) bool {
+func rewriteValuedec_OpComplexReal_0(v *Value) bool {
 	// match: (ComplexReal (ComplexMake real _))
 	// cond:
 	// result: real
@@ -72,7 +72,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpIData(v *Value) bool {
+func rewriteValuedec_OpIData_0(v *Value) bool {
 	// match: (IData (IMake _ data))
 	// cond:
 	// result: data
@@ -89,7 +89,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpITab(v *Value) bool {
+func rewriteValuedec_OpITab_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (ITab (IMake itab _))
@@ -108,7 +108,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpLoad(v *Value) bool {
+func rewriteValuedec_OpLoad_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -244,7 +244,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpSliceCap(v *Value) bool {
+func rewriteValuedec_OpSliceCap_0(v *Value) bool {
 	// match: (SliceCap (SliceMake _ _ cap))
 	// cond:
 	// result: cap
@@ -261,7 +261,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpSliceLen(v *Value) bool {
+func rewriteValuedec_OpSliceLen_0(v *Value) bool {
 	// match: (SliceLen (SliceMake _ len _))
 	// cond:
 	// result: len
@@ -278,7 +278,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpSlicePtr(v *Value) bool {
+func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
 	// match: (SlicePtr (SliceMake ptr _ _))
 	// cond:
 	// result: ptr
@@ -295,7 +295,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpStore(v *Value) bool {
+func rewriteValuedec_OpStore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -456,7 +456,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpStringLen(v *Value) bool {
+func rewriteValuedec_OpStringLen_0(v *Value) bool {
 	// match: (StringLen (StringMake _ len))
 	// cond:
 	// result: len
@@ -473,7 +473,7 @@
 	}
 	return false
 }
-func rewriteValuedec_OpStringPtr(v *Value) bool {
+func rewriteValuedec_OpStringPtr_0(v *Value) bool {
 	// match: (StringPtr (StringMake ptr _))
 	// cond:
 	// result: ptr
diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index 4b9b378..0fe0d21 100644
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -14,123 +14,123 @@
 func rewriteValuedec64(v *Value) bool {
 	switch v.Op {
 	case OpAdd64:
-		return rewriteValuedec64_OpAdd64(v)
+		return rewriteValuedec64_OpAdd64_0(v)
 	case OpAnd64:
-		return rewriteValuedec64_OpAnd64(v)
+		return rewriteValuedec64_OpAnd64_0(v)
 	case OpArg:
-		return rewriteValuedec64_OpArg(v)
+		return rewriteValuedec64_OpArg_0(v)
 	case OpBitLen64:
-		return rewriteValuedec64_OpBitLen64(v)
+		return rewriteValuedec64_OpBitLen64_0(v)
 	case OpBswap64:
-		return rewriteValuedec64_OpBswap64(v)
+		return rewriteValuedec64_OpBswap64_0(v)
 	case OpCom64:
-		return rewriteValuedec64_OpCom64(v)
+		return rewriteValuedec64_OpCom64_0(v)
 	case OpConst64:
-		return rewriteValuedec64_OpConst64(v)
+		return rewriteValuedec64_OpConst64_0(v)
 	case OpCtz64:
-		return rewriteValuedec64_OpCtz64(v)
+		return rewriteValuedec64_OpCtz64_0(v)
 	case OpEq64:
-		return rewriteValuedec64_OpEq64(v)
+		return rewriteValuedec64_OpEq64_0(v)
 	case OpGeq64:
-		return rewriteValuedec64_OpGeq64(v)
+		return rewriteValuedec64_OpGeq64_0(v)
 	case OpGeq64U:
-		return rewriteValuedec64_OpGeq64U(v)
+		return rewriteValuedec64_OpGeq64U_0(v)
 	case OpGreater64:
-		return rewriteValuedec64_OpGreater64(v)
+		return rewriteValuedec64_OpGreater64_0(v)
 	case OpGreater64U:
-		return rewriteValuedec64_OpGreater64U(v)
+		return rewriteValuedec64_OpGreater64U_0(v)
 	case OpInt64Hi:
-		return rewriteValuedec64_OpInt64Hi(v)
+		return rewriteValuedec64_OpInt64Hi_0(v)
 	case OpInt64Lo:
-		return rewriteValuedec64_OpInt64Lo(v)
+		return rewriteValuedec64_OpInt64Lo_0(v)
 	case OpLeq64:
-		return rewriteValuedec64_OpLeq64(v)
+		return rewriteValuedec64_OpLeq64_0(v)
 	case OpLeq64U:
-		return rewriteValuedec64_OpLeq64U(v)
+		return rewriteValuedec64_OpLeq64U_0(v)
 	case OpLess64:
-		return rewriteValuedec64_OpLess64(v)
+		return rewriteValuedec64_OpLess64_0(v)
 	case OpLess64U:
-		return rewriteValuedec64_OpLess64U(v)
+		return rewriteValuedec64_OpLess64U_0(v)
 	case OpLoad:
-		return rewriteValuedec64_OpLoad(v)
+		return rewriteValuedec64_OpLoad_0(v)
 	case OpLsh16x64:
-		return rewriteValuedec64_OpLsh16x64(v)
+		return rewriteValuedec64_OpLsh16x64_0(v)
 	case OpLsh32x64:
-		return rewriteValuedec64_OpLsh32x64(v)
+		return rewriteValuedec64_OpLsh32x64_0(v)
 	case OpLsh64x16:
-		return rewriteValuedec64_OpLsh64x16(v)
+		return rewriteValuedec64_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValuedec64_OpLsh64x32(v)
+		return rewriteValuedec64_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValuedec64_OpLsh64x64(v)
+		return rewriteValuedec64_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValuedec64_OpLsh64x8(v)
+		return rewriteValuedec64_OpLsh64x8_0(v)
 	case OpLsh8x64:
-		return rewriteValuedec64_OpLsh8x64(v)
+		return rewriteValuedec64_OpLsh8x64_0(v)
 	case OpMul64:
-		return rewriteValuedec64_OpMul64(v)
+		return rewriteValuedec64_OpMul64_0(v)
 	case OpNeg64:
-		return rewriteValuedec64_OpNeg64(v)
+		return rewriteValuedec64_OpNeg64_0(v)
 	case OpNeq64:
-		return rewriteValuedec64_OpNeq64(v)
+		return rewriteValuedec64_OpNeq64_0(v)
 	case OpOr64:
-		return rewriteValuedec64_OpOr64(v)
+		return rewriteValuedec64_OpOr64_0(v)
 	case OpRsh16Ux64:
-		return rewriteValuedec64_OpRsh16Ux64(v)
+		return rewriteValuedec64_OpRsh16Ux64_0(v)
 	case OpRsh16x64:
-		return rewriteValuedec64_OpRsh16x64(v)
+		return rewriteValuedec64_OpRsh16x64_0(v)
 	case OpRsh32Ux64:
-		return rewriteValuedec64_OpRsh32Ux64(v)
+		return rewriteValuedec64_OpRsh32Ux64_0(v)
 	case OpRsh32x64:
-		return rewriteValuedec64_OpRsh32x64(v)
+		return rewriteValuedec64_OpRsh32x64_0(v)
 	case OpRsh64Ux16:
-		return rewriteValuedec64_OpRsh64Ux16(v)
+		return rewriteValuedec64_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValuedec64_OpRsh64Ux32(v)
+		return rewriteValuedec64_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValuedec64_OpRsh64Ux64(v)
+		return rewriteValuedec64_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValuedec64_OpRsh64Ux8(v)
+		return rewriteValuedec64_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValuedec64_OpRsh64x16(v)
+		return rewriteValuedec64_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValuedec64_OpRsh64x32(v)
+		return rewriteValuedec64_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValuedec64_OpRsh64x64(v)
+		return rewriteValuedec64_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValuedec64_OpRsh64x8(v)
+		return rewriteValuedec64_OpRsh64x8_0(v)
 	case OpRsh8Ux64:
-		return rewriteValuedec64_OpRsh8Ux64(v)
+		return rewriteValuedec64_OpRsh8Ux64_0(v)
 	case OpRsh8x64:
-		return rewriteValuedec64_OpRsh8x64(v)
+		return rewriteValuedec64_OpRsh8x64_0(v)
 	case OpSignExt16to64:
-		return rewriteValuedec64_OpSignExt16to64(v)
+		return rewriteValuedec64_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValuedec64_OpSignExt32to64(v)
+		return rewriteValuedec64_OpSignExt32to64_0(v)
 	case OpSignExt8to64:
-		return rewriteValuedec64_OpSignExt8to64(v)
+		return rewriteValuedec64_OpSignExt8to64_0(v)
 	case OpStore:
-		return rewriteValuedec64_OpStore(v)
+		return rewriteValuedec64_OpStore_0(v)
 	case OpSub64:
-		return rewriteValuedec64_OpSub64(v)
+		return rewriteValuedec64_OpSub64_0(v)
 	case OpTrunc64to16:
-		return rewriteValuedec64_OpTrunc64to16(v)
+		return rewriteValuedec64_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValuedec64_OpTrunc64to32(v)
+		return rewriteValuedec64_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValuedec64_OpTrunc64to8(v)
+		return rewriteValuedec64_OpTrunc64to8_0(v)
 	case OpXor64:
-		return rewriteValuedec64_OpXor64(v)
+		return rewriteValuedec64_OpXor64_0(v)
 	case OpZeroExt16to64:
-		return rewriteValuedec64_OpZeroExt16to64(v)
+		return rewriteValuedec64_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValuedec64_OpZeroExt32to64(v)
+		return rewriteValuedec64_OpZeroExt32to64_0(v)
 	case OpZeroExt8to64:
-		return rewriteValuedec64_OpZeroExt8to64(v)
+		return rewriteValuedec64_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValuedec64_OpAdd64(v *Value) bool {
+func rewriteValuedec64_OpAdd64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -173,7 +173,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpAnd64(v *Value) bool {
+func rewriteValuedec64_OpAnd64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -204,7 +204,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpArg(v *Value) bool {
+func rewriteValuedec64_OpArg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -293,7 +293,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpBitLen64(v *Value) bool {
+func rewriteValuedec64_OpBitLen64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -325,7 +325,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpBswap64(v *Value) bool {
+func rewriteValuedec64_OpBswap64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -349,7 +349,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpCom64(v *Value) bool {
+func rewriteValuedec64_OpCom64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -373,7 +373,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpConst64(v *Value) bool {
+func rewriteValuedec64_OpConst64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -416,7 +416,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpCtz64(v *Value) bool {
+func rewriteValuedec64_OpCtz64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -450,7 +450,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpEq64(v *Value) bool {
+func rewriteValuedec64_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -481,7 +481,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpGeq64(v *Value) bool {
+func rewriteValuedec64_OpGeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -522,7 +522,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpGeq64U(v *Value) bool {
+func rewriteValuedec64_OpGeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -563,7 +563,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpGreater64(v *Value) bool {
+func rewriteValuedec64_OpGreater64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -604,7 +604,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpGreater64U(v *Value) bool {
+func rewriteValuedec64_OpGreater64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -645,7 +645,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpInt64Hi(v *Value) bool {
+func rewriteValuedec64_OpInt64Hi_0(v *Value) bool {
 	// match: (Int64Hi (Int64Make hi _))
 	// cond:
 	// result: hi
@@ -662,7 +662,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpInt64Lo(v *Value) bool {
+func rewriteValuedec64_OpInt64Lo_0(v *Value) bool {
 	// match: (Int64Lo (Int64Make _ lo))
 	// cond:
 	// result: lo
@@ -679,7 +679,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLeq64(v *Value) bool {
+func rewriteValuedec64_OpLeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -720,7 +720,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpLeq64U(v *Value) bool {
+func rewriteValuedec64_OpLeq64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -761,7 +761,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpLess64(v *Value) bool {
+func rewriteValuedec64_OpLess64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -802,7 +802,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpLess64U(v *Value) bool {
+func rewriteValuedec64_OpLess64U_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -843,7 +843,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpLoad(v *Value) bool {
+func rewriteValuedec64_OpLoad_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -948,7 +948,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh16x64(v *Value) bool {
+func rewriteValuedec64_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1021,7 +1021,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh32x64(v *Value) bool {
+func rewriteValuedec64_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1094,7 +1094,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh64x16(v *Value) bool {
+func rewriteValuedec64_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1145,7 +1145,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh64x32(v *Value) bool {
+func rewriteValuedec64_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1196,7 +1196,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh64x64(v *Value) bool {
+func rewriteValuedec64_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1269,7 +1269,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh64x8(v *Value) bool {
+func rewriteValuedec64_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1320,7 +1320,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpLsh8x64(v *Value) bool {
+func rewriteValuedec64_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1393,7 +1393,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpMul64(v *Value) bool {
+func rewriteValuedec64_OpMul64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1448,7 +1448,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpNeg64(v *Value) bool {
+func rewriteValuedec64_OpNeg64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neg64 <t> x)
@@ -1465,7 +1465,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpNeq64(v *Value) bool {
+func rewriteValuedec64_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1496,7 +1496,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpOr64(v *Value) bool {
+func rewriteValuedec64_OpOr64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1527,7 +1527,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1600,7 +1600,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh16x64(v *Value) bool {
+func rewriteValuedec64_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1676,7 +1676,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1749,7 +1749,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh32x64(v *Value) bool {
+func rewriteValuedec64_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1823,7 +1823,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1874,7 +1874,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1925,7 +1925,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -1998,7 +1998,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2049,7 +2049,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64x16(v *Value) bool {
+func rewriteValuedec64_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2112,7 +2112,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64x32(v *Value) bool {
+func rewriteValuedec64_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2173,7 +2173,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64x64(v *Value) bool {
+func rewriteValuedec64_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2256,7 +2256,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh64x8(v *Value) bool {
+func rewriteValuedec64_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2319,7 +2319,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2392,7 +2392,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpRsh8x64(v *Value) bool {
+func rewriteValuedec64_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2468,7 +2468,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2485,7 +2485,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2503,7 +2503,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2520,7 +2520,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpStore(v *Value) bool {
+func rewriteValuedec64_OpStore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -2589,7 +2589,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpSub64(v *Value) bool {
+func rewriteValuedec64_OpSub64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2632,7 +2632,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 (Int64Make _ lo))
 	// cond:
 	// result: (Trunc32to16 lo)
@@ -2648,7 +2648,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 (Int64Make _ lo))
 	// cond:
 	// result: lo
@@ -2665,7 +2665,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 (Int64Make _ lo))
 	// cond:
 	// result: (Trunc32to8 lo)
@@ -2681,7 +2681,7 @@
 	}
 	return false
 }
-func rewriteValuedec64_OpXor64(v *Value) bool {
+func rewriteValuedec64_OpXor64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2712,7 +2712,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2729,7 +2729,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -2747,7 +2747,7 @@
 		return true
 	}
 }
-func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 5bd4cac..70ce0d2 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -14,417 +14,417 @@
 func rewriteValuegeneric(v *Value) bool {
 	switch v.Op {
 	case OpAdd16:
-		return rewriteValuegeneric_OpAdd16(v)
+		return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v)
 	case OpAdd32:
-		return rewriteValuegeneric_OpAdd32(v)
+		return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v)
 	case OpAdd32F:
-		return rewriteValuegeneric_OpAdd32F(v)
+		return rewriteValuegeneric_OpAdd32F_0(v)
 	case OpAdd64:
-		return rewriteValuegeneric_OpAdd64(v)
+		return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v)
 	case OpAdd64F:
-		return rewriteValuegeneric_OpAdd64F(v)
+		return rewriteValuegeneric_OpAdd64F_0(v)
 	case OpAdd8:
-		return rewriteValuegeneric_OpAdd8(v)
+		return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v)
 	case OpAddPtr:
-		return rewriteValuegeneric_OpAddPtr(v)
+		return rewriteValuegeneric_OpAddPtr_0(v)
 	case OpAnd16:
-		return rewriteValuegeneric_OpAnd16(v)
+		return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v)
 	case OpAnd32:
-		return rewriteValuegeneric_OpAnd32(v)
+		return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v)
 	case OpAnd64:
-		return rewriteValuegeneric_OpAnd64(v)
+		return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v)
 	case OpAnd8:
-		return rewriteValuegeneric_OpAnd8(v)
+		return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v)
 	case OpArg:
-		return rewriteValuegeneric_OpArg(v)
+		return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v)
 	case OpArraySelect:
-		return rewriteValuegeneric_OpArraySelect(v)
+		return rewriteValuegeneric_OpArraySelect_0(v)
 	case OpCom16:
-		return rewriteValuegeneric_OpCom16(v)
+		return rewriteValuegeneric_OpCom16_0(v)
 	case OpCom32:
-		return rewriteValuegeneric_OpCom32(v)
+		return rewriteValuegeneric_OpCom32_0(v)
 	case OpCom64:
-		return rewriteValuegeneric_OpCom64(v)
+		return rewriteValuegeneric_OpCom64_0(v)
 	case OpCom8:
-		return rewriteValuegeneric_OpCom8(v)
+		return rewriteValuegeneric_OpCom8_0(v)
 	case OpConstInterface:
-		return rewriteValuegeneric_OpConstInterface(v)
+		return rewriteValuegeneric_OpConstInterface_0(v)
 	case OpConstSlice:
-		return rewriteValuegeneric_OpConstSlice(v)
+		return rewriteValuegeneric_OpConstSlice_0(v)
 	case OpConstString:
-		return rewriteValuegeneric_OpConstString(v)
+		return rewriteValuegeneric_OpConstString_0(v)
 	case OpConvert:
-		return rewriteValuegeneric_OpConvert(v)
+		return rewriteValuegeneric_OpConvert_0(v)
 	case OpCvt32Fto64F:
-		return rewriteValuegeneric_OpCvt32Fto64F(v)
+		return rewriteValuegeneric_OpCvt32Fto64F_0(v)
 	case OpCvt64Fto32F:
-		return rewriteValuegeneric_OpCvt64Fto32F(v)
+		return rewriteValuegeneric_OpCvt64Fto32F_0(v)
 	case OpDiv16:
-		return rewriteValuegeneric_OpDiv16(v)
+		return rewriteValuegeneric_OpDiv16_0(v)
 	case OpDiv16u:
-		return rewriteValuegeneric_OpDiv16u(v)
+		return rewriteValuegeneric_OpDiv16u_0(v)
 	case OpDiv32:
-		return rewriteValuegeneric_OpDiv32(v)
+		return rewriteValuegeneric_OpDiv32_0(v)
 	case OpDiv32F:
-		return rewriteValuegeneric_OpDiv32F(v)
+		return rewriteValuegeneric_OpDiv32F_0(v)
 	case OpDiv32u:
-		return rewriteValuegeneric_OpDiv32u(v)
+		return rewriteValuegeneric_OpDiv32u_0(v)
 	case OpDiv64:
-		return rewriteValuegeneric_OpDiv64(v)
+		return rewriteValuegeneric_OpDiv64_0(v)
 	case OpDiv64F:
-		return rewriteValuegeneric_OpDiv64F(v)
+		return rewriteValuegeneric_OpDiv64F_0(v)
 	case OpDiv64u:
-		return rewriteValuegeneric_OpDiv64u(v)
+		return rewriteValuegeneric_OpDiv64u_0(v)
 	case OpDiv8:
-		return rewriteValuegeneric_OpDiv8(v)
+		return rewriteValuegeneric_OpDiv8_0(v)
 	case OpDiv8u:
-		return rewriteValuegeneric_OpDiv8u(v)
+		return rewriteValuegeneric_OpDiv8u_0(v)
 	case OpEq16:
-		return rewriteValuegeneric_OpEq16(v)
+		return rewriteValuegeneric_OpEq16_0(v)
 	case OpEq32:
-		return rewriteValuegeneric_OpEq32(v)
+		return rewriteValuegeneric_OpEq32_0(v)
 	case OpEq64:
-		return rewriteValuegeneric_OpEq64(v)
+		return rewriteValuegeneric_OpEq64_0(v)
 	case OpEq8:
-		return rewriteValuegeneric_OpEq8(v)
+		return rewriteValuegeneric_OpEq8_0(v)
 	case OpEqB:
-		return rewriteValuegeneric_OpEqB(v)
+		return rewriteValuegeneric_OpEqB_0(v)
 	case OpEqInter:
-		return rewriteValuegeneric_OpEqInter(v)
+		return rewriteValuegeneric_OpEqInter_0(v)
 	case OpEqPtr:
-		return rewriteValuegeneric_OpEqPtr(v)
+		return rewriteValuegeneric_OpEqPtr_0(v)
 	case OpEqSlice:
-		return rewriteValuegeneric_OpEqSlice(v)
+		return rewriteValuegeneric_OpEqSlice_0(v)
 	case OpGeq16:
-		return rewriteValuegeneric_OpGeq16(v)
+		return rewriteValuegeneric_OpGeq16_0(v)
 	case OpGeq16U:
-		return rewriteValuegeneric_OpGeq16U(v)
+		return rewriteValuegeneric_OpGeq16U_0(v)
 	case OpGeq32:
-		return rewriteValuegeneric_OpGeq32(v)
+		return rewriteValuegeneric_OpGeq32_0(v)
 	case OpGeq32U:
-		return rewriteValuegeneric_OpGeq32U(v)
+		return rewriteValuegeneric_OpGeq32U_0(v)
 	case OpGeq64:
-		return rewriteValuegeneric_OpGeq64(v)
+		return rewriteValuegeneric_OpGeq64_0(v)
 	case OpGeq64U:
-		return rewriteValuegeneric_OpGeq64U(v)
+		return rewriteValuegeneric_OpGeq64U_0(v)
 	case OpGeq8:
-		return rewriteValuegeneric_OpGeq8(v)
+		return rewriteValuegeneric_OpGeq8_0(v)
 	case OpGeq8U:
-		return rewriteValuegeneric_OpGeq8U(v)
+		return rewriteValuegeneric_OpGeq8U_0(v)
 	case OpGreater16:
-		return rewriteValuegeneric_OpGreater16(v)
+		return rewriteValuegeneric_OpGreater16_0(v)
 	case OpGreater16U:
-		return rewriteValuegeneric_OpGreater16U(v)
+		return rewriteValuegeneric_OpGreater16U_0(v)
 	case OpGreater32:
-		return rewriteValuegeneric_OpGreater32(v)
+		return rewriteValuegeneric_OpGreater32_0(v)
 	case OpGreater32U:
-		return rewriteValuegeneric_OpGreater32U(v)
+		return rewriteValuegeneric_OpGreater32U_0(v)
 	case OpGreater64:
-		return rewriteValuegeneric_OpGreater64(v)
+		return rewriteValuegeneric_OpGreater64_0(v)
 	case OpGreater64U:
-		return rewriteValuegeneric_OpGreater64U(v)
+		return rewriteValuegeneric_OpGreater64U_0(v)
 	case OpGreater8:
-		return rewriteValuegeneric_OpGreater8(v)
+		return rewriteValuegeneric_OpGreater8_0(v)
 	case OpGreater8U:
-		return rewriteValuegeneric_OpGreater8U(v)
+		return rewriteValuegeneric_OpGreater8U_0(v)
 	case OpIMake:
-		return rewriteValuegeneric_OpIMake(v)
+		return rewriteValuegeneric_OpIMake_0(v)
 	case OpInterCall:
-		return rewriteValuegeneric_OpInterCall(v)
+		return rewriteValuegeneric_OpInterCall_0(v)
 	case OpIsInBounds:
-		return rewriteValuegeneric_OpIsInBounds(v)
+		return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v)
 	case OpIsNonNil:
-		return rewriteValuegeneric_OpIsNonNil(v)
+		return rewriteValuegeneric_OpIsNonNil_0(v)
 	case OpIsSliceInBounds:
-		return rewriteValuegeneric_OpIsSliceInBounds(v)
+		return rewriteValuegeneric_OpIsSliceInBounds_0(v)
 	case OpLeq16:
-		return rewriteValuegeneric_OpLeq16(v)
+		return rewriteValuegeneric_OpLeq16_0(v)
 	case OpLeq16U:
-		return rewriteValuegeneric_OpLeq16U(v)
+		return rewriteValuegeneric_OpLeq16U_0(v)
 	case OpLeq32:
-		return rewriteValuegeneric_OpLeq32(v)
+		return rewriteValuegeneric_OpLeq32_0(v)
 	case OpLeq32U:
-		return rewriteValuegeneric_OpLeq32U(v)
+		return rewriteValuegeneric_OpLeq32U_0(v)
 	case OpLeq64:
-		return rewriteValuegeneric_OpLeq64(v)
+		return rewriteValuegeneric_OpLeq64_0(v)
 	case OpLeq64U:
-		return rewriteValuegeneric_OpLeq64U(v)
+		return rewriteValuegeneric_OpLeq64U_0(v)
 	case OpLeq8:
-		return rewriteValuegeneric_OpLeq8(v)
+		return rewriteValuegeneric_OpLeq8_0(v)
 	case OpLeq8U:
-		return rewriteValuegeneric_OpLeq8U(v)
+		return rewriteValuegeneric_OpLeq8U_0(v)
 	case OpLess16:
-		return rewriteValuegeneric_OpLess16(v)
+		return rewriteValuegeneric_OpLess16_0(v)
 	case OpLess16U:
-		return rewriteValuegeneric_OpLess16U(v)
+		return rewriteValuegeneric_OpLess16U_0(v)
 	case OpLess32:
-		return rewriteValuegeneric_OpLess32(v)
+		return rewriteValuegeneric_OpLess32_0(v)
 	case OpLess32U:
-		return rewriteValuegeneric_OpLess32U(v)
+		return rewriteValuegeneric_OpLess32U_0(v)
 	case OpLess64:
-		return rewriteValuegeneric_OpLess64(v)
+		return rewriteValuegeneric_OpLess64_0(v)
 	case OpLess64U:
-		return rewriteValuegeneric_OpLess64U(v)
+		return rewriteValuegeneric_OpLess64U_0(v)
 	case OpLess8:
-		return rewriteValuegeneric_OpLess8(v)
+		return rewriteValuegeneric_OpLess8_0(v)
 	case OpLess8U:
-		return rewriteValuegeneric_OpLess8U(v)
+		return rewriteValuegeneric_OpLess8U_0(v)
 	case OpLoad:
-		return rewriteValuegeneric_OpLoad(v)
+		return rewriteValuegeneric_OpLoad_0(v)
 	case OpLsh16x16:
-		return rewriteValuegeneric_OpLsh16x16(v)
+		return rewriteValuegeneric_OpLsh16x16_0(v)
 	case OpLsh16x32:
-		return rewriteValuegeneric_OpLsh16x32(v)
+		return rewriteValuegeneric_OpLsh16x32_0(v)
 	case OpLsh16x64:
-		return rewriteValuegeneric_OpLsh16x64(v)
+		return rewriteValuegeneric_OpLsh16x64_0(v)
 	case OpLsh16x8:
-		return rewriteValuegeneric_OpLsh16x8(v)
+		return rewriteValuegeneric_OpLsh16x8_0(v)
 	case OpLsh32x16:
-		return rewriteValuegeneric_OpLsh32x16(v)
+		return rewriteValuegeneric_OpLsh32x16_0(v)
 	case OpLsh32x32:
-		return rewriteValuegeneric_OpLsh32x32(v)
+		return rewriteValuegeneric_OpLsh32x32_0(v)
 	case OpLsh32x64:
-		return rewriteValuegeneric_OpLsh32x64(v)
+		return rewriteValuegeneric_OpLsh32x64_0(v)
 	case OpLsh32x8:
-		return rewriteValuegeneric_OpLsh32x8(v)
+		return rewriteValuegeneric_OpLsh32x8_0(v)
 	case OpLsh64x16:
-		return rewriteValuegeneric_OpLsh64x16(v)
+		return rewriteValuegeneric_OpLsh64x16_0(v)
 	case OpLsh64x32:
-		return rewriteValuegeneric_OpLsh64x32(v)
+		return rewriteValuegeneric_OpLsh64x32_0(v)
 	case OpLsh64x64:
-		return rewriteValuegeneric_OpLsh64x64(v)
+		return rewriteValuegeneric_OpLsh64x64_0(v)
 	case OpLsh64x8:
-		return rewriteValuegeneric_OpLsh64x8(v)
+		return rewriteValuegeneric_OpLsh64x8_0(v)
 	case OpLsh8x16:
-		return rewriteValuegeneric_OpLsh8x16(v)
+		return rewriteValuegeneric_OpLsh8x16_0(v)
 	case OpLsh8x32:
-		return rewriteValuegeneric_OpLsh8x32(v)
+		return rewriteValuegeneric_OpLsh8x32_0(v)
 	case OpLsh8x64:
-		return rewriteValuegeneric_OpLsh8x64(v)
+		return rewriteValuegeneric_OpLsh8x64_0(v)
 	case OpLsh8x8:
-		return rewriteValuegeneric_OpLsh8x8(v)
+		return rewriteValuegeneric_OpLsh8x8_0(v)
 	case OpMod16:
-		return rewriteValuegeneric_OpMod16(v)
+		return rewriteValuegeneric_OpMod16_0(v)
 	case OpMod16u:
-		return rewriteValuegeneric_OpMod16u(v)
+		return rewriteValuegeneric_OpMod16u_0(v)
 	case OpMod32:
-		return rewriteValuegeneric_OpMod32(v)
+		return rewriteValuegeneric_OpMod32_0(v)
 	case OpMod32u:
-		return rewriteValuegeneric_OpMod32u(v)
+		return rewriteValuegeneric_OpMod32u_0(v)
 	case OpMod64:
-		return rewriteValuegeneric_OpMod64(v)
+		return rewriteValuegeneric_OpMod64_0(v)
 	case OpMod64u:
-		return rewriteValuegeneric_OpMod64u(v)
+		return rewriteValuegeneric_OpMod64u_0(v)
 	case OpMod8:
-		return rewriteValuegeneric_OpMod8(v)
+		return rewriteValuegeneric_OpMod8_0(v)
 	case OpMod8u:
-		return rewriteValuegeneric_OpMod8u(v)
+		return rewriteValuegeneric_OpMod8u_0(v)
 	case OpMul16:
-		return rewriteValuegeneric_OpMul16(v)
+		return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v)
 	case OpMul32:
-		return rewriteValuegeneric_OpMul32(v)
+		return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v)
 	case OpMul32F:
-		return rewriteValuegeneric_OpMul32F(v)
+		return rewriteValuegeneric_OpMul32F_0(v)
 	case OpMul64:
-		return rewriteValuegeneric_OpMul64(v)
+		return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v)
 	case OpMul64F:
-		return rewriteValuegeneric_OpMul64F(v)
+		return rewriteValuegeneric_OpMul64F_0(v)
 	case OpMul8:
-		return rewriteValuegeneric_OpMul8(v)
+		return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v)
 	case OpNeg16:
-		return rewriteValuegeneric_OpNeg16(v)
+		return rewriteValuegeneric_OpNeg16_0(v)
 	case OpNeg32:
-		return rewriteValuegeneric_OpNeg32(v)
+		return rewriteValuegeneric_OpNeg32_0(v)
 	case OpNeg32F:
-		return rewriteValuegeneric_OpNeg32F(v)
+		return rewriteValuegeneric_OpNeg32F_0(v)
 	case OpNeg64:
-		return rewriteValuegeneric_OpNeg64(v)
+		return rewriteValuegeneric_OpNeg64_0(v)
 	case OpNeg64F:
-		return rewriteValuegeneric_OpNeg64F(v)
+		return rewriteValuegeneric_OpNeg64F_0(v)
 	case OpNeg8:
-		return rewriteValuegeneric_OpNeg8(v)
+		return rewriteValuegeneric_OpNeg8_0(v)
 	case OpNeq16:
-		return rewriteValuegeneric_OpNeq16(v)
+		return rewriteValuegeneric_OpNeq16_0(v)
 	case OpNeq32:
-		return rewriteValuegeneric_OpNeq32(v)
+		return rewriteValuegeneric_OpNeq32_0(v)
 	case OpNeq64:
-		return rewriteValuegeneric_OpNeq64(v)
+		return rewriteValuegeneric_OpNeq64_0(v)
 	case OpNeq8:
-		return rewriteValuegeneric_OpNeq8(v)
+		return rewriteValuegeneric_OpNeq8_0(v)
 	case OpNeqB:
-		return rewriteValuegeneric_OpNeqB(v)
+		return rewriteValuegeneric_OpNeqB_0(v)
 	case OpNeqInter:
-		return rewriteValuegeneric_OpNeqInter(v)
+		return rewriteValuegeneric_OpNeqInter_0(v)
 	case OpNeqPtr:
-		return rewriteValuegeneric_OpNeqPtr(v)
+		return rewriteValuegeneric_OpNeqPtr_0(v)
 	case OpNeqSlice:
-		return rewriteValuegeneric_OpNeqSlice(v)
+		return rewriteValuegeneric_OpNeqSlice_0(v)
 	case OpNilCheck:
-		return rewriteValuegeneric_OpNilCheck(v)
+		return rewriteValuegeneric_OpNilCheck_0(v)
 	case OpNot:
-		return rewriteValuegeneric_OpNot(v)
+		return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
 	case OpOffPtr:
-		return rewriteValuegeneric_OpOffPtr(v)
+		return rewriteValuegeneric_OpOffPtr_0(v)
 	case OpOr16:
-		return rewriteValuegeneric_OpOr16(v)
+		return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v)
 	case OpOr32:
-		return rewriteValuegeneric_OpOr32(v)
+		return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v)
 	case OpOr64:
-		return rewriteValuegeneric_OpOr64(v)
+		return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v)
 	case OpOr8:
-		return rewriteValuegeneric_OpOr8(v)
+		return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v)
 	case OpPhi:
-		return rewriteValuegeneric_OpPhi(v)
+		return rewriteValuegeneric_OpPhi_0(v)
 	case OpPtrIndex:
-		return rewriteValuegeneric_OpPtrIndex(v)
+		return rewriteValuegeneric_OpPtrIndex_0(v)
 	case OpRound32F:
-		return rewriteValuegeneric_OpRound32F(v)
+		return rewriteValuegeneric_OpRound32F_0(v)
 	case OpRound64F:
-		return rewriteValuegeneric_OpRound64F(v)
+		return rewriteValuegeneric_OpRound64F_0(v)
 	case OpRsh16Ux16:
-		return rewriteValuegeneric_OpRsh16Ux16(v)
+		return rewriteValuegeneric_OpRsh16Ux16_0(v)
 	case OpRsh16Ux32:
-		return rewriteValuegeneric_OpRsh16Ux32(v)
+		return rewriteValuegeneric_OpRsh16Ux32_0(v)
 	case OpRsh16Ux64:
-		return rewriteValuegeneric_OpRsh16Ux64(v)
+		return rewriteValuegeneric_OpRsh16Ux64_0(v)
 	case OpRsh16Ux8:
-		return rewriteValuegeneric_OpRsh16Ux8(v)
+		return rewriteValuegeneric_OpRsh16Ux8_0(v)
 	case OpRsh16x16:
-		return rewriteValuegeneric_OpRsh16x16(v)
+		return rewriteValuegeneric_OpRsh16x16_0(v)
 	case OpRsh16x32:
-		return rewriteValuegeneric_OpRsh16x32(v)
+		return rewriteValuegeneric_OpRsh16x32_0(v)
 	case OpRsh16x64:
-		return rewriteValuegeneric_OpRsh16x64(v)
+		return rewriteValuegeneric_OpRsh16x64_0(v)
 	case OpRsh16x8:
-		return rewriteValuegeneric_OpRsh16x8(v)
+		return rewriteValuegeneric_OpRsh16x8_0(v)
 	case OpRsh32Ux16:
-		return rewriteValuegeneric_OpRsh32Ux16(v)
+		return rewriteValuegeneric_OpRsh32Ux16_0(v)
 	case OpRsh32Ux32:
-		return rewriteValuegeneric_OpRsh32Ux32(v)
+		return rewriteValuegeneric_OpRsh32Ux32_0(v)
 	case OpRsh32Ux64:
-		return rewriteValuegeneric_OpRsh32Ux64(v)
+		return rewriteValuegeneric_OpRsh32Ux64_0(v)
 	case OpRsh32Ux8:
-		return rewriteValuegeneric_OpRsh32Ux8(v)
+		return rewriteValuegeneric_OpRsh32Ux8_0(v)
 	case OpRsh32x16:
-		return rewriteValuegeneric_OpRsh32x16(v)
+		return rewriteValuegeneric_OpRsh32x16_0(v)
 	case OpRsh32x32:
-		return rewriteValuegeneric_OpRsh32x32(v)
+		return rewriteValuegeneric_OpRsh32x32_0(v)
 	case OpRsh32x64:
-		return rewriteValuegeneric_OpRsh32x64(v)
+		return rewriteValuegeneric_OpRsh32x64_0(v)
 	case OpRsh32x8:
-		return rewriteValuegeneric_OpRsh32x8(v)
+		return rewriteValuegeneric_OpRsh32x8_0(v)
 	case OpRsh64Ux16:
-		return rewriteValuegeneric_OpRsh64Ux16(v)
+		return rewriteValuegeneric_OpRsh64Ux16_0(v)
 	case OpRsh64Ux32:
-		return rewriteValuegeneric_OpRsh64Ux32(v)
+		return rewriteValuegeneric_OpRsh64Ux32_0(v)
 	case OpRsh64Ux64:
-		return rewriteValuegeneric_OpRsh64Ux64(v)
+		return rewriteValuegeneric_OpRsh64Ux64_0(v)
 	case OpRsh64Ux8:
-		return rewriteValuegeneric_OpRsh64Ux8(v)
+		return rewriteValuegeneric_OpRsh64Ux8_0(v)
 	case OpRsh64x16:
-		return rewriteValuegeneric_OpRsh64x16(v)
+		return rewriteValuegeneric_OpRsh64x16_0(v)
 	case OpRsh64x32:
-		return rewriteValuegeneric_OpRsh64x32(v)
+		return rewriteValuegeneric_OpRsh64x32_0(v)
 	case OpRsh64x64:
-		return rewriteValuegeneric_OpRsh64x64(v)
+		return rewriteValuegeneric_OpRsh64x64_0(v)
 	case OpRsh64x8:
-		return rewriteValuegeneric_OpRsh64x8(v)
+		return rewriteValuegeneric_OpRsh64x8_0(v)
 	case OpRsh8Ux16:
-		return rewriteValuegeneric_OpRsh8Ux16(v)
+		return rewriteValuegeneric_OpRsh8Ux16_0(v)
 	case OpRsh8Ux32:
-		return rewriteValuegeneric_OpRsh8Ux32(v)
+		return rewriteValuegeneric_OpRsh8Ux32_0(v)
 	case OpRsh8Ux64:
-		return rewriteValuegeneric_OpRsh8Ux64(v)
+		return rewriteValuegeneric_OpRsh8Ux64_0(v)
 	case OpRsh8Ux8:
-		return rewriteValuegeneric_OpRsh8Ux8(v)
+		return rewriteValuegeneric_OpRsh8Ux8_0(v)
 	case OpRsh8x16:
-		return rewriteValuegeneric_OpRsh8x16(v)
+		return rewriteValuegeneric_OpRsh8x16_0(v)
 	case OpRsh8x32:
-		return rewriteValuegeneric_OpRsh8x32(v)
+		return rewriteValuegeneric_OpRsh8x32_0(v)
 	case OpRsh8x64:
-		return rewriteValuegeneric_OpRsh8x64(v)
+		return rewriteValuegeneric_OpRsh8x64_0(v)
 	case OpRsh8x8:
-		return rewriteValuegeneric_OpRsh8x8(v)
+		return rewriteValuegeneric_OpRsh8x8_0(v)
 	case OpSignExt16to32:
-		return rewriteValuegeneric_OpSignExt16to32(v)
+		return rewriteValuegeneric_OpSignExt16to32_0(v)
 	case OpSignExt16to64:
-		return rewriteValuegeneric_OpSignExt16to64(v)
+		return rewriteValuegeneric_OpSignExt16to64_0(v)
 	case OpSignExt32to64:
-		return rewriteValuegeneric_OpSignExt32to64(v)
+		return rewriteValuegeneric_OpSignExt32to64_0(v)
 	case OpSignExt8to16:
-		return rewriteValuegeneric_OpSignExt8to16(v)
+		return rewriteValuegeneric_OpSignExt8to16_0(v)
 	case OpSignExt8to32:
-		return rewriteValuegeneric_OpSignExt8to32(v)
+		return rewriteValuegeneric_OpSignExt8to32_0(v)
 	case OpSignExt8to64:
-		return rewriteValuegeneric_OpSignExt8to64(v)
+		return rewriteValuegeneric_OpSignExt8to64_0(v)
 	case OpSliceCap:
-		return rewriteValuegeneric_OpSliceCap(v)
+		return rewriteValuegeneric_OpSliceCap_0(v)
 	case OpSliceLen:
-		return rewriteValuegeneric_OpSliceLen(v)
+		return rewriteValuegeneric_OpSliceLen_0(v)
 	case OpSlicePtr:
-		return rewriteValuegeneric_OpSlicePtr(v)
+		return rewriteValuegeneric_OpSlicePtr_0(v)
 	case OpSlicemask:
-		return rewriteValuegeneric_OpSlicemask(v)
+		return rewriteValuegeneric_OpSlicemask_0(v)
 	case OpSqrt:
-		return rewriteValuegeneric_OpSqrt(v)
+		return rewriteValuegeneric_OpSqrt_0(v)
 	case OpStore:
-		return rewriteValuegeneric_OpStore(v)
+		return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v)
 	case OpStringLen:
-		return rewriteValuegeneric_OpStringLen(v)
+		return rewriteValuegeneric_OpStringLen_0(v)
 	case OpStringPtr:
-		return rewriteValuegeneric_OpStringPtr(v)
+		return rewriteValuegeneric_OpStringPtr_0(v)
 	case OpStructSelect:
-		return rewriteValuegeneric_OpStructSelect(v)
+		return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
 	case OpSub16:
-		return rewriteValuegeneric_OpSub16(v)
+		return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v)
 	case OpSub32:
-		return rewriteValuegeneric_OpSub32(v)
+		return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v)
 	case OpSub32F:
-		return rewriteValuegeneric_OpSub32F(v)
+		return rewriteValuegeneric_OpSub32F_0(v)
 	case OpSub64:
-		return rewriteValuegeneric_OpSub64(v)
+		return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v)
 	case OpSub64F:
-		return rewriteValuegeneric_OpSub64F(v)
+		return rewriteValuegeneric_OpSub64F_0(v)
 	case OpSub8:
-		return rewriteValuegeneric_OpSub8(v)
+		return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v)
 	case OpTrunc16to8:
-		return rewriteValuegeneric_OpTrunc16to8(v)
+		return rewriteValuegeneric_OpTrunc16to8_0(v)
 	case OpTrunc32to16:
-		return rewriteValuegeneric_OpTrunc32to16(v)
+		return rewriteValuegeneric_OpTrunc32to16_0(v)
 	case OpTrunc32to8:
-		return rewriteValuegeneric_OpTrunc32to8(v)
+		return rewriteValuegeneric_OpTrunc32to8_0(v)
 	case OpTrunc64to16:
-		return rewriteValuegeneric_OpTrunc64to16(v)
+		return rewriteValuegeneric_OpTrunc64to16_0(v)
 	case OpTrunc64to32:
-		return rewriteValuegeneric_OpTrunc64to32(v)
+		return rewriteValuegeneric_OpTrunc64to32_0(v)
 	case OpTrunc64to8:
-		return rewriteValuegeneric_OpTrunc64to8(v)
+		return rewriteValuegeneric_OpTrunc64to8_0(v)
 	case OpXor16:
-		return rewriteValuegeneric_OpXor16(v)
+		return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v)
 	case OpXor32:
-		return rewriteValuegeneric_OpXor32(v)
+		return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v)
 	case OpXor64:
-		return rewriteValuegeneric_OpXor64(v)
+		return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v)
 	case OpXor8:
-		return rewriteValuegeneric_OpXor8(v)
+		return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v)
 	case OpZero:
-		return rewriteValuegeneric_OpZero(v)
+		return rewriteValuegeneric_OpZero_0(v)
 	case OpZeroExt16to32:
-		return rewriteValuegeneric_OpZeroExt16to32(v)
+		return rewriteValuegeneric_OpZeroExt16to32_0(v)
 	case OpZeroExt16to64:
-		return rewriteValuegeneric_OpZeroExt16to64(v)
+		return rewriteValuegeneric_OpZeroExt16to64_0(v)
 	case OpZeroExt32to64:
-		return rewriteValuegeneric_OpZeroExt32to64(v)
+		return rewriteValuegeneric_OpZeroExt32to64_0(v)
 	case OpZeroExt8to16:
-		return rewriteValuegeneric_OpZeroExt8to16(v)
+		return rewriteValuegeneric_OpZeroExt8to16_0(v)
 	case OpZeroExt8to32:
-		return rewriteValuegeneric_OpZeroExt8to32(v)
+		return rewriteValuegeneric_OpZeroExt8to32_0(v)
 	case OpZeroExt8to64:
-		return rewriteValuegeneric_OpZeroExt8to64(v)
+		return rewriteValuegeneric_OpZeroExt8to64_0(v)
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd16(v *Value) bool {
+func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Add16 (Const16 [c]) (Const16 [d]))
@@ -641,6 +641,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
 	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 	// result: (Add16 i (Sub16 <t> x z))
@@ -909,6 +914,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd16_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 	// cond:
 	// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
@@ -1091,7 +1101,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd32(v *Value) bool {
+func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Add32 (Const32 [c]) (Const32 [d]))
@@ -1308,6 +1318,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
 	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 	// result: (Add32 i (Sub32 <t> x z))
@@ -1576,6 +1591,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd32_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 	// cond:
 	// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
@@ -1758,7 +1778,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd32F(v *Value) bool {
+func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
 	// match: (Add32F (Const32F [c]) (Const32F [d]))
 	// cond:
 	// result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))])
@@ -1831,7 +1851,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd64(v *Value) bool {
+func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Add64 (Const64 [c]) (Const64 [d]))
@@ -2048,6 +2068,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
 	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 	// result: (Add64 i (Sub64 <t> x z))
@@ -2316,6 +2341,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd64_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 	// cond:
 	// result: (Add64 (Const64 <t> [c+d]) x)
@@ -2498,7 +2528,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd64F(v *Value) bool {
+func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
 	// match: (Add64F (Const64F [c]) (Const64F [d]))
 	// cond:
 	// result: (Const64F [f2i(i2f(c) + i2f(d))])
@@ -2571,7 +2601,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAdd8(v *Value) bool {
+func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Add8 (Const8 [c]) (Const8 [d]))
@@ -2788,6 +2818,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
 	// cond: (z.Op != OpConst8  && x.Op != OpConst8)
 	// result: (Add8  i (Sub8  <t> x z))
@@ -3056,6 +3091,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAdd8_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 	// cond:
 	// result: (Add8  (Const8  <t> [int64(int8(c+d))]) x)
@@ -3238,7 +3278,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAddPtr(v *Value) bool {
+func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
 	// match: (AddPtr <t> x (Const64 [c]))
 	// cond:
 	// result: (OffPtr <t> x [c])
@@ -3275,9 +3315,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAnd16(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
 	// match: (And16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (Const16 [int64(int16(c&d))])
@@ -3445,6 +3483,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAnd16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (And16 (And16 y x) x)
 	// cond:
 	// result: (And16 x y)
@@ -3689,9 +3732,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAnd32(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
 	// match: (And32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (Const32 [int64(int32(c&d))])
@@ -3859,6 +3900,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAnd32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (And32 (And32 y x) x)
 	// cond:
 	// result: (And32 x y)
@@ -4103,9 +4149,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAnd64(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
 	// match: (And64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (Const64 [c&d])
@@ -4273,6 +4317,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAnd64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (And64 (And64 y x) x)
 	// cond:
 	// result: (And64 x y)
@@ -4529,6 +4578,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAnd64_20(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d])))
 	// cond:
 	// result: (And64 (Const64 <t> [c&d]) x)
@@ -4621,9 +4675,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpAnd8(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
 	// match: (And8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (Const8  [int64(int8(c&d))])
@@ -4791,6 +4843,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpAnd8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (And8 (And8 y x) x)
 	// cond:
 	// result: (And8  x y)
@@ -5035,7 +5092,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpArg(v *Value) bool {
+func rewriteValuegeneric_OpArg_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5251,6 +5308,13 @@
 		v.AddArg(v3)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpArg_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	fe := b.Func.fe
+	_ = fe
 	// match: (Arg <t>)
 	// cond: t.IsArray() && t.NumElem() == 0
 	// result: (ArrayMake0)
@@ -5281,7 +5345,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpArraySelect(v *Value) bool {
+func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
 	// match: (ArraySelect (ArrayMake1 x))
 	// cond:
 	// result: x
@@ -5332,7 +5396,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCom16(v *Value) bool {
+func rewriteValuegeneric_OpCom16_0(v *Value) bool {
 	// match: (Com16 (Com16 x))
 	// cond:
 	// result: x
@@ -5349,7 +5413,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCom32(v *Value) bool {
+func rewriteValuegeneric_OpCom32_0(v *Value) bool {
 	// match: (Com32 (Com32 x))
 	// cond:
 	// result: x
@@ -5366,7 +5430,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCom64(v *Value) bool {
+func rewriteValuegeneric_OpCom64_0(v *Value) bool {
 	// match: (Com64 (Com64 x))
 	// cond:
 	// result: x
@@ -5383,7 +5447,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCom8(v *Value) bool {
+func rewriteValuegeneric_OpCom8_0(v *Value) bool {
 	// match: (Com8 (Com8 x))
 	// cond:
 	// result: x
@@ -5400,7 +5464,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpConstInterface(v *Value) bool {
+func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5417,7 +5481,7 @@
 		return true
 	}
 }
-func rewriteValuegeneric_OpConstSlice(v *Value) bool {
+func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5462,7 +5526,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpConstString(v *Value) bool {
+func rewriteValuegeneric_OpConstString_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5543,7 +5607,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpConvert(v *Value) bool {
+func rewriteValuegeneric_OpConvert_0(v *Value) bool {
 	// match: (Convert (Add64 (Convert ptr mem) off) mem)
 	// cond:
 	// result: (Add64 ptr off)
@@ -5610,7 +5674,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
+func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
 	// match: (Cvt32Fto64F (Const32F [c]))
 	// cond:
 	// result: (Const64F [c])
@@ -5626,7 +5690,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
+func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
 	// match: (Cvt64Fto32F (Const64F [c]))
 	// cond:
 	// result: (Const32F [f2i(float64(i2f32(c)))])
@@ -5642,7 +5706,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv16(v *Value) bool {
+func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -5791,7 +5855,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv16u(v *Value) bool {
+func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -5972,7 +6036,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv32(v *Value) bool {
+func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6196,7 +6260,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv32F(v *Value) bool {
+func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Div32F (Const32F [c]) (Const32F [d]))
@@ -6240,7 +6304,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv32u(v *Value) bool {
+func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6478,7 +6542,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv64(v *Value) bool {
+func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6661,7 +6725,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv64F(v *Value) bool {
+func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Div64F (Const64F [c]) (Const64F [d]))
@@ -6705,7 +6769,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv64u(v *Value) bool {
+func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -6841,7 +6905,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv8(v *Value) bool {
+func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -6990,7 +7054,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpDiv8u(v *Value) bool {
+func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7067,7 +7131,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEq16(v *Value) bool {
+func rewriteValuegeneric_OpEq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq16 x x)
@@ -7240,7 +7304,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEq32(v *Value) bool {
+func rewriteValuegeneric_OpEq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq32 x x)
@@ -7413,7 +7477,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEq64(v *Value) bool {
+func rewriteValuegeneric_OpEq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq64 x x)
@@ -7586,7 +7650,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEq8(v *Value) bool {
+func rewriteValuegeneric_OpEq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Eq8 x x)
@@ -7759,7 +7823,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEqB(v *Value) bool {
+func rewriteValuegeneric_OpEqB_0(v *Value) bool {
 	// match: (EqB (ConstBool [c]) (ConstBool [d]))
 	// cond:
 	// result: (ConstBool [b2i(c == d)])
@@ -7813,7 +7877,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEqInter(v *Value) bool {
+func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7834,7 +7898,7 @@
 		return true
 	}
 }
-func rewriteValuegeneric_OpEqPtr(v *Value) bool {
+func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7927,7 +7991,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpEqSlice(v *Value) bool {
+func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -7948,7 +8012,7 @@
 		return true
 	}
 }
-func rewriteValuegeneric_OpGeq16(v *Value) bool {
+func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
 	// match: (Geq16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c >= d)])
@@ -7969,7 +8033,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq16U(v *Value) bool {
+func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
 	// match: (Geq16U (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
@@ -7990,7 +8054,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq32(v *Value) bool {
+func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
 	// match: (Geq32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c >= d)])
@@ -8011,7 +8075,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq32U(v *Value) bool {
+func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
 	// match: (Geq32U (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
@@ -8032,7 +8096,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq64(v *Value) bool {
+func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
 	// match: (Geq64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c >= d)])
@@ -8053,7 +8117,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq64U(v *Value) bool {
+func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
 	// match: (Geq64U (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
@@ -8074,7 +8138,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq8(v *Value) bool {
+func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
 	// match: (Geq8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c >= d)])
@@ -8095,7 +8159,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGeq8U(v *Value) bool {
+func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
 	// match: (Geq8U (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint8(c)  >= uint8(d))])
@@ -8116,7 +8180,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater16(v *Value) bool {
+func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
 	// match: (Greater16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c > d)])
@@ -8137,7 +8201,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater16U(v *Value) bool {
+func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
 	// match: (Greater16U (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint16(c) > uint16(d))])
@@ -8158,7 +8222,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater32(v *Value) bool {
+func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
 	// match: (Greater32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c > d)])
@@ -8179,7 +8243,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater32U(v *Value) bool {
+func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
 	// match: (Greater32U (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint32(c) > uint32(d))])
@@ -8200,7 +8264,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater64(v *Value) bool {
+func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
 	// match: (Greater64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c > d)])
@@ -8221,7 +8285,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater64U(v *Value) bool {
+func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
 	// match: (Greater64U (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint64(c) > uint64(d))])
@@ -8242,7 +8306,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater8(v *Value) bool {
+func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
 	// match: (Greater8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c > d)])
@@ -8263,7 +8327,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpGreater8U(v *Value) bool {
+func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
 	// match: (Greater8U (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint8(c)  > uint8(d))])
@@ -8284,7 +8348,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpIMake(v *Value) bool {
+func rewriteValuegeneric_OpIMake_0(v *Value) bool {
 	// match: (IMake typ (StructMake1 val))
 	// cond:
 	// result: (IMake typ val)
@@ -8317,7 +8381,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpInterCall(v *Value) bool {
+func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
 	// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
 	// cond: devirt(v, itab, off) != nil
 	// result: (StaticCall [argsize] {devirt(v, itab, off)} mem)
@@ -8361,7 +8425,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
+func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
 	// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
 	// cond: (1 << 8)  <= c
 	// result: (ConstBool [1])
@@ -8591,6 +8655,9 @@
 		v.AuxInt = 1
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
 	// match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d]))
 	// cond: 0 <= c && c < d
 	// result: (ConstBool [1])
@@ -8869,6 +8936,9 @@
 		v.AuxInt = 1
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
 	// match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d]))
 	// cond: 0 <= c && c < d
 	// result: (ConstBool [1])
@@ -9072,7 +9142,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpIsNonNil(v *Value) bool {
+func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
 	// match: (IsNonNil (ConstNil))
 	// cond:
 	// result: (ConstBool [0])
@@ -9087,7 +9157,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
+func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
 	// match: (IsSliceInBounds x x)
 	// cond:
 	// result: (ConstBool [1])
@@ -9288,7 +9358,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq16(v *Value) bool {
+func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
 	// match: (Leq16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c <= d)])
@@ -9309,7 +9379,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq16U(v *Value) bool {
+func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
 	// match: (Leq16U (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
@@ -9330,7 +9400,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq32(v *Value) bool {
+func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
 	// match: (Leq32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c <= d)])
@@ -9351,7 +9421,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq32U(v *Value) bool {
+func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
 	// match: (Leq32U (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
@@ -9372,7 +9442,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq64(v *Value) bool {
+func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
 	// match: (Leq64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c <= d)])
@@ -9393,7 +9463,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq64U(v *Value) bool {
+func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
 	// match: (Leq64U (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
@@ -9414,7 +9484,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq8(v *Value) bool {
+func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
 	// match: (Leq8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c <= d)])
@@ -9435,7 +9505,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLeq8U(v *Value) bool {
+func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
 	// match: (Leq8U (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint8(c)  <= uint8(d))])
@@ -9456,7 +9526,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess16(v *Value) bool {
+func rewriteValuegeneric_OpLess16_0(v *Value) bool {
 	// match: (Less16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c < d)])
@@ -9477,7 +9547,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess16U(v *Value) bool {
+func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
 	// match: (Less16U (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint16(c) < uint16(d))])
@@ -9498,7 +9568,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess32(v *Value) bool {
+func rewriteValuegeneric_OpLess32_0(v *Value) bool {
 	// match: (Less32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c < d)])
@@ -9519,7 +9589,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess32U(v *Value) bool {
+func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
 	// match: (Less32U (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint32(c) < uint32(d))])
@@ -9540,7 +9610,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess64(v *Value) bool {
+func rewriteValuegeneric_OpLess64_0(v *Value) bool {
 	// match: (Less64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c < d)])
@@ -9561,7 +9631,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess64U(v *Value) bool {
+func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
 	// match: (Less64U (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint64(c) < uint64(d))])
@@ -9582,7 +9652,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess8(v *Value) bool {
+func rewriteValuegeneric_OpLess8_0(v *Value) bool {
 	// match: (Less8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(c < d)])
@@ -9603,7 +9673,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLess8U(v *Value) bool {
+func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
 	// match: (Less8U (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (ConstBool [b2i(uint8(c)  < uint8(d))])
@@ -9624,7 +9694,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLoad(v *Value) bool {
+func rewriteValuegeneric_OpLoad_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	fe := b.Func.fe
@@ -9813,7 +9883,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh16x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x16 <t> x (Const16 [c]))
@@ -9851,7 +9921,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh16x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x32 <t> x (Const32 [c]))
@@ -9889,7 +9959,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10030,7 +10100,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh16x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh16x8 <t> x (Const8 [c]))
@@ -10068,7 +10138,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh32x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x16 <t> x (Const16 [c]))
@@ -10106,7 +10176,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh32x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x32 <t> x (Const32 [c]))
@@ -10144,7 +10214,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10285,7 +10355,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh32x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh32x8 <t> x (Const8 [c]))
@@ -10323,7 +10393,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh64x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x16 <t> x (Const16 [c]))
@@ -10361,7 +10431,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh64x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x32 <t> x (Const32 [c]))
@@ -10399,7 +10469,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10540,7 +10610,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh64x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh64x8 <t> x (Const8 [c]))
@@ -10578,7 +10648,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh8x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x16 <t> x (Const16 [c]))
@@ -10616,7 +10686,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh8x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x32 <t> x (Const32 [c]))
@@ -10654,7 +10724,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -10795,7 +10865,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpLsh8x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Lsh8x8 <t> x (Const8 [c]))
@@ -10833,7 +10903,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod16(v *Value) bool {
+func rewriteValuegeneric_OpMod16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod16 (Const16 [c]) (Const16 [d]))
@@ -10910,7 +10980,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod16u(v *Value) bool {
+func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod16u (Const16 [c]) (Const16 [d]))
@@ -10986,7 +11056,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod32(v *Value) bool {
+func rewriteValuegeneric_OpMod32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod32 (Const32 [c]) (Const32 [d]))
@@ -11063,7 +11133,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod32u(v *Value) bool {
+func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod32u (Const32 [c]) (Const32 [d]))
@@ -11139,7 +11209,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod64(v *Value) bool {
+func rewriteValuegeneric_OpMod64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod64 (Const64 [c]) (Const64 [d]))
@@ -11216,7 +11286,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod64u(v *Value) bool {
+func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod64u (Const64 [c]) (Const64 [d]))
@@ -11292,7 +11362,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod8(v *Value) bool {
+func rewriteValuegeneric_OpMod8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod8 (Const8 [c]) (Const8 [d]))
@@ -11369,7 +11439,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMod8u(v *Value) bool {
+func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Mod8u (Const8 [c]) (Const8 [d]))
@@ -11445,7 +11515,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul16(v *Value) bool {
+func rewriteValuegeneric_OpMul16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11642,6 +11712,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpMul16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Mul16 (Const16 [0]) _)
 	// cond:
 	// result: (Const16 [0])
@@ -11794,7 +11869,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul32(v *Value) bool {
+func rewriteValuegeneric_OpMul32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -11991,6 +12066,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpMul32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
 	// cond:
 	// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
@@ -12295,7 +12375,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul32F(v *Value) bool {
+func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
 	// match: (Mul32F (Const32F [c]) (Const32F [d]))
 	// cond:
 	// result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))])
@@ -12434,7 +12514,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul64(v *Value) bool {
+func rewriteValuegeneric_OpMul64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -12631,6 +12711,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpMul64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
 	// cond:
 	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
@@ -12935,7 +13020,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul64F(v *Value) bool {
+func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
 	// match: (Mul64F (Const64F [c]) (Const64F [d]))
 	// cond:
 	// result: (Const64F [f2i(i2f(c) * i2f(d))])
@@ -13074,7 +13159,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpMul8(v *Value) bool {
+func rewriteValuegeneric_OpMul8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -13271,6 +13356,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpMul8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Mul8 (Const8 [0]) _)
 	// cond:
 	// result: (Const8  [0])
@@ -13423,7 +13513,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg16(v *Value) bool {
+func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
 	// match: (Neg16 (Const16 [c]))
 	// cond:
 	// result: (Const16  [int64(-int16(c))])
@@ -13454,7 +13544,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg32(v *Value) bool {
+func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
 	// match: (Neg32 (Const32 [c]))
 	// cond:
 	// result: (Const32  [int64(-int32(c))])
@@ -13485,7 +13575,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg32F(v *Value) bool {
+func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
 	// match: (Neg32F (Const32F [c]))
 	// cond: i2f(c) != 0
 	// result: (Const32F [f2i(-i2f(c))])
@@ -13504,7 +13594,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg64(v *Value) bool {
+func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
 	// match: (Neg64 (Const64 [c]))
 	// cond:
 	// result: (Const64  [-c])
@@ -13535,7 +13625,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg64F(v *Value) bool {
+func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
 	// match: (Neg64F (Const64F [c]))
 	// cond: i2f(c) != 0
 	// result: (Const64F [f2i(-i2f(c))])
@@ -13554,7 +13644,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeg8(v *Value) bool {
+func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
 	// match: (Neg8 (Const8 [c]))
 	// cond:
 	// result: (Const8   [int64( -int8(c))])
@@ -13585,7 +13675,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeq16(v *Value) bool {
+func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq16 x x)
@@ -13758,7 +13848,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeq32(v *Value) bool {
+func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq32 x x)
@@ -13931,7 +14021,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeq64(v *Value) bool {
+func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq64 x x)
@@ -14104,7 +14194,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeq8(v *Value) bool {
+func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Neq8 x x)
@@ -14277,7 +14367,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeqB(v *Value) bool {
+func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
 	// match: (NeqB (ConstBool [c]) (ConstBool [d]))
 	// cond:
 	// result: (ConstBool [b2i(c != d)])
@@ -14331,7 +14421,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeqInter(v *Value) bool {
+func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14352,7 +14442,7 @@
 		return true
 	}
 }
-func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
+func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
 	// match: (NeqPtr p (ConstNil))
 	// cond:
 	// result: (IsNonNil p)
@@ -14381,7 +14471,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
+func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -14402,7 +14492,7 @@
 		return true
 	}
 }
-func rewriteValuegeneric_OpNilCheck(v *Value) bool {
+func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -14486,7 +14576,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpNot(v *Value) bool {
+func rewriteValuegeneric_OpNot_0(v *Value) bool {
 	// match: (Not (Eq64 x y))
 	// cond:
 	// result: (Neq64 x y)
@@ -14637,6 +14727,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpNot_10(v *Value) bool {
 	// match: (Not (Greater64 x y))
 	// cond:
 	// result: (Leq64 x y)
@@ -14787,6 +14880,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpNot_20(v *Value) bool {
 	// match: (Not (Geq16 x y))
 	// cond:
 	// result: (Less16 x y)
@@ -14937,6 +15033,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpNot_30(v *Value) bool {
 	// match: (Not (Less64U x y))
 	// cond:
 	// result: (Geq64U x y)
@@ -15087,6 +15186,9 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpNot_40(v *Value) bool {
 	// match: (Not (Leq16U x y))
 	// cond:
 	// result: (Greater16U x y)
@@ -15119,7 +15221,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpOffPtr(v *Value) bool {
+func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
 	// match: (OffPtr (OffPtr p [b]) [a])
 	// cond:
 	// result: (OffPtr p [a+b])
@@ -15154,9 +15256,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpOr16(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpOr16_0(v *Value) bool {
 	// match: (Or16 (Const16 [c]) (Const16 [d]))
 	// cond:
 	// result: (Const16 [int64(int16(c|d))])
@@ -15324,6 +15424,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpOr16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Or16 (Or16 y x) x)
 	// cond:
 	// result: (Or16 x y)
@@ -15568,9 +15673,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpOr32(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpOr32_0(v *Value) bool {
 	// match: (Or32 (Const32 [c]) (Const32 [d]))
 	// cond:
 	// result: (Const32 [int64(int32(c|d))])
@@ -15738,6 +15841,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpOr32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Or32 (Or32 y x) x)
 	// cond:
 	// result: (Or32 x y)
@@ -15982,9 +16090,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpOr64(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpOr64_0(v *Value) bool {
 	// match: (Or64 (Const64 [c]) (Const64 [d]))
 	// cond:
 	// result: (Const64 [c|d])
@@ -16152,6 +16258,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpOr64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Or64 (Or64 y x) x)
 	// cond:
 	// result: (Or64 x y)
@@ -16396,9 +16507,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpOr8(v *Value) bool {
-	b := v.Block
-	_ = b
+func rewriteValuegeneric_OpOr8_0(v *Value) bool {
 	// match: (Or8 (Const8 [c]) (Const8 [d]))
 	// cond:
 	// result: (Const8  [int64(int8(c|d))])
@@ -16566,6 +16675,11 @@
 		v.AddArg(y)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpOr8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Or8 (Or8 y x) x)
 	// cond:
 	// result: (Or8  x y)
@@ -16810,7 +16924,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpPhi(v *Value) bool {
+func rewriteValuegeneric_OpPhi_0(v *Value) bool {
 	// match: (Phi (Const8 [c]) (Const8 [c]))
 	// cond:
 	// result: (Const8  [c])
@@ -16905,7 +17019,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpPtrIndex(v *Value) bool {
+func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -16954,7 +17068,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRound32F(v *Value) bool {
+func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
 	// match: (Round32F x:(Const32F))
 	// cond:
 	// result: x
@@ -16970,7 +17084,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRound64F(v *Value) bool {
+func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
 	// match: (Round64F x:(Const64F))
 	// cond:
 	// result: x
@@ -16986,7 +17100,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux16 <t> x (Const16 [c]))
@@ -17024,7 +17138,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux32 <t> x (Const32 [c]))
@@ -17062,7 +17176,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -17232,7 +17346,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16Ux8 <t> x (Const8 [c]))
@@ -17270,7 +17384,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x16 <t> x (Const16 [c]))
@@ -17308,7 +17422,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x32 <t> x (Const32 [c]))
@@ -17346,7 +17460,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -17462,7 +17576,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh16x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh16x8 <t> x (Const8 [c]))
@@ -17500,7 +17614,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux16 <t> x (Const16 [c]))
@@ -17538,7 +17652,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux32 <t> x (Const32 [c]))
@@ -17576,7 +17690,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -17775,7 +17889,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32Ux8 <t> x (Const8 [c]))
@@ -17813,7 +17927,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x16 <t> x (Const16 [c]))
@@ -17851,7 +17965,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x32 <t> x (Const32 [c]))
@@ -17889,7 +18003,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -18034,7 +18148,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh32x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh32x8 <t> x (Const8 [c]))
@@ -18072,7 +18186,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux16 <t> x (Const16 [c]))
@@ -18110,7 +18224,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux32 <t> x (Const32 [c]))
@@ -18148,7 +18262,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -18376,7 +18490,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64Ux8 <t> x (Const8 [c]))
@@ -18414,7 +18528,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x16 <t> x (Const16 [c]))
@@ -18452,7 +18566,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x32 <t> x (Const32 [c]))
@@ -18490,7 +18604,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -18664,7 +18778,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh64x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh64x8 <t> x (Const8 [c]))
@@ -18702,7 +18816,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux16 <t> x (Const16 [c]))
@@ -18740,7 +18854,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux32 <t> x (Const32 [c]))
@@ -18778,7 +18892,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	types := &b.Func.Config.Types
@@ -18919,7 +19033,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8Ux8 <t> x (Const8 [c]))
@@ -18957,7 +19071,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x16 <t> x (Const16 [c]))
@@ -18995,7 +19109,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x32 <t> x (Const32 [c]))
@@ -19033,7 +19147,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
@@ -19118,7 +19232,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpRsh8x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Rsh8x8 <t> x (Const8 [c]))
@@ -19156,7 +19270,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
 	// match: (SignExt16to32 (Const16 [c]))
 	// cond:
 	// result: (Const32 [int64( int16(c))])
@@ -19197,7 +19311,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
 	// match: (SignExt16to64 (Const16 [c]))
 	// cond:
 	// result: (Const64 [int64( int16(c))])
@@ -19238,7 +19352,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
 	// match: (SignExt32to64 (Const32 [c]))
 	// cond:
 	// result: (Const64 [int64( int32(c))])
@@ -19279,7 +19393,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
 	// match: (SignExt8to16 (Const8 [c]))
 	// cond:
 	// result: (Const16 [int64(  int8(c))])
@@ -19320,7 +19434,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
 	// match: (SignExt8to32 (Const8 [c]))
 	// cond:
 	// result: (Const32 [int64(  int8(c))])
@@ -19361,7 +19475,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
 	// match: (SignExt8to64 (Const8 [c]))
 	// cond:
 	// result: (Const64 [int64(  int8(c))])
@@ -19402,7 +19516,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSliceCap(v *Value) bool {
+func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
 	// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
 	// cond:
 	// result: (Const64 <t> [c])
@@ -19477,7 +19591,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSliceLen(v *Value) bool {
+func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
 	// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
 	// cond:
 	// result: (Const64 <t> [c])
@@ -19535,7 +19649,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSlicePtr(v *Value) bool {
+func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
 	// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
 	// cond:
 	// result: (SlicePtr x)
@@ -19555,7 +19669,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSlicemask(v *Value) bool {
+func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
 	// match: (Slicemask (Const32 [x]))
 	// cond: x > 0
 	// result: (Const32 [-1])
@@ -19620,7 +19734,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSqrt(v *Value) bool {
+func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
 	// match: (Sqrt (Const64F [c]))
 	// cond:
 	// result: (Const64F [f2i(math.Sqrt(i2f(c)))])
@@ -19636,7 +19750,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpStore(v *Value) bool {
+func rewriteValuegeneric_OpStore_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -19921,6 +20035,13 @@
 		v.AddArg(mem)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpStore_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	config := b.Func.Config
+	_ = config
 	// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
 	// cond: isConstZero(x) 	&& mem.Op == OpStaticCall 	&& isSameSym(mem.Aux, "runtime.newobject") 	&& c == config.ctxt.FixedFrameSize() + config.RegSize
 	// result: mem
@@ -19957,7 +20078,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpStringLen(v *Value) bool {
+func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
 	// match: (StringLen (StringMake _ (Const64 <t> [c])))
 	// cond:
 	// result: (Const64 <t> [c])
@@ -19979,7 +20100,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpStringPtr(v *Value) bool {
+func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
 	// match: (StringPtr (StringMake (Const64 <t> [c]) _))
 	// cond:
 	// result: (Const64 <t> [c])
@@ -20001,11 +20122,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpStructSelect(v *Value) bool {
-	b := v.Block
-	_ = b
-	fe := b.Func.fe
-	_ = fe
+func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
 	// match: (StructSelect (StructMake1 x))
 	// cond:
 	// result: x
@@ -20173,6 +20290,13 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
+	b := v.Block
+	_ = b
+	fe := b.Func.fe
+	_ = fe
 	// match: (StructSelect [i] x:(Load <t> ptr mem))
 	// cond: !fe.CanSSA(t)
 	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
@@ -20217,7 +20341,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub16(v *Value) bool {
+func rewriteValuegeneric_OpSub16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Sub16 (Const16 [c]) (Const16 [d]))
@@ -20425,6 +20549,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpSub16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
 	// cond:
 	// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
@@ -20457,7 +20586,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub32(v *Value) bool {
+func rewriteValuegeneric_OpSub32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Sub32 (Const32 [c]) (Const32 [d]))
@@ -20665,6 +20794,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpSub32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
 	// cond:
 	// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
@@ -20697,7 +20831,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub32F(v *Value) bool {
+func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
 	// match: (Sub32F (Const32F [c]) (Const32F [d]))
 	// cond:
 	// result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))])
@@ -20735,7 +20869,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub64(v *Value) bool {
+func rewriteValuegeneric_OpSub64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Sub64 (Const64 [c]) (Const64 [d]))
@@ -20943,6 +21077,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpSub64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
 	// cond:
 	// result: (Add64 (Const64 <t> [c-d]) x)
@@ -20975,7 +21114,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub64F(v *Value) bool {
+func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
 	// match: (Sub64F (Const64F [c]) (Const64F [d]))
 	// cond:
 	// result: (Const64F [f2i(i2f(c) - i2f(d))])
@@ -21013,7 +21152,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpSub8(v *Value) bool {
+func rewriteValuegeneric_OpSub8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Sub8 (Const8 [c]) (Const8 [d]))
@@ -21221,6 +21360,11 @@
 		v.AddArg(x)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpSub8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
 	// cond:
 	// result: (Add8  (Const8  <t> [int64(int8(c-d))]) x)
@@ -21253,7 +21397,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
 	// match: (Trunc16to8 (Const16 [c]))
 	// cond:
 	// result: (Const8   [int64(int8(c))])
@@ -21339,7 +21483,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
 	// match: (Trunc32to16 (Const32 [c]))
 	// cond:
 	// result: (Const16  [int64(int16(c))])
@@ -21451,7 +21595,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
 	// match: (Trunc32to8 (Const32 [c]))
 	// cond:
 	// result: (Const8   [int64(int8(c))])
@@ -21537,7 +21681,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
 	// match: (Trunc64to16 (Const64 [c]))
 	// cond:
 	// result: (Const16  [int64(int16(c))])
@@ -21649,7 +21793,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
 	// match: (Trunc64to32 (Const64 [c]))
 	// cond:
 	// result: (Const32  [int64(int32(c))])
@@ -21787,7 +21931,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
 	// match: (Trunc64to8 (Const64 [c]))
 	// cond:
 	// result: (Const8   [int64(int8(c))])
@@ -21873,7 +22017,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpXor16(v *Value) bool {
+func rewriteValuegeneric_OpXor16_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Xor16 (Const16 [c]) (Const16 [d]))
@@ -22056,6 +22200,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpXor16_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Xor16 (Xor16 z i:(Const16 <t>)) x)
 	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 	// result: (Xor16 i (Xor16 <t> z x))
@@ -22256,7 +22405,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpXor32(v *Value) bool {
+func rewriteValuegeneric_OpXor32_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Xor32 (Const32 [c]) (Const32 [d]))
@@ -22439,6 +22588,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpXor32_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Xor32 (Xor32 z i:(Const32 <t>)) x)
 	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 	// result: (Xor32 i (Xor32 <t> z x))
@@ -22639,7 +22793,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpXor64(v *Value) bool {
+func rewriteValuegeneric_OpXor64_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Xor64 (Const64 [c]) (Const64 [d]))
@@ -22822,6 +22976,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpXor64_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Xor64 (Xor64 z i:(Const64 <t>)) x)
 	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 	// result: (Xor64 i (Xor64 <t> z x))
@@ -23022,7 +23181,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpXor8(v *Value) bool {
+func rewriteValuegeneric_OpXor8_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	// match: (Xor8 (Const8 [c]) (Const8 [d]))
@@ -23205,6 +23364,11 @@
 		v.AddArg(v0)
 		return true
 	}
+	return false
+}
+func rewriteValuegeneric_OpXor8_10(v *Value) bool {
+	b := v.Block
+	_ = b
 	// match: (Xor8 (Xor8 z i:(Const8 <t>)) x)
 	// cond: (z.Op != OpConst8  && x.Op != OpConst8)
 	// result: (Xor8  i (Xor8  <t> z x))
@@ -23405,7 +23569,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZero(v *Value) bool {
+func rewriteValuegeneric_OpZero_0(v *Value) bool {
 	b := v.Block
 	_ = b
 	config := b.Func.Config
@@ -23441,7 +23605,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
 	// match: (ZeroExt16to32 (Const16 [c]))
 	// cond:
 	// result: (Const32 [int64(uint16(c))])
@@ -23482,7 +23646,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
 	// match: (ZeroExt16to64 (Const16 [c]))
 	// cond:
 	// result: (Const64 [int64(uint16(c))])
@@ -23523,7 +23687,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
 	// match: (ZeroExt32to64 (Const32 [c]))
 	// cond:
 	// result: (Const64 [int64(uint32(c))])
@@ -23564,7 +23728,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
 	// match: (ZeroExt8to16 (Const8 [c]))
 	// cond:
 	// result: (Const16 [int64( uint8(c))])
@@ -23605,7 +23769,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
 	// match: (ZeroExt8to32 (Const8 [c]))
 	// cond:
 	// result: (Const32 [int64( uint8(c))])
@@ -23646,7 +23810,7 @@
 	}
 	return false
 }
-func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
 	// match: (ZeroExt8to64 (Const8 [c]))
 	// cond:
 	// result: (Const64 [int64( uint8(c))])