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 = []

expression: BREAK
text: break

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?) {}

fun test(b: Boolean) {
    while (true) {
        if (<expr>break</expr>) {
            "OK"
        } else {
            continue
        }
    }

	}
	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