if v_2.Op != OpMIPSMOVWconst || auxIntToInt32(v_2.AuxInt) != 0 {
			break
		}
		v.copyOf(f)
		return true
	}
	// match: (CMOVZ a _ (MOVWconst [c]))
	// cond: c!=0
	// result: a
	for {
		a := v_0
		if v_2.Op != OpMIPSMOVWconst {
			break
		}
		c := auxIntToInt32(v_2.AuxInt)
		if !(c != 0) {
			break
		}
		v.copyOf(a)
		return true
	}

		if !(shiftIsBounded(v)) {
			break
		}
		v.reset(OpWasmI64Shl)
		v.AddArg2(x, y)
		return true
	}
	// match: (Lsh64x64 x (I64Const [c]))
	// cond: uint64(c) < 64
	// result: (I64Shl x (I64Const [c]))
	for {
		x := v_0
		if v_1.Op != OpWasmI64Const {
			break
		}
		c := auxIntToInt64(v_1.AuxInt)
		if !(uint64(c) < 64) {
			break
		}
		v.reset(OpWasmI64Shl)

                    break;
                case "group":
                    group = reader.nextString();
                    break;
                case "module":
                    module = reader.nextString();
                    break;
                case "version":
                    version = reader.nextString();
                    break;
                default:

	// match: (Lsh16x64 _ (Int64Make (Const32 [c]) _))
	// cond: c != 0
	// result: (Const32 [0])
	for {
		if v_1.Op != OpInt64Make {
			break
		}
		v_1_0 := v_1.Args[0]
		if v_1_0.Op != OpConst32 {
			break
		}
		c := auxIntToInt32(v_1_0.AuxInt)
		if !(c != 0) {
			break
		}
		v.reset(OpConst32)
		v.AuxInt = int32ToAuxInt(0)
		return true
	}
	// match: (Lsh16x64 [c] x (Int64Make (Const32 [0]) lo))

			v.AddArg3(x, y, z)
			return true
		}
		break
	}
	// match: (FMADDD x y neg:(FNEGD z))
	// cond: neg.Uses == 1
	// result: (FMSUBD x y z)
	for {
		x := v_0
		y := v_1
		neg := v_2
		if neg.Op != OpRISCV64FNEGD {
			break
		}
		z := neg.Args[0]
		if !(neg.Uses == 1) {
			break
		}
		v.reset(OpRISCV64FMSUBD)
		v.AddArg3(x, y, z)

	for i := 0; true; {
		A()
		i = i + 1
		if i >= b.N {
			break
		}
		A()
		i = i + 1
		if i >= b.N {
			break
		}
		A()
		i = i + 1
		if i >= b.N {
			break
		}
		A()
		i = i + 1
		if i >= b.N {
			break
		}
		A()
		i = i + 1
		if i >= b.N {
			break
		}
		A()
		i = i + 1
		if i >= b.N {
			break
		}
	}

//    Me, Cf, Lm or Sk).
//    Rule: Don't break between Letter and Mid, but break between two Mids.
//
// 3) Break:
//    Any other category: NewLine, MidNum, CR, LF, Double_Quote, Katakana, and
//    Other.
//    These categories should always result in a break between two cased letters.
//    Rule: Always break.
//
// Note 1: the Katakana and MidNum categories can, in esoteric cases, result in

                break;
            case IMP_ERR:
                resultCodeString = "IMP_ERR";
                break;
            case RFS_ERR:
                resultCodeString = "RFS_ERR";
                break;
            case ACT_ERR:
                resultCodeString = "ACT_ERR";
                break;
            case CFT_ERR:
                resultCodeString = "CFT_ERR";
                break;
            default:

            break;
        case IMP_ERR:
            resultCodeString = "IMP_ERR";
            break;
        case RFS_ERR:
            resultCodeString = "RFS_ERR";
            break;
        case ACT_ERR:
            resultCodeString = "ACT_ERR";
            break;
        case CFT_ERR:
            resultCodeString = "CFT_ERR";
            break;
        default:

                        threadSum++;
                        break;
                      case 1:
                        map.decrementAndGet(key);
                        threadSum--;
                        break;
                      case 2:
                        map.addAndGet(key, delta);
                        threadSum += delta;
                        break;
                      case 3: