main(ctr){
    // Until ctr is 448, we keep calling main ... recursively
    if (ctr != 448) {
        main(ctr + 1);
    }

    // When CTR doesn't divide evenly by 64 ...
    if (--ctr % 64) {

        int k = 0;

        if (ctr & 2) {
            k = 1;
        } else {
            k = 8;
        }

        // Lookup table number one ...
        char * a = ">'txiZ^(~z?" - 48;

        // Where to start indexing into const char * named __TIME__
        int b = 7 - (ctr / 8 % 8);

        // Set pointer to location of digit we want to read
        char * d = __TIME__ + b;


        int e = (((ctr * 2) & 8) | (ctr / 64));

        // Get the character that equates to the location specified by e
        char f =  (";;;====~$::199"[e]);

        // Divide by either 1 or 8 depending on whether ctr has the second bit set
        int g = (f / k);

        // Get what is left over after dividing by 8
        int h = g % 8;

        // Offset into a (lookup table) by the ascii of wherever d is pointing,
        // which is __TIME__ + b. Then add 1 to get the integer required. (The
        // lookup table is shifted down 1, because it contains ~ and the next
        // character in the ASCII table to represent would be the DEL (127
        // dec), so we add 1 now...
        int l = a[d[0]] + 1;

        // We shift it over according to h
        int n = l >> h;

        // We check to see if the high bit is set or not
        int o = n & 1;

        putchar(
                // We take 32 and or it with o, if the high bit was set, this
                // will cause the high bit to be set in 32 as well turning it
                // into 33, also known as !. 32 is a space in the ASCII table
                32 | o
               );
    } else {
        // If CTR does divide equally by 64
        //
        // Print a newline
        putchar(10);
    }
}