continue
		}
	}
}

func returns0() {
	return
	return 0 /* ERROR "too many return values" */
}

func returns1(x float64) (int, *float64) {
	return 0, &x
	return /* ERROR "not enough return values" */
	return "foo" /* ERRORx `cannot .* in return statement` */, x /* ERRORx `cannot use .* in return statement` */
	return 0, &x, 1 /* ERROR "too many return values" */
}

func returns2() (a, b int) {

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

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

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

fun foo(a: Int): Int {
    a.let {
        <expr>if (it > 0) return@foo it else return -it</expr>
    }
    return 0

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

  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return it,
    return@foo -it
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return it,
    return@foo -it
  ]

  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return@foo it,
    return -it
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return@foo it,
    return -it
  ]

    expression = if (a + b > 0) return 0
        else if (a - b < 0) consume(a - b)
        else consume(0)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return 0
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 0
  ]

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