cprint {

  sclass VStack implements Steppable {

    new L<Computable> stack;

    void subCompute(Computable computation) {

      computation.stack = this;

      stack.add(computation);

    }

    public bool step() {

      if (empty(stack)) false;

      if (last(stack).returned)

        popLast(stack);

      else

        last(stack).run();

      true;

    }

  }

  asclass Computable implements Runnable {

    VStack stack;

    bool returned;

    Runnable continuation;

  }

  sclass f_ackermann extends Computable {

    BigInt a, b;

    BigInt returnValue;

    *(BigInt *a, BigInt *b) {}

    record noeq JustReturn(f_ackermann subComputation) implements Runnable {

      run {

        returnValue = subComputation.returnValue;

        set returned;

      }

    }

    record noeq Step2(f_ackermann subComputation) implements Runnable {

      run {

        f_ackermann subComputation2 = new(minus(a, BigInt.ONE), 

          subComputation.returnValue);

        continuation = new JustReturn(subComputation2);

        stack.subCompute(subComputation2);

      }

    }

    run {

      if (continuation != null)

        ret with continuation.run();

      if (a.equals(BigInt.ZERO)) {

        returnValue = plus(b, BigInt.ONE);

        ret with set returned;

      }

      if (b.equals(BigInt.ZERO)) {

        f_ackermann subComputation = new(a.subtract(BigInt.ONE), BigInt.ONE);

        continuation = new JustReturn(subComputation);

        stack.subCompute(subComputation);

        ret;

      }

      f_ackermann subComputation = new(a, minus(b, BigInt.ONE));

      continuation = new Step2(subComputation);

      stack.subCompute(subComputation);

    }

  }

  start-thread {

    new VStack stack;

    f_ackermann ack = new(bigInt(2), bigInt(2));

    stack.subCompute(ack);

    stepAllWithStats(stack);

    print("Result: " + ack.returnValue);

  }

}