I naively expect above/below above/below above/below return sequence, rather than above/above/above below/below/below return.

```  print "above\n";
my \$E = binary(\$k);
print "below\n";

No, it has to finish the binary(\$k) before it can do the print "below\n". And that binary() call has its own above/binary()/below sequence to follow. It would be like saying:

```  print "x\n";
print "y\n";
print "z\n";

You wouldn't expect that to output "x/z/y", would you? Each line has to finish before the next one starts, and the recursive binary() call will (from the top) also involve another recursive call before it returns to the original call.

It may be simpler to look a version without the calculations, just showing the call path:

```# How many steps we want to take
my \$steps = 3;

sub recur
{
my (\$x) = @_;

# Create a number of leading spaces equal to our current \$x
my \$ldr = " " x \$x;

# Note that we're starting

# We only go to \$steps to make it a smallish example
if(\$x >= \$steps)
{
print "\${ldr}At \$steps, returning.\n";
return;
}

# Recurse with the next number.  Say we're doing it, do it, say we
+'re
# done.
my \$y = \$x + 1;
print "\${ldr}-> Subcall with \$y\n";
recur(\$y);
print "\${ldr}<- Back from \$y\n";

# And now we're done with this number, so step back
print "\${ldr}Done with \$x\n";
}

# Start off
recur(0);

So now we're just calling ourselves \$steps times, and noting where we go. Output:

```% ./tst.pl
-> Subcall with 1
-> Subcall with 2
-> Subcall with 3