Twenty Eighth International Obfuscated C Code Contest

  cc -Wno-implicit-int -Wno-implicit-function-declaration phase.c && ./a.out

"While terseness was preferred over obscurity, this program hopefully still lives down to IOCCC’s usual standards of clarity."

> By an astonishing coincidence, the number of bits in the input format is approximately the log2 of the number of MD5 evaluations that a five-year-old GPU can do in an hour.

This is right there in the mad scientist territory.

Incredible, pure bananas.

https://www.youtube.com/live/UDzGwTalVAc

/ * PPM Pattern Generator * * This program generates a 80x80 black and white PPM image based on a * hexadecimal input pattern. The pattern is rendered as ASCII art using * bit manipulation to determine which pixels are on or off. /

int main() { long pixel_index = 0; // Current pixel being processed (0-6399 for 80x80) long horizontal_offset; // Horizontal position relative to center long hex_pattern; // Input hexadecimal pattern

    // Output PPM header for 80x80 black and white image
    // P1 = ASCII black and white format
    // 80 80 = width and height
    puts("P1\n80 80");
    
    // Read hexadecimal pattern from user (up to 10 hex digits)
    scanf("%10lx", &hex_pattern);
    
    // Process each pixel in the 80x80 image
    // Continue until we've processed all pixels
    // The condition (3 - pixel_index/2160) continues while pixel_index < 6480
    // This accounts for 80x80 = 6400 pixels plus some margin
    for (; 3 - pixel_index/2160; ) {
        
        // Move to next pixel and calculate horizontal offset from center
        pixel_index++;
        horizontal_offset = (pixel_index % 81) / 8 - 5;
        
        // Determine what to output for this pixel
        if (horizontal_offset < 5) {
            // We're in the main pattern area (central region)
            
            // Complex bit manipulation to determine pixel state:
            // 1. Calculate bit position based on horizontal offset
            int bit_pos = (horizontal_offset ^ -(horizontal_offset < 1)) + 1;
            
            // 2. Extract relevant bits from the pattern
            // hex_pattern << 5 shifts the pattern
            // >> (pixel_index/648*5) selects which part of pattern to use based on vertical position
            long pattern_bits = (hex_pattern << 5) >> (pixel_index/648 * 5);
            
            // 3. Check if the specific bit is set
            int bit_is_set = (16 >> bit_pos) & pattern_bits;
            
            // 4. Invert the bit and XOR with '1' (ASCII 49) to get '0' or '1'
            char pixel_char = (!bit_is_set) ^ 49;
            
            putchar(pixel_char);
            
        } else {
            // We're outside the pattern area - output newline
            putchar(10);  // ASCII 10 = newline character
        }
    }
    
    return 0;

/ * USAGE: * Compile: gcc -o pattern_gen pattern_gen.c * Run: ./pattern_gen * Input: Enter a hexadecimal number (e.g., 1234ABCD) * Output: PPM format image data that can be saved to a .pbm file * * EXAMPLE: * ./pattern_gen > output.pbm * Then input: DEADBEEF * * The resulting .pbm file can be viewed with image viewers that support PPM format * or converted to other formats using tools like ImageMagick. */

I think you can answer your own question