* Make the FFT size a bit larger.
 * Explicitely pass the addressing strategies to use for reading input and
   writing output on each stage. So far, only REGULAR_IN is supported for
   input (ie, no changes) and REGULAR_OUT and BITREVERSED_OUT are supported
   for output (ie, add support for bitreversing the last stage).

 * Let the libmontiumc version output it's input and output in a matlab
   compatible format.
 * Use a longer period worth of sinus function.

 * Let the python simulator load the input memories from file.
 * Let the python simulator break when the algorithm is done (ie, gpo(0) is set).

 * Let the libmontiumc write the contents of the input memories to file before
   starting, so we can use them in the python simulator.
 * Output the results in hex as well as fixed point format.
 * Fix some comments.

 * Let the run() function set gpo(0) after completion of the algorithm.

 * 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.