KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = null
  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break@x
  ]
  returnValueType = null
  valuedReturnExpressions = []

// WITH_STDLIB

fun test(a: Int): Int {
    val b: Int = a + 10
    for (n in 1..b) {
        <expr>if (n > 5) throw Exception("")
        if (a + n > b) break
        println(b - n)</expr>
    }

    expression = if (cond()) {
                    break
                } else if (cond()) {
                    break@outer
                }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = true
  jumpExpressions = [
    break,
    break@outer
  ]
  returnValueType = null
  valuedReturnExpressions = []

fun test() {
    x@ while (cond()) {
        <expr>consume(5)
        break@x</expr>
    }
}

fun cond(): Boolean = true

    expression = println(b - n)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

fun test() {
    outer@ while (cond()) {
        consume(1)
        while (cond()) {
            consume(2)
            <expr>if (cond()) {
                break
            } else if (cond()) {
                break@outer
            }</expr>
        }
    }
}

fun consume(obj: Any?) {}

	}
	return s, false
}

func isHR(s line) bool {
	t := s
	t.trimSpace(0, 3, false)
	switch c := t.peek(); c {
	case '-', '_', '*':
		for i := 0; ; i++ {
			if !t.trim(c) {
				if i >= 3 {
					break
				}
				return false
			}
			t.skipSpace()
		}
		return t.eof()
	}
	return false
}

type HardBreak struct{}

func (*HardBreak) Inline() {}

		x := v_0
		if x.Op != OpARM64Equal {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(NotEqual _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64NotEqual {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(LessThan _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64LessThan {
			break
		}
		v.copyOf(x)
		return true

			break
		}
		v_0_0 := v_0.Args[0]
		if v_0_0.Op != OpARM64ANDconst {
			break
		}
		c1 := auxIntToInt64(v_0_0.AuxInt)
		x := v_0_0.Args[0]
		if v_1.Op != OpARM64ANDconst {
			break
		}
		c2 := auxIntToInt64(v_1.AuxInt)
		if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
			break
		}
		v.reset(OpARM64REV16W)

	for {
		if auxIntToInt32(v.AuxInt) != 6 {
			break
		}
		x := v_0
		y := v_1
		if v_2.Op != OpPPC64CMPconst || auxIntToInt64(v_2.AuxInt) != 0 {
			break
		}
		v_2_0 := v_2.Args[0]
		if v_2_0.Op != OpPPC64ANDconst || auxIntToInt64(v_2_0.AuxInt) != 1 {
			break
		}
		v_2_0_0 := v_2_0.Args[0]
		if v_2_0_0.Op != OpPPC64SETBC {
			break
		}
		c := auxIntToInt32(v_2_0_0.AuxInt)