case 0:
                    return cached ? cachedLinear[random.nextInt(cached.size())] : next()
                case 1:
                    return cache(nextModule())
                case 2:
                    return cache(nextGroup())
                case 3:
                    return cache(nextModuleId())
                case 4:
                    return cache(nextGroupSet())
                case 5:

			return true
		}

	case *ast.BlockStmt:
		return check.isTerminatingList(s.List, "")

	case *ast.IfStmt:
		if s.Else != nil &&
			check.isTerminating(s.Body, "") &&
			check.isTerminating(s.Else, "") {
			return true
		}

	case *ast.SwitchStmt:
		return check.isTerminatingSwitch(s.Body, label)

	case *ast.TypeSwitchStmt:
		return check.isTerminatingSwitch(s.Body, label)

	case *ast.SelectStmt:

expression: RETURN
text: return 54

  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return 1,
    return 2,
    return b
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 1,
    return 2,
    return b
  ]

fun test(flag: Boolean): Int {
    block {
        <expr>if (flag) {
            return 1
        }

        consume("foo")
        return@block</expr>
    }

    return 0
}

inline fun block(block: () -> Unit) {}

func _() int {
	return 2
	print(3)
} // ERROR "missing return"

func _() int {
L:
	goto L
	print(3)
} // ERROR "missing return"

func _() int {
	panic(2)
	print(3)
} // ERROR "missing return"

func _() int {
	{
		return 2
		print(3)
	}
} // ERROR "missing return"

func _() int {
L:
	{
		goto L

			return true
		}

	case *syntax.BlockStmt:
		return check.isTerminatingList(s.List, "")

	case *syntax.IfStmt:
		if s.Else != nil &&
			check.isTerminating(s.Then, "") &&
			check.isTerminating(s.Else, "") {
			return true
		}

	case *syntax.SwitchStmt:
		return check.isTerminatingSwitch(s.Body, label)

	case *syntax.SelectStmt:
		for _, cc := range s.Body {

  defaultExpressionInfo = null
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = true
  jumpExpressions = [
    return 1,
    return@block
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 1
  ]

fun foo(a: Int): Int {
    val b: Int = 1
    <expr>if (a + b > 0) return 1
    else if (a - b < 0) return 2
    else return b</expr>

  defaultExpressionInfo = null
  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return a + b
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return a + b
  ]