program primes;
    /* prints all prime numbers <= max. */
    /* this contains some recursion just for fun. */

	/* elements 0 and 1 are ignored. */
    var bitmap: array[0..45] of boolean;
        max: integer; /* same as the length of the array */
                     /* spim seems to die for larger sizes. */

    procedure initbitmap;
	/* initialize bitmap to all true's. */
	var i: integer;
    begin
	i := 2;
	while i <= max do
	    begin
		bitmap[i] := true;
		i := i + 1
	    end
    end /*initbitmap*/;

    function firsttrue(n: integer): integer;
	/* returns the index of the first true element of the bitmap
	  at or after element n.
	  if there is no such, returns 0. */
    begin
	if n > max then
	    firsttrue := 0
	else
	    if bitmap[n] then
		firsttrue := n
	    else
		firsttrue := firsttrue(n + 1)
    end /*firsttrue*/;

    procedure putprimes(startingprime: integer);
	/* startingprime must be a prime number.
	  this prints startingprime, and then prints
	  primes after that, until max is reached. */

	var n: integer;
	    j: integer;
	    next: integer;
    begin
	n := startingprime;
	writeln(n);

	/* set bitmap[j] to false for all multiples j of startingprime: */
	j := 2*n;
	while j <= max do
	    begin
		bitmap[j] := false;
		j := j + n
	    end;

	/* find the next true element of bitmap after bitmap[startingprime].
	  that's the next prime number, so call ourself with that: */
	next := firsttrue(n + 1);
	writeln('putprimes');
	writeln(next);
	if next <> 0 then /* reached the end? */
	    putprimes(next)
    end /*putprimes*/;

begin
    max := 44;
    initbitmap;
    putprimes(2);
    writeln('finished')
end /*primes*/.