mirror/ioccc
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Landon Curt Noll authored and GitHub committed 2025-08-06 16:19:03 -07:00
2 parents 808ddf12e5 187bc22f69
commit 6811aa55ae
19 files changed
+480 -169
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

2024/README.md
+38 -30
View File
@@ -39,15 +39,20 @@ The **major motivation** for the above was to:
On the last point, for **IOCCC28** the Judging started on **2025-06-05 04:03:02.010099 UTC** and then the winners were selected by the [IOCCC Judges](../judges.html) on **2025-07-07 20:05:07.000000 UTC**:
* Winners were announced during a live the [Our Favorite Universe](https://www.youtube.com/@OurFavoriteUniverse) YouTube Channel that started on **2025-08-02 18:00:00.000000 UTC**
* Winners were announced during a live show that started on **2025-08-02 18:00:00.000000 UTC**
on the [Our Favorite Universe](https://www.youtube.com/@OurFavoriteUniverse)
YouTube Channel.
* Near the end of the 2 hour XXX-add-show-URL-here-XXX YouTube show, the **source code** of the [IOCCC28 winning entries](#inventory) was published on [IOCCC GitHub winner repo](https://github.com/ioccc-src/winner) and on the [Official IOCCC website](../index.html).
* At about 03h:42m:03s mark in the 04h:30m:35s [YouTube
show](https://www.youtube.com/live/UDzGwTalVAc), the **source code** of the
[IOCCC28 winning entries](#inventory) was published on [IOCCC GitHub winner
repo](https://github.com/ioccc-src/winner) and on the [Official IOCCC
website](../index.html).
**No longer will there be many months** between when the winners are
announced and their source code is made available. For **IOCCC28**
the time was **less than 2 hours**. :-)
### Increased submission quantity and quality
The submissions to **IOCCC28** were remarkable when compared with previous contests, in both the
@@ -55,16 +60,16 @@ The submissions to **IOCCC28** were remarkable when compared with previous conte
was more challenging and required greater effort. Thankfully due to the above mentioned improvements,
the judging process **took only 33 days**. Under the previous system it **would have taken much longer**!
One thing that began to emerge after we exits the early rounds of judging and entered the middle rounds
One thing that began to emerge after we exited the early rounds of judging and entered the middle rounds
of judging was that we were very likely to have more winning entries than in previous contests.
Even so, the final rounds of judging required more rounds and tool longer than in any previous IOCCC.
Even so, the final rounds of judging required more rounds and took longer than any previous IOCCC.
At the end of the final round of the final rounds of judging, we had a record **23 winners of IOCCC28**,
eclipsing the record of 15 winners!
While we suspect that the 4 year gap between **IOCCC27** and **IOCCC28** allowed
people extra time to improve their submissions, we also believe that people
submitting to the IOCCC have become more adept in adept in obfuscation and have
submitting to the IOCCC have become more adept in obfuscation and have
become more skilled in the programming in the C language.
@@ -82,14 +87,15 @@ was the first size increase in over 10 years. Given the quality of submissions
that were well under the limit, we do **NOT** expect to change the
[Rule 2 size limit](../next/rules.html#rule2) for **at least another 10 years** (and likely longer).
**IMPORTANT HINT**: Only 3 of 23 the **IOCCC28 winners** came close to the [Rule 2 size limit](../next/rules.html#rule2).
Large code size isn't everything. :-) Those submitting to future contents should
**take a careful note** of that fact.
**IMPORTANT HINT**: Only 3 of the 23 **IOCCC28 winners** came close to the [Rule
2 size limit](../next/rules.html#rule2). Large code size isn't everything. :-)
Those submitting to future contents should **take a careful note** of that fact.
### Rules and Guidelines for this contest
Here are the final versions of the IOCCC rules and guidelines that were in effect for this contest:
Here are the final versions of the IOCCC rules and guidelines that were in
effect for this contest:
* [2024 rules](rules.html) version **28.30 2025-03-03**
* [2024 guidelines](guidelines.html) version **28.47 2025-03-15**
@@ -142,7 +148,7 @@ into the code's obfuscation. :-)
* [2024/howe](howe/index.html)
"_Eh_"? The source code, with its UTF-8 conforming accent gives you a
polite editor that is more functional an `ed(1)`.
polite editor that is more functional than `ed(1)`.
We invite you to use the program to view the UTF-8 fun in the
[2024/howe/prog.c source code](%%REPO_URL%%/2024/howe/prog.c).
@@ -165,7 +171,7 @@ different hex digits value. Then feed the MD5 hash of the
The [2024/endoh1/try.sh](%%REPO_URL%%/2024/endoh1/try.sh) will carry you on
a journey that tests your patience as well as the patience of the C-preprocessor.
Building a 8x8 image requires order of 20 seconds of C-preprocessor
Building a 8x8 image requires an order of 20 seconds of C-preprocessor
time, when running 6 jobs on 4 CPU cores in parallel. Unfortunately,
with such a tiny image, it is hard to appreciate the image being rendered.
@@ -185,8 +191,8 @@ will be given an image with a reasonable amount of detail to appreciate
what is being rendered.
One fun aspect of the [2024/endoh1/prog.c source code](%%REPO_URL%%/2024/endoh1/prog.c)
is that when it is compiled an executed, the program outputs C code.
That C code, call it `rt.c` will fail to compile! But that is OK because the C-preprocessor
is that when it is compiled and executed, the program outputs C code.
That C code, called `rt.c`, will fail to compile! But that is OK because the C-preprocessor
has enough work to do without bothering the C compiler. :-)
We plan to recognise those who report that they [rendered a new record sized image](endoh1/index.html#larger).
@@ -204,7 +210,7 @@ This won the "**Prize in ℤ₃**", but what does that mean? Well,
the "_double-struck Z_" is **NOT** a reference to a set of integers,
nor is the "_double-struck Z subscript 3_" a reference to a ring of
3-adic integers. Instead, it is a reference to the 3rd version of a
certain [virtual machine](https://en.wikipedia.org/wiki/Z-machine).
[certain virtual machine](https://en.wikipedia.org/wiki/Z-machine).
If you use the [2024/mills/try.sh](%%REPO_URL%%/2024/mills/try.sh) script, you will first be given
an opportunity to view the [2024/mills/prog.c source code](%%REPO_URL%%/2024/mills/prog.c).
@@ -218,7 +224,7 @@ reading/navigating the twisty mazes of this source code! :-)
As you study the [2024/codemeow/prog.c source code](%%REPO_URL%%/2024/codemeow/prog.c),
try not to lose track of the forest of obfuscation while tracking down the execution path trees.
We think this code will "grow on you" as the C expression goes just a compiled C code "_grows on parse trees_". :-)
We think this code will "grow on you" as the C expression goes just as compiled C code "_grows on parse trees_". :-)
* [2024/kurdyukov2](kurdyukov2/index.html)
@@ -235,13 +241,13 @@ you run this code: let alone when your try to figure out how the author was able
encode the virtual machine in under **2.5K bytes** of [prog.c source code](%%REPO_URL%%/2024/kurdyukov3/prog.c)!
**NOTE**: The implementation runs without sound or mouse
input. You will need reply on your keyboard skills. The
input. You will need to rely on your keyboard skills. The
[2024/kurdyukov3/try.sh](%%REPO_URL%%/2024/kurdyukov3/try.sh)
demonstration script will give you some useful keyboard hints.
* [2024/cable2](cable2/index.html)
To those who follow the concept of "_seeing is believing_" will very
Those who follow the concept of "_seeing is believing_" will very
likely be "_deceived_" when they try to see the source in terminal window:
``` <!---sh-->
@@ -249,11 +255,11 @@ likely be "_deceived_" when they try to see the source in terminal window:
```
Viewing the [prog.c source code](%%REPO_URL%%/2024/cable2/prog.c) in most editors
might suggest that the is something fishy 🐠 with the code.
might suggest that there is something fishy 🐠 with the code.
* [2024/macke](macke/index.html)
Have you ever wondered would what would happen if you recursively removed
Have you ever wondered what would would happen if you recursively removed
files starting from the root directory? Are you curious what happens when
you launch a [fork bomb](https://en.wikipedia.org/wiki/Fork_bomb)?
You can safely give those and other scenarios under this virtual machine.
@@ -291,15 +297,15 @@ by computing the output of each gate in a loop, effectively running the CPU and
### Remarks on some of submissions that did not win
* Depending on the address of a variable, as not all platforms support
[ASLR](https://en.wikipedia.org/wiki/Address_space_layout_randomization),
as the single source of pseudo-randomness isn't a good idea. It's
much better to mix in other sources of variability (e.g. time, process
* Depending on the address of a variable as the single source of
pseudo-randomness isn't a good idea, as not all platforms support
[ASLR](https://en.wikipedia.org/wiki/Address_space_layout_randomization).
It's much better to mix in other sources of variability (e.g. time, process
ID, etc.) so that subsequent runs will behave differently.
* If a submission's obfuscation strongly resembles a past IOCCC winning
entry, and the submission's obfuscation is mainly in the C code source,
then the submission likely to not make it into the final rounds of judging.
then the submission is likely to not make it into the final rounds of judging.
* When working with modern C compilers, it's crucial to explicitly
declare variable and function types. Don't assume they'll
@@ -319,8 +325,9 @@ might not be the most innovative approach.
C code that implements the mathematics is well obfuscated.
* Just a friendly reminder that before you upload your submissions,
uncompress the compressed tarball into a different directory. This way,
you can be sure you didn't miss uploading any important files!
uncompress the compressed tarball into a different directory and verify
everything is in order. This way, you can be sure you didn't miss uploading any
important files!
* Using a lot of goto statements to make your code harder to understand
might not help it pass the final rounds of judging.
@@ -339,7 +346,7 @@ submission. If you think this happened with your submission, consider
submitting an enhanced version to the next IOCCC.
**PLEASE DO NOT** give up hope! There are some submissions that have been
submitted with revisions, multiple times before rising to the level of
submitted with revisions multiple times before rising to the level of
a winning IOCCC entry. You might also want to try with a different type
of submission altogether for the next IOCCC.
@@ -353,14 +360,15 @@ Some C compilers aren't as great as they could be. If yours isn't
working well, you might want to try compiling with an updated version
of clang and/or gcc instead.
If you encounter problems in compiling and/or running the winning entries, see the FAQ on:
If you encounter problems in compiling and/or running the winning entries, see
the FAQs on:
* [Compiling IOCCC entries](../faq.html#compiling)
* [IOCCC entry dependencies](../faq.html#dependencies)
* [Problems compiling entries](../faq.html#compile_problems)
* [Running IOCCC entries](../faq.html#running_entries)
For additional information on how to submit fixes, see the FAQ on:
For additional information on how to submit fixes, see the FAQs on:
* [How to submit a fix](../faq.html#fix_an_entry) - how to submit a fix to an entry
* [Update author information](../faq.html#fix_author) - how to correct or update an IOCCC author's information
2024/burton/.entry.json
+3 -3
View File
@@ -41,7 +41,7 @@
"file_path" : "deobfuscated.html",
"inventory_order" : 100,
"OK_to_edit" : false,
"display_as" : "markdown",
"display_as" : "html",
"display_via_github" : true,
"entry_text" : "about deobfuscation"
},
@@ -57,8 +57,8 @@
"file_path" : "extra.html",
"inventory_order" : 100,
"OK_to_edit" : false,
"display_as" : "markdown",
"display_via_github" : true,
"display_as" : "html",
"display_via_github" : false,
"entry_text" : "description of the extra files"
},
{
2024/burton/index.html
+1 -1
View File
@@ -881,7 +881,7 @@ due to the omissions noted above, but I am unaware of these.</p>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/prog.orig.c">prog.orig.c</a> - original source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/deobfuscated.html">deobfuscated.html</a> - about deobfuscation</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/dict">dict</a> - 5-letter wordle dictionary</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/extra.html">extra.html</a> - description of the extra files</li>
<li><a href="extra.html">extra.html</a> - description of the extra files</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/reveal.c">reveal.c</a> - reveal wordle hints</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/try.sh">try.sh</a> - script to try entry</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/burton/deobfuscated.c">deobfuscated.c</a> - deobfuscated source code</li>
2024/ferguson1/.entry.json
+22 -6
View File
@@ -37,6 +37,14 @@
"display_via_github" : true,
"entry_text" : "alternate source code"
},
{
"file_path" : "prog.goto.max.c",
"inventory_order" : 40,
"OK_to_edit" : true,
"display_as" : "c",
"display_via_github" : true,
"entry_text" : "entry source code with maxed out gotos"
},
{
"file_path" : "prog.orig.c",
"inventory_order" : 50,
@@ -97,17 +105,25 @@
"file_path" : "deobfuscation.html",
"inventory_order" : 100,
"OK_to_edit" : false,
"display_as" : "markdown",
"display_via_github" : true,
"display_as" : "html",
"display_via_github" : false,
"entry_text" : "hints on how to deobfuscate"
},
{
"file_path" : "gotos.txt",
"file_path" : "gotos.c.txt",
"inventory_order" : 100,
"OK_to_edit" : true,
"display_as" : "text",
"display_via_github" : true,
"entry_text" : "text file showing all the line changes in a run"
"entry_text" : "text file showing only the gotos in the entry code"
},
{
"file_path" : "jumps.txt",
"inventory_order" : 100,
"OK_to_edit" : true,
"display_as" : "text",
"display_via_github" : true,
"entry_text" : "text file showing all the line changes in a single run"
},
{
"file_path" : "lencount.c",
@@ -129,8 +145,8 @@
"file_path" : "obfuscation.html",
"inventory_order" : 100,
"OK_to_edit" : false,
"display_as" : "markdown",
"display_via_github" : true,
"display_as" : "html",
"display_via_github" : false,
"entry_text" : "obfuscation information"
},
{
2024/ferguson1/.gitignore
+3
View File
@@ -20,4 +20,7 @@ printer
prog.alt.asc
prog.alt.scrnshot
prog.asc
prog.goto.max
prog.goto.max.asc
prog.goto.max.scrnshot
prog.scrnshot
2024/ferguson1/Makefile
+22 -2
View File
@@ -154,8 +154,10 @@ TARGET= ${PROG} ${PROG}.asc ${PROG}.scrnshot
# .alt is as above more events
#
ALT_OBJ= ${PROG}.alt.o ${PROG}.alt.asc.o ${PROG}.alt.scrnshot.o
ALT_TARGET= ${PROG}.alt ${PROG}.alt.asc ${PROG}.alt.scrnshot
ALT_OBJ= ${PROG}.alt.o ${PROG}.alt.asc.o ${PROG}.alt.scrnshot.o ${PROG}.goto.max.o \
${PROG}.goto.max.asc.o ${PROG}.goto.max.scrnshot.o
ALT_TARGET= ${PROG}.alt ${PROG}.alt.asc ${PROG}.alt.scrnshot ${PROG}.goto.max \
${PROG}.goto.max.asc ${PROG}.goto.max.scrnshot
# list any data files supplied with the submission
#
@@ -350,12 +352,30 @@ ${PROG}.alt.asc: ${PROG}.alt.c
${MAKE} padding
${CC} ${CFLAGS} -DDATA='"data.asc"' ${PROG}.alt.c -o $@ ${LDFLAGS}
# goto maxed out - regular data file
#
${PROG}.goto.max: ${PROG}.goto.max.c
${MAKE} padding
${CC} ${CFLAGS} -DDATA='"data"' ${PROG}.goto.max.c -o $@ ${LDFLAGS}
# goto maxed out - ASCII only data file
#
${PROG}.goto.max.asc: ${PROG}.goto.max.c
${MAKE} padding
${CC} ${CFLAGS} -DDATA='"data.asc"' ${PROG}.goto.max.c -o $@ ${LDFLAGS}
# screenshot friendly version of alt code
#
${PROG}.alt.scrnshot: ${PROG}.alt.c
${MAKE} padding
${CC} ${CFLAGS} -DDATA='"data.scrnshot"' ${PROG}.alt.c -o $@ ${LDFLAGS}
# goto maxed out - screenshot friendly version
#
${PROG}.goto.max.scrnshot: ${PROG}.goto.max.c
${MAKE} padding
${CC} ${CFLAGS} -DDATA='"data.scrnshot"' ${PROG}.goto.max.c -o $@ ${LDFLAGS}
# data files
#
data: ${DATA}
2024/ferguson1/README.md
+42 -27
View File
@@ -56,10 +56,11 @@ inside this C code. :-)
> Fun fact: after winning this, the author played the game in gdb from start to
finish and not counting macros but counting all function calls (not libc
functions just the few functions in prog.c), there were a total of **985** (!)
line jumps. The prog.c, counting `#include`s, `#define`s, functions and some
lines that have only braces, as well as 14 blank lines, has only 85 lines. A
very tiny fraction of the time a line might be repeated in a row ONCE but that
does not really matter.
line jumps. Skipping prog.c function calls and it's still **776** jumps! The
prog.c, if you remove `#include`s, blank lines, lines with just a brace and
lines that have only variables, has only 59 lines of code. A very tiny fraction
of the time a line might be repeated in a row ONCE but that does not really
matter.
**NOTE**: I actually submitted two versions. This one is not encrypted. The
encrypted one even encrypted emojis without having to decrypt them in order to
@@ -2454,11 +2455,15 @@ really does not seem to be dead (it's quite sneaky).
I could be wrong on whether this is one the compiler missed though: it's hard to
follow all the `goto`s. As you find out in [obfuscation.html](obfuscation.html) it's
134 after pre-processing! Yes I might be mad. But then again I might just be
the Devil. Who knows? What I do know is code that is meant to be reached is
reached! Yes I've played it many times. Some code I made dead seemed totally
useless but why not add to confusion? If that includes one that the compiler
misses that's even better!
134 after pre-processing! One of the alt versions I supplied is 131 before the
cpp and 149 after. I did not submit that for practical reasons but I kind of
wish I had, now that it won. Nonetheless 134 is already way too many. 149 is
much worse.
Yes I might be mad. But then again I might just be the Devil. Who knows? What I
do know is code that is meant to be reached is reached! Yes I've played it many
times. Some code I made dead seemed totally useless but why not add to
confusion? If that includes one that the compiler misses that's even better!
It is **NOT** a bug where in the inner switch there is a missing case. That is
done because I do not want it to always trigger. That is the one that is in a
@@ -3016,7 +3021,12 @@ In general I think it's extremely hard to follow the flow of this program due to
the abuse of 116 `goto`s, more than the BASIC game. 134 when pre-processed. But
let's be honest, or 134 for a small C program is too many but to be only six
fewer than a larger BASIC program? That is hard to fathom. Not that 116 is not
too many for larger programs...or one goto, for that matter.
too many for larger programs...or one goto, for that matter. As noted elsewhere,
an alt version has 131/149 gotos, before/after the cpp. I did not make it the
main version when submitting because I did not want to make the judges weep and
curse any more than they already had to (besides, it can't be 4666 bytes with
the extra `goto`s) but now that it's in I have no qualms about providing it as
alt code: if I am going to ruin `goto`s I might as well do it properly.
Some things are clear about the program from visual inspection:
@@ -3256,18 +3266,21 @@ Except on the Oregon Trail.
I was right too: the entire game is worse, far far worse. After this won I did a
full sequence. This is from start to finish and I include it for your amusement
(see [gotos.txt](gotos.txt)). Or horror. There are a few times where the line
(see [jumps.txt](jumps.txt) for the line changes including calls to prog.c
functions). Or horror. There are a few times where the line
is the same but that only shows how very often the line changes. It is a total
of **985** (!) changes, counting function calls (i.e. each call to one of the few
functions is a jump); calls to the macros are not counted.
of **985** (!) changes, counting function calls, and **776** (!) excluding
function calls. Macros are not counted of course.
This is in a program that is **JUST 85 (!) lines**! A program that has only 85 lines
COUNTING the `#include`s, `#define`s, other functions and 14 blank lines that
jumps 985 times is astonishing. Of course that's not the only technique but the
title of the award and the judges' remarks are rather fitting as it is
diabolical to follow this code (and the theme of the game fits as well); the
[obfuscation.html](obfuscation.html) shows even more on this - and the other
things I did as well.
This program, if you remove blank lines and lines with just a brace,
`#include`s and only variables, has a mere 59 (!) lines.
A program that has only 59 lines of code that jumps 985 (counting functions) or
776 (just in main()) times is astonishing. Of course that's not the
only technique but the title of the award and the judges' remarks are rather
fitting as it is diabolical to follow this code (and the theme of the game fits
as well); the [obfuscation.html](obfuscation.html) shows even more on this - and
the other things I did as well.
> I have yet to see a single study that supported the supposition that GOTOs are
harmful (I presume this is not because nobody has tried). Nonetheless, people
@@ -3280,16 +3293,17 @@ said was missing. And it was about time. Not that it didn't happen before. But
he was wrong.
It is not about not trying. But even IF he WAS right, he
sure as hell is WRONG NOW. Anyone who thinks otherwise needs to try and debug
sure as hell is wrong NOW. Anyone who thinks otherwise needs to try and debug
my program - or maintain it. Or write it.
It would have been SO MUCH EASIER if I did not use 134 `goto`s. Actually, even a
It would have been SO MUCH EASIER if I did not use 134 `goto`s (and I could have
fit more in). Actually, even a
tiny portion of that would make it harder. Nobody, whether they're in their
right mind or not, would WANT to maintain this, or something even close to it.
Feel free to pass on judgement to me. I welcome it! You have to be mad and
embrace it to do this. I went full out and if I didn't have to do other things
(or felt like fewer events would be worth it) I would have done even more
`goto`s for this very reason.
embrace it to do this. I went full out and I could have fit more `goto`s in: not
only is the iocccsize not 2503 but I could have removed some events if I really
wanted more `goto`s.
Even flex/bison code, which as far as I am aware uses FAR fewer `goto`s, is
notorious for `goto`s and is quite hard to follow. It would be a nightmare to
@@ -3421,9 +3435,10 @@ the degree I have taken it in this program, it demonstrates why you should avoid
No matter how many you have, UNLESS IT'S 0, it makes it hard to maintain and
ensure that the code is correct. So how did I actually manage doing exactly
that? Very carefully - and I nearly lost my mind doing it. I will not make any
judgement on anyone else who uses them.
judgement on anyone else who uses them, although I will talk about the notion
that they aren't harmful, mostly to show just how extreme this program went.
Anyway, I am even reminded of Apple's **SINGLE** misplaced `goto` that caused a
Anyway, I am reminded of Apple's **SINGLE** misplaced `goto` that caused a
**SECURITY HOLE** (CVE-2014-1266):
<https://www.blackduck.com/blog/understanding-apple-goto-fail-vulnerability-2.html>.
That's all it takes: **JUST ONE `goto` led to a CVE**!
2024/ferguson1/gotos.c.txt
+134
View File
@@ -0,0 +1,134 @@
goto A;
goto f;
goto PP;
goto hell;
goto M;
goto hell;
goto M;
goto G;
goto hell;
goto M;
goto hell;
goto M;
goto S;
goto hell;
goto M;
goto OO;
goto L;
goto i;
goto kk;
goto HA;
goto at;
goto I;
goto r;
goto II;
goto F;
goto c;
goto zz;
goto qq;
goto C;
goto N;
goto dd;
goto jj;
goto oo;
goto ee;
goto x;
goto heaven;
goto XT;
goto ET;
goto v;
goto x;
goto v;
goto ZZ;
goto bb;
goto s;
goto X;
goto v;
goto T;
goto y;
goto E;
goto d;
goto P;
goto to;
goto y;
goto TA;
goto BB;
goto LL;
goto uu;
goto JJ;
goto B;
goto h;
goto l;
goto e;
goto hell;
goto M;
goto Y;
goto P;
goto K;
goto tt;
goto Z;
goto W;
goto ha;
goto D;
goto m;
goto Z;
goto H;
goto Z;
goto g;
goto Z;
goto Z;
goto Z;
goto Y;
goto MM;
goto hell;
goto M;
goto J;
goto Q;
goto k;
goto W;
goto hell;
goto M;
goto q;
goto TT;
goto P;
goto U;
goto hell;
goto M;
goto QQ;
goto KK;
goto z;
goto k;
goto k;
goto k;
goto hell;
goto M;
goto M;
goto yy;
goto Z;
goto rr;
goto hell;
goto M;
goto a;
goto Z;
goto Z;
goto Z;
goto go;
goto ii;
goto o;
goto V;
goto Z;
goto Y;
goto O;
goto W;
goto b;
goto n;
goto p;
goto x;
goto j;
goto n;
goto R;
goto t;
goto n;
goto u;
goto w;
goto _;
2024/ferguson1/index.html
+45 -30
View File
@@ -499,10 +499,11 @@ inside this C code. :-)</p>
<p>Fun fact: after winning this, the author played the game in gdb from start to
finish and not counting macros but counting all function calls (not libc
functions just the few functions in prog.c), there were a total of <strong>985</strong> (!)
line jumps. The prog.c, counting <code>#include</code>s, <code>#define</code>s, functions and some
lines that have only braces, as well as 14 blank lines, has only 85 lines. A
very tiny fraction of the time a line might be repeated in a row ONCE but that
does not really matter.</p>
line jumps. Skipping prog.c function calls and it’s still <strong>776</strong> jumps! The
prog.c, if you remove <code>#include</code>s, blank lines, lines with just a brace and
lines that have only variables, has only 59 lines of code. A very tiny fraction
of the time a line might be repeated in a row ONCE but that does not really
matter.</p>
</blockquote>
<p><strong>NOTE</strong>: I actually submitted two versions. This one is not encrypted. The
encrypted one even encrypted emojis without having to decrypt them in order to
@@ -2449,11 +2450,14 @@ might be one that the compiler does not trigger a dead code warning on. It
really does not seem to be dead (it’s quite sneaky).</p>
<p>I could be wrong on whether this is one the compiler missed though: it’s hard to
follow all the <code>goto</code>s. As you find out in <a href="obfuscation.html">obfuscation.html</a> it’s
134 after pre-processing! Yes I might be mad. But then again I might just be
the Devil. Who knows? What I do know is code that is meant to be reached is
reached! Yes I’ve played it many times. Some code I made dead seemed totally
useless but why not add to confusion? If that includes one that the compiler
misses that’s even better!</p>
134 after pre-processing! One of the alt versions I supplied is 131 before the
cpp and 149 after. I did not submit that for practical reasons but I kind of
wish I had, now that it won. Nonetheless 134 is already way too many. 149 is
much worse.</p>
<p>Yes I might be mad. But then again I might just be the Devil. Who knows? What I
do know is code that is meant to be reached is reached! Yes I’ve played it many
times. Some code I made dead seemed totally useless but why not add to
confusion? If that includes one that the compiler misses that’s even better!</p>
<p>It is <strong>NOT</strong> a bug where in the inner switch there is a missing case. That is
done because I do not want it to always trigger. That is the one that is in a
sense polymorphic. One of the events is actually immediate death, in particular
@@ -2896,7 +2900,12 @@ I mentioned in <a href="obfuscation.html">obfuscation.html</a> (and some briefly
the abuse of 116 <code>goto</code>s, more than the BASIC game. 134 when pre-processed. But
let’s be honest, or 134 for a small C program is too many but to be only six
fewer than a larger BASIC program? That is hard to fathom. Not that 116 is not
too many for larger programs…or one goto, for that matter.</p>
too many for larger programs…or one goto, for that matter. As noted elsewhere,
an alt version has 131/149 gotos, before/after the cpp. I did not make it the
main version when submitting because I did not want to make the judges weep and
curse any more than they already had to (besides, it can’t be 4666 bytes with
the extra <code>goto</code>s) but now that it’s in I have no qualms about providing it as
alt code: if I am going to ruin <code>goto</code>s I might as well do it properly.</p>
<p>Some things are clear about the program from visual inspection:</p>
<ul>
<li>it is clear the program does print SOME THINGS (but it is <strong>NOT clear WHAT</strong>
@@ -3090,17 +3099,19 @@ I’m a dragon. I’m not a dragon. I have a secret for you: dragons don’t exi
Except on the Oregon Trail.</p>
<p>I was right too: the entire game is worse, far far worse. After this won I did a
full sequence. This is from start to finish and I include it for your amusement
(see <a href="gotos.txt">gotos.txt</a>). Or horror. There are a few times where the line
(see <a href="jumps.txt">jumps.txt</a> for the line changes including calls to prog.c
functions). Or horror. There are a few times where the line
is the same but that only shows how very often the line changes. It is a total
of <strong>985</strong> (!) changes, counting function calls (i.e. each call to one of the few
functions is a jump); calls to the macros are not counted.</p>
<p>This is in a program that is <strong>JUST 85 (!) lines</strong>! A program that has only 85 lines
COUNTING the <code>#include</code>s, <code>#define</code>s, other functions and 14 blank lines that
jumps 985 times is astonishing. Of course that’s not the only technique but the
title of the award and the judges’ remarks are rather fitting as it is
diabolical to follow this code (and the theme of the game fits as well); the
<a href="obfuscation.html">obfuscation.html</a> shows even more on this - and the other
things I did as well.</p>
of <strong>985</strong> (!) changes, counting function calls, and <strong>776</strong> (!) excluding
function calls. Macros are not counted of course.</p>
<p>This program, if you remove blank lines and lines with just a brace,
<code>#include</code>s and only variables, has a mere 59 (!) lines.</p>
<p>A program that has only 59 lines of code that jumps 985 (counting functions) or
776 (just in main()) times is astonishing. Of course that’s not the
only technique but the title of the award and the judges’ remarks are rather
fitting as it is diabolical to follow this code (and the theme of the game fits
as well); the <a href="obfuscation.html">obfuscation.html</a> shows even more on this - and
the other things I did as well.</p>
<blockquote>
<p>I have yet to see a single study that supported the supposition that GOTOs are
harmful (I presume this is not because nobody has tried). Nonetheless, people
@@ -3112,15 +3123,16 @@ dismiss any statement opposing it.</p>
said was missing. And it was about time. Not that it didn’t happen before. But
he was wrong.</p>
<p>It is not about not trying. But even IF he WAS right, he
sure as hell is WRONG NOW. Anyone who thinks otherwise needs to try and debug
sure as hell is wrong NOW. Anyone who thinks otherwise needs to try and debug
my program - or maintain it. Or write it.</p>
<p>It would have been SO MUCH EASIER if I did not use 134 <code>goto</code>s. Actually, even a
<p>It would have been SO MUCH EASIER if I did not use 134 <code>goto</code>s (and I could have
fit more in). Actually, even a
tiny portion of that would make it harder. Nobody, whether they’re in their
right mind or not, would WANT to maintain this, or something even close to it.
Feel free to pass on judgement to me. I welcome it! You have to be mad and
embrace it to do this. I went full out and if I didn’t have to do other things
(or felt like fewer events would be worth it) I would have done even more
<code>goto</code>s for this very reason.</p>
embrace it to do this. I went full out and I could have fit more <code>goto</code>s in: not
only is the iocccsize not 2503 but I could have removed some events if I really
wanted more <code>goto</code>s.</p>
<p>Even flex/bison code, which as far as I am aware uses FAR fewer <code>goto</code>s, is
notorious for <code>goto</code>s and is quite hard to follow. It would be a nightmare to
try and maintain without the .l/.y source files.</p>
@@ -3228,8 +3240,9 @@ the degree I have taken it in this program, it demonstrates why you should avoid
<p>No matter how many you have, UNLESS IT’S 0, it makes it hard to maintain and
ensure that the code is correct. So how did I actually manage doing exactly
that? Very carefully - and I nearly lost my mind doing it. I will not make any
judgement on anyone else who uses them.</p>
<p>Anyway, I am even reminded of Apple’s <strong>SINGLE</strong> misplaced <code>goto</code> that caused a
judgement on anyone else who uses them, although I will talk about the notion
that they aren’t harmful, mostly to show just how extreme this program went.</p>
<p>Anyway, I am reminded of Apple’s <strong>SINGLE</strong> misplaced <code>goto</code> that caused a
<strong>SECURITY HOLE</strong> (CVE-2014-1266):
<a href="https://www.blackduck.com/blog/understanding-apple-goto-fail-vulnerability-2.html" class="uri">https://www.blackduck.com/blog/understanding-apple-goto-fail-vulnerability-2.html</a>.
That’s all it takes: <strong>JUST ONE <code>goto</code> led to a CVE</strong>!</p>
@@ -3703,6 +3716,7 @@ helps you appreciate the careful design even more.<a href="#fnref2" class="footn
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/prog.c">prog.c</a> - entry source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/Makefile">Makefile</a> - entry Makefile</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/prog.alt.c">prog.alt.c</a> - alternate source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/prog.goto.max.c">prog.goto.max.c</a> - entry source code with maxed out gotos</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/prog.orig.c">prog.orig.c</a> - original source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/commented.c">commented.c</a> - commented version of the game</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/addpadding.c">addpadding.c</a> - add padding from data source files</li>
@@ -3710,11 +3724,12 @@ helps you appreciate the careful design even more.<a href="#fnref2" class="footn
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/bytecount.c">bytecount.c</a> - print each string with locations</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/byteread.c">byteread.c</a> - prints out the strings without locations</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/bytetest.c">bytetest.c</a> - prints every string extracted from data</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/deobfuscation.html">deobfuscation.html</a> - hints on how to deobfuscate</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/gotos.txt">gotos.txt</a> - text file showing all the line changes in a run</li>
<li><a href="deobfuscation.html">deobfuscation.html</a> - hints on how to deobfuscate</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/gotos.c.txt">gotos.c.txt</a> - text file showing only the gotos in the entry code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/jumps.txt">jumps.txt</a> - text file showing all the line changes in a single run</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/lencount.c">lencount.c</a> - counts strings and reports longest one</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/mbcheck.c">mbcheck.c</a> - show location of multibyte characters</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/obfuscation.html">obfuscation.html</a> - obfuscation information</li>
<li><a href="obfuscation.html">obfuscation.html</a> - obfuscation information</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/printer.c">printer.c</a> - prints strings like the game does</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/try.sh">try.sh</a> - script to try entry</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/ferguson1/devil.png">devil.png</a> - Devil driving wagon</li>
2024/ferguson1/gotos.txt → 2024/ferguson1/jumps.txt
View File
File renamed without changes.
2024/ferguson1/obfuscation.html
+13 -10
View File
@@ -496,7 +496,10 @@ too many, even in a large program, let alone a small one. Even one <code>goto</c
many. Unless I am very much mistaken, I have broken the record by a huge margin.</p>
<p>Here’s the horrifying and hilarious truth: I beat it out by 92 MORE, <strong>BEFORE</strong> the
cpp at 116 and after the cpp is through I beat it by <strong>110</strong> MORE (!!), <strong>AT
134!</strong> Yes, you read that right. 134 <code>goto</code>s!</p>
134!</strong> Yes, you read that right. 134 <code>goto</code>s! I even went further in an alt
version, where before the cpp it was 131 <code>goto</code>s and after the cpp 149 (!!)
<code>goto</code>s. I didn’t do this in the main entry for practical reasons but I wish I
had.</p>
<p>Even removing what I think are the only dead <code>goto</code>s, two of them, including one
that is in the <code>w()</code> macro that would be translated into more, I beat it by 90
more, at 114 before the cpp, and 99 more after the cpp, at 123!</p>
@@ -510,16 +513,16 @@ YES I think it’s HILARIOUS. But if it was not for the IOCCC… Well, as I
mention in my <a href="#devil">remarks above</a>, EVEN ONE IS TOO MANY
in real code.</p>
<p>I dare you to run the program in a debugger from start to finish to see how many
line jumps there truly are. After I won I did it once: in a program with just 85
lines (14 blank, some with just a brace, <code>#include</code>s, <code>#define</code>s included) there
were a total of 985 line changes (a tiny tiny fraction had the same line number
repeated once). I rarely went to the fort and I only hunted once (I might not
have hunted at all). This is obscene.</p>
line jumps there truly are. After I won I did it once: removing the <code>#include</code>s,
blank lines, lines with only variables and lines with just braces (i.e. only
lines of code) the program has just 59 lines and in a single run there were a
total of <strong>985</strong> (!) line changes, counting function calls. In <code>main()</code> itself
the line changed a total of <strong>776</strong> (!) times!</p>
<p>The best (or worst, depending on how you look at it :-) ) part is this works. As
I note in those concluding remarks, a company actually introduced a security
hole from ONE <code>goto</code>. Yet I have 116/134 and it actually works? That is surely
obscene. And beautiful.</p>
<p>Oh and BTW: it appears that <code>hines</code> is a bit confused about my submission,
I note in those concluding remarks, a <a href="https://www.apple.com">famous company</a>
actually introduced a security hole from ONE <code>goto</code>. Yet I have 116/134 and it
actually works? That is surely obscene. And beautiful.</p>
<p>Oh and BTW: it appears that <code>hines</code> is a bit confused about my entry,
though I’m not really sure why. In any case, I not only have dethroned <code>hines</code>
(sorry …but also not sorry!) but I have, as noted already, beaten the original
BASIC game by <strong>7</strong> more <code>goto</code>s at 116 before the cpp and <strong>25 MORE</strong> after the
2024/ferguson1/obfuscation.md
+13 -10
View File
@@ -50,7 +50,10 @@ many. Unless I am very much mistaken, I have broken the record by a huge margin.
Here's the horrifying and hilarious truth: I beat it out by 92 MORE, **BEFORE** the
cpp at 116 and after the cpp is through I beat it by **110** MORE (!!), **AT
134!** Yes, you read that right. 134 `goto`s!
134!** Yes, you read that right. 134 `goto`s! I even went further in an alt
version, where before the cpp it was 131 `goto`s and after the cpp 149 (!!)
`goto`s. I didn't do this in the main entry for practical reasons but I wish I
had.
Even removing what I think are the only dead `goto`s, two of them, including one
that is in the `w()` macro that would be translated into more, I beat it by 90
@@ -68,18 +71,18 @@ mention in my [remarks above](#devil), EVEN ONE IS TOO MANY
in real code.
I dare you to run the program in a debugger from start to finish to see how many
line jumps there truly are. After I won I did it once: in a program with just 85
lines (14 blank, some with just a brace, `#include`s, `#define`s included) there
were a total of 985 line changes (a tiny tiny fraction had the same line number
repeated once). I rarely went to the fort and I only hunted once (I might not
have hunted at all). This is obscene.
line jumps there truly are. After I won I did it once: removing the `#include`s,
blank lines, lines with only variables and lines with just braces (i.e. only
lines of code) the program has just 59 lines and in a single run there were a
total of **985** (!) line changes, counting function calls. In `main()` itself
the line changed a total of **776** (!) times!
The best (or worst, depending on how you look at it :-) ) part is this works. As
I note in those concluding remarks, a company actually introduced a security
hole from ONE `goto`. Yet I have 116/134 and it actually works? That is surely
obscene. And beautiful.
I note in those concluding remarks, a [famous company](https://www.apple.com)
actually introduced a security hole from ONE `goto`. Yet I have 116/134 and it
actually works? That is surely obscene. And beautiful.
Oh and BTW: it appears that `hines` is a bit confused about my submission,
Oh and BTW: it appears that `hines` is a bit confused about my entry,
though I'm not really sure why. In any case, I not only have dethroned `hines`
(sorry ...but also not sorry!) but I have, as noted already, beaten the original
BASIC game by **7** more `goto`s at 116 before the cpp and **25 MORE** after the
2024/ferguson1/prog.goto.max.c
+85
View File
@@ -0,0 +1,85 @@
#include<stdio.h>
#include<string.h>
#include<time.h>
#include<stdlib.h>
#include<unistd.h>
long x(long y, long z){ return rand()%(z-y+1)+y; }
unsigned m,D,Q,v,l,f,X,z,B,i,h,
r,u,d,e; long
O,R,E,G,O,N, T,R,A,I,L,
*o[]={ &O,&R,&E,&G,&O,&N} ,a,t[7],q,M, b=666,c,W;
char *y,*p; FILE*K; size_t J;
#define w(i) { V(i); V(4); goto hell; goto M; }
long Z(long x){ return x * 1663; }
#define S(x,z) while(scanf(&y[Z(x)],&z)!=1)while(getchar()!='\n');
void V(long x){ printf("%s",&y[Z(x)]); }
long k() { return E>0?x(0,99)>49:0; } int main() {
switch(1)
{ j:if(z)goto A; E*=5; B:
printf(&y[Z(12)],T); if(z) { goto f; } goto PP; default: srand(time(0));
K=fopen(DATA,"r"); if(!K||getdelim(&y,&J,EOF,K)<0)
goto hell; goto M; OO: if(b<1) { if(a){ w(40) PP: goto G; } if(f) w(41) w(45) g:goto S; } w(M>2169?47:45)
hell:
return
666; rr:;
goto CC; yy:
{ if(b<1||M<0||M>2169){ goto _; F:V(51); R+=18; goto L; } goto i;
P:for(X=1; X<--(unsigned){ 7 } ; ){ goto kk; BB:*o[X]+=(X==2?t[X]*5:t[X]); goto HA; TA:++X; goto at; ZZ:; }
printf(&y[Z(11)],R,E,G,O,N,T,b,M); if(x(0,1))goto I; R:if(R<14)V(37); if(z) { z=0; l: { if (k()) { if (x(0,9) > 4) { V(52);
R+=23; if(!x(0,9)){ goto r; L: goto II; } c:; } else{ goto F; r: goto c; qq: { V(53); goto zz; } II:; } } else { goto qq; } zz: E-=9; M-=45; } goto C; y:V(42); S(2,r) switch(r) { M:V(1); v:memset(&t,0,sizeof t); goto
N; D:{ if (k()) { goto dd; ii:V(f=79); b -= 80; T/=4; goto jj; ee:; } else { goto oo; dd:V(a=29); T+=70; goto ee; x:V(X+--(
unsigned){ 6 } ); if(z){ S(3,
t[X])if(t[X]<0||t[X]>
666 ){ V(14); goto x; goto
heaven ; ET:L-=t[u]; goto XT; } L=T; for(u
=0; u < 6; ++u){ goto ET; XT:; }
if(L<0){ V(46); memset(&t,0,
sizeof t); goto v; } }
else{ S(3 ,*(o[X])) if(
*o[X]<0||*o[X] >
666) { V(14);
goto x; } T=1666-O-R-E-G-0-N; if(T<0){ V(46); O=R=E=G=N=0; goto v; LL:*o[X]=0; uu:++X; goto ZZ; } } goto bb; } } goto s; case 3: goto X; case 1:z=1; M-=45; goto v;
case 2:goto T; } goto y;
O:{ V(e = 19); O -= 40; R+=40; } goto E; i:if(O<1){ goto d; } else { goto vv; mm:; } goto P; go: V(81); R+=9; N+=3; goto to;
} else{ goto y; HA:T-=X[t]; goto TA; A:for(X=1; X < 6; ){ goto BB; kk:if (*o[X]<0) goto LL; goto uu; QQ:V(B=38); goto JJ; at:; } goto B;
} T:l=1; if (E<9){ goto h; } else { goto l; h: V(16); goto C; DD: goto u; } C: l=0; f:z=0;
X:if(R<1){ goto e; U: w(24) K:R-=R
>23?23:R>18? 18 : R > 13 ? 13 :
R; goto Y; TT:V(v=15); O=0; goto P; } else { goto K; } goto tt; Y:switch(q=x(0,23))
{ case 1:V(95); R+=5; goto Z; case 18:V(26); goto Z; case 13:V(28); goto Z;
case 2:O-=40; V(71); goto Z; case 3:V(a=76); b-=70; goto W; case 4:V(77); N-=7; M-=7; goto Z; case 5:case
10:if(q<6) { goto ha; m: V(56); goto D; CC: goto OO; o:; } else
{ goto m; oo:V(f=62); M-=50; b-=35; s:; } goto Z; a:goto H;
case 9:case 19:V(30); goto Z; case 20:V(32); goto Z; case 21 :V(31); goto Z; case 6:goto g; case 16: case 22:V(49); goto Z; case 17:V(72); goto Z;
case 7:V(83); M-=10; goto Z; case 8:V(86); R-=30; G-=20; O-=40; V
:switch(x(1,9)){ case 2:if(q>9){ switch(x(1,2)){ q:R+=40; goto Y; case 1:{ switch (x(2,5)) { case 2:V(a=54); goto
MM; b:w(48)
case 3:goto J; N:goto Q; case 4:i=17; } } case 2: V(5); } goto k; u: if(M<1951||W){ goto
W; } W=1;
if(!d&&!x(0,4)){ V(75); d=1; R+= 50; }
if(!x(0,3)){ w(x(0,4)?84:x(0,4)?33:34) e:if(O>39){ goto xx; vv:v=0; goto mm; d:{ if(!v)goto TT; goto P; } } goto U; } if (x(0,9) < 5) w:V(35); c=1; M-=101; ++E; k: M-=10; W: if(x(0,1)){ if (d) V(39); if(e)V(25); } while(i)heaven:{ w(i) } if (!B&&(f||
a)){ if(d&&a) V(91); if(T<666){ goto QQ; KK:Q=a?1:Q; h=f?1:h; f=a=0; V(93); T-=666; } else{ goto KK; } JJ:; } b-=f?15
:h?5:0; b-=a?5:Q?15:0; M+=170; M+=O> 99 ? 30:- 99;
b-=10; goto z; J: V(a=54); } goto k; MM
:goto k; default: if(q>10) { goto k; } if(q>7) { if(N<5) { w(99) goto M; G:goto yy; } V(13); N-=5; } goto Z; _:goto rr; S:if (E>1999){ w(27) I:goto a; } V(82); M-=9; N-=5; R-=20; goto Z;
} M-=17; goto Z; case 14: V(74); goto Z; case 15: V(x(0,1)?69:68);
goto Z; ha:V(78); if(k()){ goto go; to:; } else { goto ii; jj:; } goto o; case 11: goto V; case
12:V(94); M-=5; b-=19; N -= 5; goto Z; tt: goto Y; case 0:V(20); Z:; } if(O>39&&!x(0,9)){goto O; xx: V(e=x(0,1)?18:19); O -= 40; goto q; } E: if(M<951) goto W; if (G < 36){ goto b; } if (x(0,9) > 2) goto n; V(96); if (x(0,1)) { goto p; Q: for (X=
1; X < 6; ++X) { goto x; bb:; } goto j; } V(97); M-= 60; goto n; H:goto R; p: if (x(0,9)<3) goto t; V(21); M -=99;
goto n; t: V(22); M -= 85; n:if(m){ goto DD; } m=1; if (x(0,9) > 5) goto w; V(23); z:; } if (A++<21) goto yy; goto _;
}
}
2024/howe/.entry.json
+2 -2
View File
@@ -41,8 +41,8 @@
"file_path" : "prog.html",
"inventory_order" : 100,
"OK_to_edit" : false,
"display_as" : "markdown",
"display_via_github" : true,
"display_as" : "html",
"display_via_github" : false,
"entry_text" : "eh man page"
},
{
2024/howe/index.html
+1 -1
View File
@@ -572,7 +572,7 @@ Location: <a href="../../location.html#CA">CA</a> - <em>Canada</em></li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/prog.c">prog.c</a> - entry source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/Makefile">Makefile</a> - entry Makefile</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/prog.orig.c">prog.orig.c</a> - original source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/prog.html">prog.html</a> - eh man page</li>
<li><a href="prog.html">prog.html</a> - eh man page</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/try.sh">try.sh</a> - script to try entry</li>
</ul>
<h2 id="secondary-files">Secondary files</h2>
2024/index.html
+38 -29
View File
@@ -484,8 +484,14 @@ the <a href="https://github.com/ioccc-src/mkiocccentry">mkiocccentry toolkit</a>
</ul>
<p>On the last point, for <strong>IOCCC28</strong> the Judging started on <strong>2025-06-05 04:03:02.010099 UTC</strong> and then the winners were selected by the <a href="../judges.html">IOCCC Judges</a> on <strong>2025-07-07 20:05:07.000000 UTC</strong>:</p>
<ul>
<li><p>Winners were announced during a live the <a href="https://www.youtube.com/@OurFavoriteUniverse">Our Favorite Universe</a> YouTube Channel that started on <strong>2025-08-02 18:00:00.000000 UTC</strong></p></li>
<li><p>Near the end of the 2 hour XXX-add-show-URL-here-XXX YouTube show, the <strong>source code</strong> of the <a href="#inventory">IOCCC28 winning entries</a> was published on <a href="https://github.com/ioccc-src/winner">IOCCC GitHub winner repo</a> and on the <a href="../index.html">Official IOCCC website</a>.</p></li>
<li><p>Winners were announced during a live show that started on <strong>2025-08-02 18:00:00.000000 UTC</strong>
on the <a href="https://www.youtube.com/@OurFavoriteUniverse">Our Favorite Universe</a>
YouTube Channel.</p></li>
<li><p>At about 03h:42m:03s mark in the 04h:30m:35s <a href="https://www.youtube.com/live/UDzGwTalVAc">YouTube
show</a>, the <strong>source code</strong> of the
<a href="#inventory">IOCCC28 winning entries</a> was published on <a href="https://github.com/ioccc-src/winner">IOCCC GitHub winner
repo</a> and on the <a href="../index.html">Official IOCCC
website</a>.</p></li>
</ul>
<p><strong>No longer will there be many months</strong> between when the winners are
announced and their source code is made available. For <strong>IOCCC28</strong>
@@ -495,14 +501,14 @@ the time was <strong>less than 2 hours</strong>. :-)</p>
<strong>increased quantity and quality</strong> of the submissions. As a result the judging process for <strong>IOCCC28</strong>
was more challenging and required greater effort. Thankfully due to the above mentioned improvements,
the judging process <strong>took only 33 days</strong>. Under the previous system it <strong>would have taken much longer</strong>!</p>
<p>One thing that began to emerge after we exits the early rounds of judging and entered the middle rounds
<p>One thing that began to emerge after we exited the early rounds of judging and entered the middle rounds
of judging was that we were very likely to have more winning entries than in previous contests.
Even so, the final rounds of judging required more rounds and tool longer than in any previous IOCCC.</p>
Even so, the final rounds of judging required more rounds and took longer than any previous IOCCC.</p>
<p>At the end of the final round of the final rounds of judging, we had a record <strong>23 winners of IOCCC28</strong>,
eclipsing the record of 15 winners!</p>
<p>While we suspect that the 4 year gap between <strong>IOCCC27</strong> and <strong>IOCCC28</strong> allowed
people extra time to improve their submissions, we also believe that people
submitting to the IOCCC have become more adept in adept in obfuscation and have
submitting to the IOCCC have become more adept in obfuscation and have
become more skilled in the programming in the C language.</p>
<h3 id="code-size-and-rule-2">Code size and Rule 2</h3>
<p>We were pleased to observe that while the <a href="../faq.html#size_rule_history">IOCCC size limit</a>
@@ -515,11 +521,12 @@ small and medium sized submissions. Half of the <strong>IOCCC28 winners</strong>
was the first size increase in over 10 years. Given the quality of submissions we received
that were well under the limit, we do <strong>NOT</strong> expect to change the
<a href="../next/rules.html#rule2">Rule 2 size limit</a> for <strong>at least another 10 years</strong> (and likely longer).</p>
<p><strong>IMPORTANT HINT</strong>: Only 3 of 23 the <strong>IOCCC28 winners</strong> came close to the <a href="../next/rules.html#rule2">Rule 2 size limit</a>.
Large code size isn’t everything. :-) Those submitting to future contents should
<strong>take a careful note</strong> of that fact.</p>
<p><strong>IMPORTANT HINT</strong>: Only 3 of the 23 <strong>IOCCC28 winners</strong> came close to the <a href="../next/rules.html#rule2">Rule
2 size limit</a>. Large code size isn’t everything. :-)
Those submitting to future contents should <strong>take a careful note</strong> of that fact.</p>
<h3 id="rules-and-guidelines-for-this-contest">Rules and Guidelines for this contest</h3>
<p>Here are the final versions of the IOCCC rules and guidelines that were in effect for this contest:</p>
<p>Here are the final versions of the IOCCC rules and guidelines that were in
effect for this contest:</p>
<ul>
<li><a href="rules.html">2024 rules</a> version <strong>28.30 2025-03-03</strong></li>
<li><a href="guidelines.html">2024 guidelines</a> version <strong>28.47 2025-03-15</strong></li>
@@ -563,7 +570,7 @@ into the code’s obfuscation. :-)</p>
<li><a href="howe/index.html">2024/howe</a></li>
</ul>
<p>“<em>Eh</em>”? The source code, with its UTF-8 conforming accent gives you a
polite editor that is more functional an <code>ed(1)</code>.</p>
polite editor that is more functional than <code>ed(1)</code>.</p>
<p>We invite you to use the program to view the UTF-8 fun in the
<a href="https://github.com/ioccc-src/winner/blob/master/2024/howe/prog.c">2024/howe/prog.c source code</a>.</p>
<p><strong>HINT to emacs users</strong>: type <strong>Q</strong> or press <strong>CTRL+C</strong> to exit. 🤓</p>
@@ -582,7 +589,7 @@ different hex digits value. Then feed the MD5 hash of the
</ul>
<p>The <a href="https://github.com/ioccc-src/winner/blob/master/2024/endoh1/try.sh">2024/endoh1/try.sh</a> will carry you on
a journey that tests your patience as well as the patience of the C-preprocessor.</p>
<p>Building a 8x8 image requires order of 20 seconds of C-preprocessor
<p>Building a 8x8 image requires an order of 20 seconds of C-preprocessor
time, when running 6 jobs on 4 CPU cores in parallel. Unfortunately,
with such a tiny image, it is hard to appreciate the image being rendered.</p>
<p>So you might try building a 32x32 form of the image, invoking the
@@ -598,8 +605,8 @@ the C-preprocessor 262144 times over a period of about 23.5 hours, you
will be given an image with a reasonable amount of detail to appreciate
what is being rendered.</p>
<p>One fun aspect of the <a href="https://github.com/ioccc-src/winner/blob/master/2024/endoh1/prog.c">2024/endoh1/prog.c source code</a>
is that when it is compiled an executed, the program outputs C code.
That C code, call it <code>rt.c</code> will fail to compile! But that is OK because the C-preprocessor
is that when it is compiled and executed, the program outputs C code.
That C code, called <code>rt.c</code>, will fail to compile! But that is OK because the C-preprocessor
has enough work to do without bothering the C compiler. :-)</p>
<p>We plan to recognise those who report that they <a href="endoh1/index.html#larger">rendered a new record sized image</a>.</p>
<ul>
@@ -615,7 +622,7 @@ we suggest you compile and run the program for more information.</p>
the “<em>double-struck Z</em>” is <strong>NOT</strong> a reference to a set of integers,
nor is the “<em>double-struck Z subscript 3</em>” a reference to a ring of
3-adic integers. Instead, it is a reference to the 3rd version of a
certain <a href="https://en.wikipedia.org/wiki/Z-machine">virtual machine</a>.</p>
<a href="https://en.wikipedia.org/wiki/Z-machine">certain virtual machine</a>.</p>
<p>If you use the <a href="https://github.com/ioccc-src/winner/blob/master/2024/mills/try.sh">2024/mills/try.sh</a> script, you will first be given
an opportunity to view the <a href="https://github.com/ioccc-src/winner/blob/master/2024/mills/prog.c">2024/mills/prog.c source code</a>.
Then you will be given 10 choices to play.</p>
@@ -626,7 +633,7 @@ reading/navigating the twisty mazes of this source code! :-)</p>
</ul>
<p>As you study the <a href="https://github.com/ioccc-src/winner/blob/master/2024/codemeow/prog.c">2024/codemeow/prog.c source code</a>,
try not to lose track of the forest of obfuscation while tracking down the execution path trees.</p>
<p>We think this code will “grow on you” as the C expression goes just a compiled C code “<em>grows on parse trees</em>”. :-)</p>
<p>We think this code will “grow on you” as the C expression goes just as compiled C code “<em>grows on parse trees</em>”. :-)</p>
<ul>
<li><a href="kurdyukov2/index.html">2024/kurdyukov2</a></li>
</ul>
@@ -641,21 +648,21 @@ then you might be able to see how the code words.</p>
you run this code: let alone when your try to figure out how the author was able to
encode the virtual machine in under <strong>2.5K bytes</strong> of <a href="https://github.com/ioccc-src/winner/blob/master/2024/kurdyukov3/prog.c">prog.c source code</a>!</p>
<p><strong>NOTE</strong>: The implementation runs without sound or mouse
input. You will need reply on your keyboard skills. The
input. You will need to rely on your keyboard skills. The
<a href="https://github.com/ioccc-src/winner/blob/master/2024/kurdyukov3/try.sh">2024/kurdyukov3/try.sh</a>
demonstration script will give you some useful keyboard hints.</p>
<ul>
<li><a href="cable2/index.html">2024/cable2</a></li>
</ul>
<p>To those who follow the concept of “<em>seeing is believing</em>” will very
<p>Those who follow the concept of “<em>seeing is believing</em>” will very
likely be “<em>deceived</em>” when they try to see the source in terminal window:</p>
<pre><code> cat 2024/cable2/prog.c</code></pre>
<p>Viewing the <a href="https://github.com/ioccc-src/winner/blob/master/2024/cable2/prog.c">prog.c source code</a> in most editors
might suggest that the is something fishy 🐠 with the code.</p>
might suggest that there is something fishy 🐠 with the code.</p>
<ul>
<li><a href="macke/index.html">2024/macke</a></li>
</ul>
<p>Have you ever wondered would what would happen if you recursively removed
<p>Have you ever wondered what would would happen if you recursively removed
files starting from the root directory? Are you curious what happens when
you launch a <a href="https://en.wikipedia.org/wiki/Fork_bomb">fork bomb</a>?
You can safely give those and other scenarios under this virtual machine.</p>
@@ -688,14 +695,14 @@ emulating the entire
by computing the output of each gate in a loop, effectively running the CPU and associated RAM/ROM chips!</p>
<h3 id="remarks-on-some-of-submissions-that-did-not-win">Remarks on some of submissions that did not win</h3>
<ul>
<li><p>Depending on the address of a variable, as not all platforms support
<a href="https://en.wikipedia.org/wiki/Address_space_layout_randomization">ASLR</a>,
as the single source of pseudo-randomness isn’t a good idea. It’s
much better to mix in other sources of variability (e.g. time, process
<li><p>Depending on the address of a variable as the single source of
pseudo-randomness isn’t a good idea, as not all platforms support
<a href="https://en.wikipedia.org/wiki/Address_space_layout_randomization">ASLR</a>.
It’s much better to mix in other sources of variability (e.g. time, process
ID, etc.) so that subsequent runs will behave differently.</p></li>
<li><p>If a submission’s obfuscation strongly resembles a past IOCCC winning
entry, and the submission’s obfuscation is mainly in the C code source,
then the submission likely to not make it into the final rounds of judging.</p></li>
then the submission is likely to not make it into the final rounds of judging.</p></li>
<li><p>When working with modern C compilers, it’s crucial to explicitly
declare variable and function types. Don’t assume they’ll
automatically default to an <code>int</code>.</p></li>
@@ -709,8 +716,9 @@ might not be the most innovative approach.</p></li>
<li><p>If your submission relies on mathematical algorithms, be sure that the
C code that implements the mathematics is well obfuscated.</p></li>
<li><p>Just a friendly reminder that before you upload your submissions,
uncompress the compressed tarball into a different directory. This way,
you can be sure you didn’t miss uploading any important files!</p></li>
uncompress the compressed tarball into a different directory and verify
everything is in order. This way, you can be sure you didn’t miss uploading any
important files!</p></li>
<li><p>Using a lot of goto statements to make your code harder to understand
might not help it pass the final rounds of judging.</p></li>
</ul>
@@ -724,7 +732,7 @@ winning IOCCC entry, only to be beaten by a similar, but slightly better
submission. If you think this happened with your submission, consider
submitting an enhanced version to the next IOCCC.</p>
<p><strong>PLEASE DO NOT</strong> give up hope! There are some submissions that have been
submitted with revisions, multiple times before rising to the level of
submitted with revisions multiple times before rising to the level of
a winning IOCCC entry. You might also want to try with a different type
of submission altogether for the next IOCCC.</p>
<p>If you’re not planning to improve and resubmit your non-winning entry
@@ -733,14 +741,15 @@ for the next IOCCC, you’re welcome to publish it.</p>
<p>Some C compilers aren’t as great as they could be. If yours isn’t
working well, you might want to try compiling with an updated version
of clang and/or gcc instead.</p>
<p>If you encounter problems in compiling and/or running the winning entries, see the FAQ on:</p>
<p>If you encounter problems in compiling and/or running the winning entries, see
the FAQs on:</p>
<ul>
<li><a href="../faq.html#compiling">Compiling IOCCC entries</a></li>
<li><a href="../faq.html#dependencies">IOCCC entry dependencies</a></li>
<li><a href="../faq.html#compile_problems">Problems compiling entries</a></li>
<li><a href="../faq.html#running_entries">Running IOCCC entries</a></li>
</ul>
<p>For additional information on how to submit fixes, see the FAQ on:</p>
<p>For additional information on how to submit fixes, see the FAQs on:</p>
<ul>
<li><a href="../faq.html#fix_an_entry">How to submit a fix</a> - how to submit a fix to an entry</li>
<li><a href="../faq.html#fix_author">Update author information</a> - how to correct or update an IOCCC author’s information</li>
2024/weaver/.entry.json
+1 -1
View File
@@ -43,7 +43,7 @@
"OK_to_edit" : true,
"display_as" : "mp3",
"display_via_github" : true,
"entry_text" : "ref.raw converted into MP3, 256 kbps, 48 kHz, JntStereo"
"entry_text" : "ref.raw converted into MP3 256 kbps 48 kHz JntStereo"
},
{
"file_path" : "try.sh",
2024/weaver/index.html
+1 -1
View File
@@ -539,7 +539,7 @@ of this program.</p>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/prog.c">prog.c</a> - entry source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/Makefile">Makefile</a> - entry Makefile</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/prog.orig.c">prog.orig.c</a> - original source code</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/ref.mp3">ref.mp3</a> - ref.raw converted into MP3, 256 kbps, 48 kHz, JntStereo</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/ref.mp3">ref.mp3</a> - ref.raw converted into MP3 256 kbps 48 kHz JntStereo</li>
<li><a href="https://github.com/ioccc-src/winner/blob/master/2024/weaver/try.sh">try.sh</a> - script to try entry</li>
</ul>
<h2 id="secondary-files">Secondary files</h2>
sitemap.xml
+16 -16
View File
@@ -9146,7 +9146,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2012/omoikane/index.html</loc>
<lastmod>2025-07-26T18:44:07+00:00</lastmod>
<lastmod>2025-08-05T07:32:55+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2012/omoikane/Makefile</loc>
@@ -14346,7 +14346,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/burton/index.html</loc>
<lastmod>2025-08-04T19:21:50+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/burton/Makefile</loc>
@@ -14442,7 +14442,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/cable1/index.html</loc>
<lastmod>2025-08-03T19:39:58+00:00</lastmod>
<lastmod>2025-08-04T20:31:45+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/cable1/Makefile</loc>
@@ -14458,7 +14458,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/cable1/README.md</loc>
<lastmod>2025-08-03T19:39:30+00:00</lastmod>
<lastmod>2025-08-04T20:31:45+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/cable1/try.sh</loc>
@@ -14754,7 +14754,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/index.html</loc>
<lastmod>2025-08-04T19:03:08+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/ioccc.jpg</loc>
@@ -14778,11 +14778,11 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/obfuscation.html</loc>
<lastmod>2025-08-04T19:03:08+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/obfuscation.md</loc>
<lastmod>2025-08-04T19:03:08+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/printer.c</loc>
@@ -14802,7 +14802,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/README.md</loc>
<lastmod>2025-08-04T19:03:08+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson1/spaghetti.png</loc>
@@ -14850,7 +14850,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson2/index.html</loc>
<lastmod>2025-08-04T19:03:08+00:00</lastmod>
<lastmod>2025-08-04T20:31:45+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson2/Makefile</loc>
@@ -14886,7 +14886,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson2/README.md</loc>
<lastmod>2025-08-03T19:51:15+00:00</lastmod>
<lastmod>2025-08-04T20:31:45+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/ferguson2/sam.jpg</loc>
@@ -14910,7 +14910,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/howe/index.html</loc>
<lastmod>2025-08-03T18:29:13+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/howe/Makefile</loc>
@@ -15158,7 +15158,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/kurdyukov4/prog.c</loc>
<lastmod>2025-07-05T06:08:05+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/kurdyukov4/prog.orig.c</loc>
@@ -15166,7 +15166,7 @@
</url>
<url>
<loc>https://www.ioccc.org/2024/kurdyukov4/README.md</loc>
<lastmod>2025-07-22T18:05:48+00:00</lastmod>
<lastmod>2025-08-05T22:50:30+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/2024/kurdyukov4/try.sh</loc>
@@ -16722,11 +16722,11 @@
</url>
<url>
<loc>https://www.ioccc.org/bugs.html</loc>
<lastmod>2025-07-26T20:09:50+00:00</lastmod>
<lastmod>2025-08-05T22:51:10+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/bugs.md</loc>
<lastmod>2025-07-26T20:09:50+00:00</lastmod>
<lastmod>2025-08-05T22:51:10+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/CODE_OF_CONDUCT.html</loc>
@@ -16926,7 +16926,7 @@
</url>
<url>
<loc>https://www.ioccc.org/status.html</loc>
<lastmod>2025-08-04T19:22:58+00:00</lastmod>
<lastmod>2025-08-05T22:47:21+00:00</lastmod>
</url>
<url>
<loc>https://www.ioccc.org/status.json</loc>