return 1
		}
	}
	return 0
}

// returns2.go T_chained_indirect_call 132 0 1
// <endpropsdump>
// {"Flags":0,"ParamFlags":[0,0],"ResultFlags":null}
// callsite: returns2.go:135:18|0 flagstr "" flagval 0 score -31 mask 8192 maskstr "returnFeedsInlinableFuncToIndCallAdj"
// <endcallsites>
// <endfuncpreamble>
func T_chained_indirect_call(x, y int) {
	// Here 'returnsFunc' returns an inlinable func that feeds

}

// interestingToCompare returns TRUE if we want to compare results
// for function 'fname'.
func interestingToCompare(fname string) bool {
	if strings.HasPrefix(fname, "init.") {
		return true
	}
	if strings.HasPrefix(fname, "T_") {
		return true
	}
	f := strings.Split(fname, ".")
	if len(f) == 2 && strings.HasPrefix(f[1], "T_") {
		return true
	}
	return false

			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
  ]