* No longer keep a global variable with the current stage number, but pass it
   as an argument to the functions that need it. This also replaces the
   stage_odd parameter.
 * No longer loop through the needed stages, since the Montium sequencer can't
   change the twiddle memory mask dynamically. Instead, call the (new)
   do_regular_stage() function four times manually, with constant stage
   numbers that the optimizer can roll out.

 * Improve debug output slightly.

 * Change loops back to do while, MontiumCC can't handle while loops.

 * Add a missing ! in write_output_regular().
 * Use while loops instead of do while, since loop_next checks for zero before
   decrementing, not after.
Regular FFT seems to work now, though there seem to be quite some rounding errors.
Testing a larger FFT is hard, since decoding the results is still manual.

 * Add a few constraints on the FFT size parameters and make the parameters
   abide by those constraints (we're now doing 4 16-point FFT's).

 * Use two periods of the sine for testing instead of one and scale the values
   to prevent overflow.

 * Keep track of the current stage number (not montiumcc compatible) so we
   know which twiddle factors we need. This needs checking and improving.

 * Actually make the output addressing different in the second half, it was
   still the same as the first half.
 * Actually do half a stage in do_half_regular_stage() instead of a full
   stage.
 * Let run do n_t stages instead of just two.
 * Call init_libmontiumc() in our main(), so libmontiumc actually works.

 * Cleanup and comments.

 * Cleanup main.cpp a bit.
 * Let the libmontiumc implementation allocate its memories itself, because the
   montiumcc version doesn't use global variables for that anymore.

 * Prefix all algorithm parameters with PARAM_ so we can still use variable
   names such as 'n'.

 * Remove some unused code.
 * Add more comments.
 * Slightly change the behaviour of do_half_regular_stage(), it now intializes
   the output addresses once instead of on every cycle. It also waits for the
   last write cycle to complete before returning.

 * Add current progress of the project. The code compiles and should be able to execute two stages of regular FFT by now.