}
	}

L9:
	switch {
	case true:
		break L9
	defalt /* ERROR "label defalt declared and not used" */ :
	}

L10:
	select {
	default:
		break L10
		break L9 /* ERROR "invalid break label L9" */
	}

	goto L10a
L10a: L10b:
	select {
	default:
		break L10a /* ERROR "invalid break label L10a" */
		break L10b
		continue L10b /* ERROR "invalid continue label L10b" */
	}
}

                    break;

                case SessionStarted:
                    listener.sessionStarted(event);
                    break;
                case SessionEnded:
                    listener.sessionEnded(event);
                    break;

                case ProjectSkipped:
                    listener.projectSkipped(event);
                    break;
                case ProjectStarted:

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

			break
		}
		z := v_0
		if z.Op != OpPPC64XOR {
			break
		}
		if !(v.Block == z.Block) {
			break
		}
		v.reset(OpPPC64CMPconst)
		v.AuxInt = int64ToAuxInt(0)
		v.AddArg(convertPPC64OpToOpCC(z))
		return true
	}
	// match: (CMPconst [0] z:(NEG x))
	// cond: v.Block == z.Block
	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
	for {
		if auxIntToInt64(v.AuxInt) != 0 {
			break
		}

	// result: (BSFQ (ORQconst <t> [1<<8] x))
	for {
		if v_0.Op != OpAMD64ORQconst {
			break
		}
		t := v_0.Type
		if auxIntToInt32(v_0.AuxInt) != 1<<8 {
			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != OpAMD64MOVBQZX {
			break
		}
		x := v_0_0.Args[0]
		v.reset(OpAMD64BSFQ)
		v0 := b.NewValue0(v.Pos, OpAMD64ORQconst, t)

				continue
			}
			v.reset(OpAddPtr)
			v.AddArg2(ptr, off)
			return true
		}
		break
	}
	// match: (Convert (Convert ptr mem) mem)
	// result: ptr
	for {
		if v_0.Op != OpConvert {
			break
		}
		mem := v_0.Args[1]
		ptr := v_0.Args[0]
		if mem != v_1 {
			break
		}
		v.copyOf(ptr)
		return true
	}
	return false
}

    expression = when {
                a + b > 0 -> break
                a - b > 0 -> break
                else -> consume(0)
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

    expression = if (a + b > 0) break
            else {
                consume(a - b)
                if (a - b > 0) break else consume(a + b)
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

			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)

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