diff --git a/1987/korn/Makefile b/1987/korn/Makefile index 70c5554fca..a420d9b66a 100644 --- a/1987/korn/Makefile +++ b/1987/korn/Makefile @@ -38,7 +38,7 @@ include ../../var.mk # Common C compiler warnings to silence # -CSILENCE= -Wno-error -Wno-implicit-function-declaration -Wno-implicit-int -Dunix=1 \ +CSILENCE= -Wno-error -Wno-implicit-function-declaration -Wno-implicit-int \ -Wno-string-plus-int -Wno-strict-prototypes -Wno-return-type \ -Wno-builtin-declaration-mismatch -Wno-format-contains-nul @@ -60,7 +60,7 @@ ARCH= # Defines that are needed to compile # -CDEFINE= +CDEFINE= -Dunix=1 # Include files that are needed to compile # diff --git a/2024/README.md b/2024/README.md index f1cbf3f723..9e95a336fe 100644 --- a/2024/README.md +++ b/2024/README.md @@ -297,40 +297,51 @@ emulating the entire by computing the output of each gate in a loop, effectively running the CPU and associated RAM/ROM chips! +
### Remarks on some of submissions that did not win +
+
* 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 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 automatically default to an `int`. +
* Sadly, K&C-style C code does not compile well under modern C compilers. +
* A submission that only works under gcc or clang does not work as well as submissions that can work under either compiler. +
* Shrinking an existing open-source program to meet rule 2 size might be an impressive feat of code shrinking, but it might not be enough to make it into the final rounds of judging. Originality is key, and this might not be the most innovative approach. +
* If your submission relies on mathematical algorithms, be sure that the 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 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. diff --git a/2024/ferguson1/.entry.json b/2024/ferguson1/.entry.json index 3f92d7b6b3..26e620d6d1 100644 --- a/2024/ferguson1/.entry.json +++ b/2024/ferguson1/.entry.json @@ -133,6 +133,14 @@ "display_via_github" : true, "entry_text" : "text file showing all the line changes in a single run" }, + { + "file_path" : "gotos.ruined.c", + "inventory_order" : 100, + "OK_to_edit" : true, + "display_as" : "c", + "display_via_github" : true, + "entry_text" : "shows why lots of gotos will no longer make it through the final rounds" + }, { "file_path" : "lencount.c", "inventory_order" : 100, diff --git a/2024/ferguson1/README.md b/2024/ferguson1/README.md index 095d7d2e47..9acb2cf86e 100644 --- a/2024/ferguson1/README.md +++ b/2024/ferguson1/README.md @@ -12,6 +12,15 @@ YouTube show for this entry: make all ``` +### Bugs and (Mis)features: + +The current status of this entry is: + +> **STATUS: INABIAF - please DO NOT fix** + +For more detailed information see [2024/ferguson1 in bugs.html](../../bugs.html#2024_ferguson1). + + ## To use: @@ -57,10 +66,9 @@ practical reasons. ## Judges' remarks: You will have to go to "Fun-Damentals" to understand the logic flow of this -game. While the code might goto as many as 152 times to travel from `main()` to -a successful `exit(666)` you may have a devil of a time trying to figure out how -this program actually does what it does as it jumps hundreds if not thousands of -times. +game. While you jump thousands of times from as many as 152 `goto`s, to travel +from `main()` to a successful `exit(666);`, you may have a devil of a time trying +to figure out how this program actually does what it does. Before you set off on your adventure to decode this program's logic, make sure you have enough food, ammo, clothes, oxen, and programming supplies. @@ -73,19 +81,24 @@ are, you will have a devil of a time jumping around inside this C code. :-) ## Author's remarks: -> 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 **1416** (!) -line jumps. Skipping prog.c function calls and it was still **1131** jumps! The -prog.c, if you remove `#include`s, blank lines, lines with just a brace and -lines that have only variables, **only has 55 (!) 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, as it is still technically a jump. +If you wish to jump straight to the remarks about the game, go [here](#devil). + +> **FUN FACT**: the judges stated in the [2024 +index.html](https://www.ioccc.org/2024/index.html#gotos) the following: +> +> * Using a lot of goto statements to make your code harder to understand might +not help it pass the final rounds of judging. -**SUGGESTION**: if you dare, try opening -[prog.gotos.c](%%REPO_URL%%/2024/ferguson1/prog.gotos.c) in an editor with -syntax highlighting and then highlight `goto`. Alternatively, try it with `grep` -if your grep has colours enabled (probably easier). This is a nice one to try: +...and Landon told me personally: + +> One might say that the number of gotos were nearly countless. 😉 + +...which made me EXTREMELY happy and I decided to demonstrate exactly what this +means, and why lots of `goto`s are now frowned upon, something I aimed to do. If +you dare, try opening [gotos.ruined.c](%%REPO_URL%%/2024/ferguson1/prog.gotos.c) +in an editor with syntax highlighting and then highlight `goto`. Alternatively, +try it with `grep` if your grep has colours enabled (probably easier). This is a +nice one to try: ``` grep -E 'heaven|goto|666|hell' prog.gotos.c @@ -99,7 +112,23 @@ depend on what you're doing): /heaven\|goto\|666\|hell ``` -Read it and weep scream (or curse :-) )! +After that, to see just the `goto`s before pre-processing, take a look at +[prog.gotos.c](%%REPO_URL%%/2024/ferguson1/prog.gotos.c), using the same methods +as above (you could also try, if your `grep` has the `-o` option, which is not +required by POSIX, just doing `grep -o goto gotos.ruined.c` and `grep -o goto +prog.gotos.c` but this is less fun). + +Read them and weep scream (or curse the +[devil](https://www.ioccc.org/authors.html#Cody_Boone_Ferguson) :-) )! + +> **FUN FACT**: after winning this, I 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 **1416** (!) +line jumps. Skipping prog.c function calls and it was still **1131** jumps! The +prog.c, if you remove `#include`s, blank lines, lines with just a brace and +lines that have only variables, **only has 55 (!) 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 as it's still a jump. **NOTE**: I actually submitted two versions, one encrypted (even emojis); any document mentioning encryption is left for personal reasons out of @@ -110,6 +139,13 @@ can be found [here](https://ioccc.xexyl.net/2024/oregon/) or else in the markdown files in the tarball), if anyone is interested, assuming there's not an extended power cut or something else goes wrong. +The server is backed by solar panels with batteries and two SmartUPSes, one for +the Internet and one for the server, so except for upgrades and/or hardware +maintenance (which I hate doing and depending on what needs to be done can be +longer than one might expect), it should usually be available, though if I +have time am not too lazy, one day I'll add it to the IOCCC website +instead. +
### A Pact With the Devil On the Oregon Trail (...and his 134 152 regrets of goto) @@ -244,7 +280,7 @@ even work). So the data files allow for portability and obfuscation (and showing some rather cool things that you can do in C - whether or not they're a good idea in production code, they're still quite cool and could inspire people, maybe). Plus -allowing this to be a submission at all. As I discuss this and the other reasons +allowing this to be an entry at all. As I discuss this and the other reasons later (including [portability](#portability) and [compiling](#compiling)) as well as obfuscation - with some **REALLY** cool and **VERY** interesting tricks - in [obfuscation.html](obfuscation.html), I will try and not repeat this justification, @@ -257,7 +293,7 @@ used for various reasons). Yes that's right. Not an array of `char *` (as in `char *y[]`) but a single `char *` - though it's used and looks like it IS an array anyway. -Going back to this submission. Why not have a bit (or a lot as the case turned +Going back to this entry. Why not have a bit (or a lot as the case turned out to be) of fun and livelihood for the IOCCC? In this game the player character (PC) had an ambiguously (most of the jokes are ambiguous like many great stories) sinful night, wasting thousands, dropping them from $6666 to @@ -453,7 +489,7 @@ even have some bugs that were fixed (it is unclear if the same applies to the alt code although I think I got those fixed). Actually, you get to see progression more, comparing the alt code with the -submission code, and you can appreciate much more this way. +entry code, and you can appreciate much more this way. Anyway, I made a huge amount of effort to repeatedly reduce bytes for more events and more obfuscation but if it was not for the size limit increase (or @@ -1276,13 +1312,13 @@ though of course the game is over at that point. There are several other events at the bare minimum or at least there were; as I continued to optimise the code size I got more in: but not all. But unfortunately due to the obfuscation it's hard to be sure what is where. I do -know that limb loss one (though there's a similar one that is in the submission -code but not one that causes a death) is not in the submission code. +know that limb loss one (though there's a similar one that is in the entry +code but not one that causes a death) is not in the entry code. It uses too many bytes. As noted (and as you would see if you looked) the -submission code got way more obfuscated than the alt code but there were it felt +entry code got way more obfuscated than the alt code but there were it felt better to add more obfuscation than to add even more events as it already has -more. I think the alt code has 25 events and the submission has 23. That's not +more. I think the alt code has 25 events and the entry has 23. That's not even counting the mountain events or the events that are part of other events! Realistically I could even get rid of the alt code but since there are more @@ -1368,7 +1404,7 @@ cases what it was)! This all took a lot of care in calculating things, manipulating values and much more. Throw in all the many jokes (many of which are utterly ridiculous) and -you have a really fun submission! +you have a really fun entry! Of course there's also the `hell` label and many of the strings in the game refer to the devil and the player character's (PC's) pact. The `goto hell` is @@ -1917,8 +1953,8 @@ A reference to 'Casper the friendly ghost' is also present: also it has no effect on gameplay but it's fun. There are possibly other cultural references I am forgetting in the alt code -that aren't in the submission code: not sure. There likely are others in the -submission code too. +that aren't in the entry code: not sure. There likely are others in the +entry code too. There are vampires (supposedly) and werewolves (supposedly) too in the both (I think) versions but possibly in a way you might not expect (hence supposedly). @@ -3315,7 +3351,7 @@ traits I do not even know how to describe. Perhaps they would be utterly ineffable. Actually I wanted to see what it was like. It was VERY amusing - but only -because I did not have to debug it. For the submission I included line changes +because I did not have to debug it. For the entry I included line changes for JUST the third prompt (this means the prog.orig.c file: as noted I made the prog.c the complete version instead, and made prog.c as submitted the prog.alt2.c, after the win). Yes, what would only take a few seconds of play. It @@ -3602,15 +3638,16 @@ The only kind of spaghetti that should exist is in a pot, on a plate or in the stomach. Or on a tree for more details if you do not recognise what I mean - and yes it's in the game). -On a lighter note (or maybe this is darker?): did you know that every time a -`goto` is used an angel (whatever you consider an angel) **DIES** and goes -straight to HELL? You don't really want that do you? I didn't think so. Yes I -killed 134 152 angels. YES I condemned 134 152 angels to -eternal torment. I **HAD** to. I don't regret it - but you should, if you -**ever** write something like this outside the IOCCC. In fact you should regret -a single goto angel dying. Even if they did not go straight to hell -in a handcart, you should still regret it. But they do. Okay so I don't really -believe that but there is no denying there is goto hell here. +On a lighter note (some might say 'darker' but I know better as I wrote the code +:-) ): did you know that every time a `goto` is used an angel (whatever you +consider an angel) **DIES** and goes straight to HELL? You don't really want +that do you? I didn't think so. Yes I killed 134 152 angels. YES I +condemned 134 152 angels to eternal torment. I **HAD** to. I don't +regret it - but you should, if you **ever** write something like this outside +the IOCCC. In fact you should regret a single goto angel dying. Even +if they did not go straight to hell in a handcart, you should still regret it. +But they do. Okay so I don't really believe that but there is no denying there +is goto hell here. I found find my abuse of `goto` hilarious. It was good intentions - the contest. But sadly sometimes the worst things that happen start with good @@ -3620,13 +3657,17 @@ it would not be good anywhere else. I would be beyond angry if I had to maintain this code. I would not blame anyone if they cursed me. I probably would be too. Not cursing you. I mean cursing me. -Don't write code like this. Except for the IOCCC. Unless of course the judges -decide they want no more `goto`s. I would not put that past them after what I -have done. I can imagine them screaming and crying. Hopefully they're laughing -at more than the jokes but I hope they laugh at this too. Well we'll see I -guess... (it appears that, based on the general remarks by the judges, of the -winning entries, that `goto` will no longer hold nearly as much water, and that -makes me happy). +And yes, it gave me IMMENSE pleasure and satisfaction that I ruined `goto` for +future IOCCC competitions. Not only was this one of my goals but as you probably +noticed already I **despise** `goto`s and although useful for obfuscation, this +is far better. And yes smashing the IOCCC record and making sure my record will +never be broken also gives me **EXTREME** pleasure and satisfaction. Obviously +this was also one of my goals. But you already knew these things, didn't you? :-) + +Don't write code like this. Not only did I make sure it'll not get past the +final rounds but it's horrible style. If you need to break out of heavily nested +loops and don't want to use a flag, break it into functions. Avoid `goto`s like +the plague. Because they are the plague. Frankly THIS PROGRAM SHOULD NOT WORK! But it does and it works well even if the flow-control is a horrible nightmare from hell. Perhaps the Devil truly has @@ -3644,20 +3685,21 @@ I say I ran out of code to move, I really mean it. The code I moved in this absurd exercise is, like I said before, already filtered through major abuse of `goto`s. -I could change all but one of the `break;`s to `goto Z;` and that would increase -it a bit. I might be able to move one or two blocks of code before reaching the -2503 limit. With the exception of the `goto Z;` (which incidentally is done in -some sneaky places) the others would be perilous. +During submission I thought: I could change all but one of the `break;`s to +`goto Z;` and that would increase it a bit. I might be able to move one or two +blocks of code before reaching the 2503 limit. With the exception of the `goto +Z;` (which incidentally is done in some sneaky places) the others would be +perilous. But after this won I decided to finish the job as the only reason I +did not do this was for practical reasons: due to the other version I wanted to +make it easier to test and having the same flow control made this much easier. -So if I have not reached the actual logical conclusion of `goto` then it has to be -in a much bigger program, but after doing this, I pity anyone who would do that, -for they're only going to cause themselves and others problems. I believe in any -case this finally reaches the logical conclusion of `goto`s in the IOCCC, -unless the size limit is changed a lot again, and I it doesn't, as 2503 is a -nice number and also allows for so much, as I have shown. +In any case, I finally did what was thought to be done in 1987: `goto` truly has +reached its final conclusion. If I've not reached the logical conclusion out of +the contest then it has to be a much bigger program but after doing this I pity +anyone who would do that, for they're only going to cause themselves and others +nightmarish debugging sessions. -Something it allows too much of though: `goto`s. I have shown that. I've -dethroned 1987/hines by a staggering amount. +I've dethroned 1987/hines by a staggering amount. One final thing to ponder. This is from an article about tools that obfuscate code, C and C++ (which I hate). It is called 'Code Obfuscation For the C and CPP @@ -3745,7 +3787,7 @@ with adding more spaghetti to the pot? Just like with temperature, where at some point hot is hot, spaghetti code is spaghetti code and I have never seen worse spaghetti code, at least not in C. -And although it might not be, I would not be surprised if this submission, or +And although it might not be, I would not be surprised if this entry, or the encrypted one, makes you fed up with `goto`s. I know I am, and as far as I am concerned, they only belong in obfuscated code! I would understand if you wanted something else new, including some new things I have put in here as well @@ -3792,6 +3834,17 @@ But again, as I made an ASCII only file any issues there shouldn't be a problem anyway. That is why I included it, for portability. I think it's pretty amazing what I did with encryption though. +Actually, to be truly horrible, I ended up doing it after all; the +[prog.orig.c](prog.orig.c) has the much fewer 134 `goto`s and [prog.c](prog.c) +has 152 `goto`s. To be strictly technical prog.c has 134 gotos and the +pre-processed version has 152 whereas the prog.orig.c has 116 gotos before +pre-processing. Yes there was a certain amount of cheating for this but it only +adds to the hellish spaghetti code and even without that 'cheating' even 100 +gotos would be awful but whether you call it 116, 134 or 152, it is still +horrific. In any case the lowest amount is 116. Additionally, it adds to +confusion because the `goto hell; goto M;` actually occurs naturally in the code +dependent on an `if` where it will do `goto hell;` OR `goto M;`. +
### Troubleshooting @@ -3843,13 +3896,13 @@ doesn't make sense to have an ASCII only one of this) friendly one too. Just to be clear, in case I made an error in describing this (or was not clear enough or more possibly have the filenames messed up), the point of the .asc -programs (compiled with `prog.c` for submission and `prog.alt.c` for alt code +programs (compiled with `prog.c` for entry and `prog.alt.c` for alt code with more events) is to be ASCII only (again if there is such a thing as a character that's >4 bytes that is unknown to me to check). This is why I have the `DATA` macro. Rather than trying to keep the same code in multiple files (aside from a lot of the same code in the alt version that is in -the submission code and trying to do this with the [commented code](commented.c) +the entry code and trying to do this with the [commented code](commented.c) too) based on how it's compiled it will open the right data file. The only other macro at compilation is discussed in another place and it's only for the theme. I was considering having it in the code itself but that would look **REALLY @@ -3942,7 +3995,7 @@ need. And isn't it lovely that emojis are encrypted with this code? I mean can you figure out how this works? The `-Wformat-nonliteral` is part of obfuscation **AND** allowing me to even -have this as a submission. The format conversions for scanf and printf are way +have this as an entry. The format conversions for scanf and printf are way too long and would consume a huge amount of bytes[^3]. It would also make the program much less pretty and FAR MORE obvious. Well: maybe not: I guess it depends on if it would complain about how `V()` is done. But let's be honest: diff --git a/2024/ferguson1/gotos.ruined.c b/2024/ferguson1/gotos.ruined.c new file mode 100644 index 0000000000..452a083e43 --- /dev/null +++ b/2024/ferguson1/gotos.ruined.c @@ -0,0 +1,38 @@ +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)); + goto hell; goto M; OO:if(b<1) { if(a){ { V(40); V(4); goto hell; goto M; } PP:goto G; } if(f) { V(41); V(4); goto hell; goto M; } { V(36); V(4); goto hell; goto M; } g:goto S; } { V(M>2169?47:36); V(4); goto hell; goto M; } + 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); while(scanf(&y[Z(2)],&r)!=1)while(getchar()!='\n'); 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+--( + 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; } } + 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:{ V(24); V(4); goto hell; goto M; } K:R-=R + R; goto Y; TT:V(v=15); O=0; goto P; } else { goto K; } goto tt; Y:switch(q=x(0,22)) +{ 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:{ V(48); V(4); goto hell; goto M; } +case 3:goto J; N:goto Q; case 4:i=17; } } case 2:V(5); } goto k; u:if(M<1951||W){ goto +if(!x(0,3)){ { V(x(0,4)?84:x(0,4)?33:34); V(4); goto hell; goto M; } 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:{ { V(i); V(4); goto hell; goto M; } goto _; } 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 +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) { { V(99); V(4); goto hell; goto M; } goto M; G:goto yy; } V(13); N-=5; } goto Z; _:goto rr; goto _; S:if (E>1999){ { V(27); V(4); goto hell; goto M; } goto _; 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 _; diff --git a/2024/ferguson1/index.html b/2024/ferguson1/index.html index e1118e2f84..240a73b2fe 100644 --- a/2024/ferguson1/index.html +++ b/2024/ferguson1/index.html @@ -481,6 +481,12 @@

Award presentation:

To build:

    make all
+

Bugs and (Mis)features:

+

The current status of this entry is:

+
+

STATUS: INABIAF - please DO NOT fix

+
+

For more detailed information see 2024/ferguson1 in bugs.html.

To use:

    ./prog

Try:

@@ -501,10 +507,9 @@

Alternate use:

./prog.alt2 # submitted code with bug fix

Judges’ remarks:

You will have to go to “Fun-Damentals” to understand the logic flow of this -game. While the code might goto as many as 152 times to travel from main() to -a successful exit(666) you may have a devil of a time trying to figure out how -this program actually does what it does as it jumps hundreds if not thousands of -times.

+game. While you jump thousands of times from as many as 152 gotos, to travel +from main() to a successful exit(666);, you may have a devil of a time trying +to figure out how this program actually does what it does.

Before you set off on your adventure to decode this program’s logic, make sure you have enough food, ammo, clothes, oxen, and programming supplies. You’ll be driving for 2170 miles through a wild wilderness inspired @@ -513,26 +518,46 @@

Judges’ remarks:

you’ll need to be prepared for anything! Regardless of how well prepared you are, you will have a devil of a time jumping around inside this C code. :-)

Author’s remarks:

+

If you wish to jump straight to the remarks about the game, go here.

-

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 1416 (!) -line jumps. Skipping prog.c function calls and it was still 1131 jumps! The -prog.c, if you remove #includes, blank lines, lines with just a brace and -lines that have only variables, only has 55 (!) 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, as it is still technically a jump.

+

FUN FACT: the judges stated in the 2024 +index.html the following:

+
    +
  • Using a lot of goto statements to make your code harder to understand might +not help it pass the final rounds of judging.
    • +
-

SUGGESTION: if you dare, try opening -prog.gotos.c in an editor with -syntax highlighting and then highlight goto. Alternatively, try it with grep -if your grep has colours enabled (probably easier). This is a nice one to try:

+

…and Landon told me personally:

+
+

One might say that the number of gotos were nearly countless. 😉

+
+

…which made me EXTREMELY happy and I decided to demonstrate exactly what this +means, and why lots of gotos are now frowned upon, something I aimed to do. If +you dare, try opening gotos.ruined.c +in an editor with syntax highlighting and then highlight goto. Alternatively, +try it with grep if your grep has colours enabled (probably easier). This is a +nice one to try:

    grep -E 'heaven|goto|666|hell' prog.gotos.c

Alternatively, in vim you might try, making sure you’re in command mode first (hit ESC if you don’t know - if that doesn’t work try hitting it again as it can depend on what you’re doing):

    /heaven\|goto\|666\|hell
-

Read it and weep scream (or curse :-) )!

+

After that, to see just the gotos before pre-processing, take a look at +prog.gotos.c, using the same methods +as above (you could also try, if your grep has the -o option, which is not +required by POSIX, just doing grep -o goto gotos.ruined.c and grep -o goto prog.gotos.c but this is less fun).

+

Read them and weep scream (or curse the +devil :-) )!

+
+

FUN FACT: after winning this, I 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 1416 (!) +line jumps. Skipping prog.c function calls and it was still 1131 jumps! The +prog.c, if you remove #includes, blank lines, lines with just a brace and +lines that have only variables, only has 55 (!) 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 as it’s still a jump.

+

NOTE: I actually submitted two versions, one encrypted (even emojis); any document mentioning encryption is left for personal reasons out of laziness and exhaustion from working on improving the presentation even after it @@ -541,6 +566,12 @@

Author’s remarks:

can be found here or else in the markdown files in the tarball), if anyone is interested, assuming there’s not an extended power cut or something else goes wrong.

+

The server is backed by solar panels with batteries and two SmartUPSes, one for +the Internet and one for the server, so except for upgrades and/or hardware +maintenance (which I hate doing and depending on what needs to be done can be +longer than one might expect), it should usually be available, though if I +have time am not too lazy, one day I’ll add it to the IOCCC website +instead.

A Pact With the Devil On the Oregon Trail (…and his 134 152 regrets of goto)

@@ -650,7 +681,7 @@

portability and compiling) as well as obfuscation - with some REALLY cool and VERY interesting tricks - in obfuscation.html, I will try and not repeat this justification, @@ -661,7 +692,7 @@

Actually, you get to see progression more, comparing the alt code with the -submission code, and you can appreciate much more this way.

+entry code, and you can appreciate much more this way.

Anyway, I made a huge amount of effort to repeatedly reduce bytes for more events and more obfuscation but if it was not for the size limit increase (or decrease depending on how you think of it) AND the data file this would @@ -1489,12 +1520,12 @@

Alt version of the code: the De

There are several other events at the bare minimum or at least there were; as I continued to optimise the code size I got more in: but not all. But unfortunately due to the obfuscation it’s hard to be sure what is where. I do -know that limb loss one (though there’s a similar one that is in the submission -code but not one that causes a death) is not in the submission code.

+know that limb loss one (though there’s a similar one that is in the entry +code but not one that causes a death) is not in the entry code.

It uses too many bytes. As noted (and as you would see if you looked) the -submission code got way more obfuscated than the alt code but there were it felt +entry code got way more obfuscated than the alt code but there were it felt better to add more obfuscation than to add even more events as it already has -more. I think the alt code has 25 events and the submission has 23. That’s not +more. I think the alt code has 25 events and the entry has 23. That’s not even counting the mountain events or the events that are part of other events!

Realistically I could even get rid of the alt code but since there are more jokes there I am keeping it. In any case 23+ is plenty.

@@ -1551,7 +1582,7 @@

Additional thematic ref cases what it was)!

This all took a lot of care in calculating things, manipulating values and much more. Throw in all the many jokes (many of which are utterly ridiculous) and -you have a really fun submission!

+you have a really fun entry!

Of course there’s also the hell label and many of the strings in the game refer to the devil and the player character’s (PC’s) pact. The goto hell is discussed more in the Humour section, as well as perhaps the @@ -2008,8 +2039,8 @@

Cultural references

A reference to ‘Casper the friendly ghost’ is also present: also it has no effect on gameplay but it’s fun.

There are possibly other cultural references I am forgetting in the alt code -that aren’t in the submission code: not sure. There likely are others in the -submission code too.

+that aren’t in the entry code: not sure. There likely are others in the +entry code too.

There are vampires (supposedly) and werewolves (supposedly) too in the both (I think) versions but possibly in a way you might not expect (hence supposedly).

@@ -3140,7 +3171,7 @@

The only kind of spaghetti that should exist is in a pot, on a plate or in the stomach. Or on a tree for more details if you do not recognise what I mean - and yes it’s in the game).

-

On a lighter note (or maybe this is darker?): did you know that every time a -goto is used an angel (whatever you consider an angel) DIES and goes -straight to HELL? You don’t really want that do you? I didn’t think so. Yes I -killed 134 152 angels. YES I condemned 134 152 angels to -eternal torment. I HAD to. I don’t regret it - but you should, if you -ever write something like this outside the IOCCC. In fact you should regret -a single goto angel dying. Even if they did not go straight to hell -in a handcart, you should still regret it. But they do. Okay so I don’t really -believe that but there is no denying there is goto hell here.

+

On a lighter note (some might say ‘darker’ but I know better as I wrote the code +:-) ): did you know that every time a goto is used an angel (whatever you +consider an angel) DIES and goes straight to HELL? You don’t really want +that do you? I didn’t think so. Yes I killed 134 152 angels. YES I +condemned 134 152 angels to eternal torment. I HAD to. I don’t +regret it - but you should, if you ever write something like this outside +the IOCCC. In fact you should regret a single goto angel dying. Even +if they did not go straight to hell in a handcart, you should still regret it. +But they do. Okay so I don’t really believe that but there is no denying there +is goto hell here.

I found find my abuse of goto hilarious. It was good intentions - the contest. But sadly sometimes the worst things that happen start with good intentions; and some of the best things strangely start with horrible @@ -3393,13 +3425,16 @@

gotos.

-

I could change all but one of the break;s to goto Z; and that would increase -it a bit. I might be able to move one or two blocks of code before reaching the -2503 limit. With the exception of the goto Z; (which incidentally is done in -some sneaky places) the others would be perilous.

-

So if I have not reached the actual logical conclusion of goto then it has to be -in a much bigger program, but after doing this, I pity anyone who would do that, -for they’re only going to cause themselves and others problems. I believe in any -case this finally reaches the logical conclusion of gotos in the IOCCC, -unless the size limit is changed a lot again, and I it doesn’t, as 2503 is a -nice number and also allows for so much, as I have shown.

-

Something it allows too much of though: gotos. I have shown that. I’ve -dethroned 1987/hines by a staggering amount.

+

During submission I thought: I could change all but one of the break;s to +goto Z; and that would increase it a bit. I might be able to move one or two +blocks of code before reaching the 2503 limit. With the exception of the goto Z; (which incidentally is done in some sneaky places) the others would be +perilous. But after this won I decided to finish the job as the only reason I +did not do this was for practical reasons: due to the other version I wanted to +make it easier to test and having the same flow control made this much easier.

+

In any case, I finally did what was thought to be done in 1987: goto truly has +reached its final conclusion. If I’ve not reached the logical conclusion out of +the contest then it has to be a much bigger program but after doing this I pity +anyone who would do that, for they’re only going to cause themselves and others +nightmarish debugging sessions.

+

I’ve dethroned 1987/hines by a staggering amount.

One final thing to ponder. This is from an article about tools that obfuscate code, C and C++ (which I hate). It is called ‘Code Obfuscation For the C and CPP Programming Languages’:

@@ -3488,7 +3523,7 @@

P.S. select remarks made t with adding more spaghetti to the pot? Just like with temperature, where at some point hot is hot, spaghetti code is spaghetti code and I have never seen worse spaghetti code, at least not in C.

-

And although it might not be, I would not be surprised if this submission, or +

And although it might not be, I would not be surprised if this entry, or the encrypted one, makes you fed up with gotos. I know I am, and as far as I am concerned, they only belong in obfuscated code! I would understand if you wanted something else new, including some new things I have put in here as well @@ -3527,6 +3562,16 @@

P.S. select remarks made t

But again, as I made an ASCII only file any issues there shouldn’t be a problem anyway. That is why I included it, for portability. I think it’s pretty amazing what I did with encryption though.

+

Actually, to be truly horrible, I ended up doing it after all; the +prog.orig.c has the much fewer 134 gotos and prog.c +has 152 gotos. To be strictly technical prog.c has 134 gotos and the +pre-processed version has 152 whereas the prog.orig.c has 116 gotos before +pre-processing. Yes there was a certain amount of cheating for this but it only +adds to the hellish spaghetti code and even without that ‘cheating’ even 100 +gotos would be awful but whether you call it 116, 134 or 152, it is still +horrific. In any case the lowest amount is 116. Additionally, it adds to +confusion because the goto hell; goto M; actually occurs naturally in the code +dependent on an if where it will do goto hell; OR goto M;.

Troubleshooting

IMPORTANT: if the program exits without doing anything then either the data file could not be read (see below) although that would likely only happen if a @@ -3561,12 +3606,12 @@

Troubleshooting

Portability

Just to be clear, in case I made an error in describing this (or was not clear enough or more possibly have the filenames messed up), the point of the .asc -programs (compiled with prog.c for submission and prog.alt.c for alt code +programs (compiled with prog.c for entry and prog.alt.c for alt code with more events) is to be ASCII only (again if there is such a thing as a character that’s >4 bytes that is unknown to me to check).

This is why I have the DATA macro. Rather than trying to keep the same code in multiple files (aside from a lot of the same code in the alt version that is in -the submission code and trying to do this with the commented code +the entry code and trying to do this with the commented code too) based on how it’s compiled it will open the right data file. The only other macro at compilation is discussed in another place and it’s only for the theme. I was considering having it in the code itself but that would look REALLY @@ -3638,7 +3683,7 @@

Compiling

need. And isn’t it lovely that emojis are encrypted with this code? I mean can you figure out how this works?

The -Wformat-nonliteral is part of obfuscation AND allowing me to even -have this as a submission. The format conversions for scanf and printf are way +have this as an entry. The format conversions for scanf and printf are way too long and would consume a huge amount of bytes3. It would also make the program much less pretty and FAR MORE obvious. Well: maybe not: I guess it depends on if it would complain about how V() is done. But let’s be honest: @@ -3777,6 +3822,7 @@

Primary files

  • bytetest.c - prints every string extracted from data
  • deobfuscation.html - hints on how to deobfuscate
  • gotos.c.txt - text file showing only gotos in the entry code pre cpp
    • +
  • gotos.ruined.c - shows why lots of gotos will no longer make it through the final rounds
  • jumps.txt - text file showing all the line changes in a single run
  • lencount.c - counts strings and reports longest one
  • mbcheck.c - show location of multibyte characters
    • diff --git a/2024/index.html b/2024/index.html index a8d8bc71e7..88a5bceafc 100644 --- a/2024/index.html +++ b/2024/index.html @@ -695,34 +695,88 @@

    Remarks on some of the winning e emulating the entire 4004 chip circuit by computing the output of each gate in a loop, effectively running the CPU and associated RAM/ROM chips!

    +

    Remarks on some of submissions that did not win

    +
    +
    + +
      -

    • Depending on the address of a variable as the single source of +

    • 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. 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 +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 is likely to not make it into the final rounds of judging.

      • -

    • When working with modern C compilers, it’s crucial to explicitly +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 -automatically default to an int.

      • -

    • Sadly, K&C-style C code does not compile well under modern C compilers.

      • -

    • A submission that only works under gcc or clang does not work as well -as submissions that can work under either compiler.

      • -

    • Shrinking an existing open-source program to meet rule 2 size might +automatically default to an int.

      • +
    +
    + +
    +
      +
    • Sadly, K&C-style C code does not compile well under modern C compilers.
      • +
    +
    + +
    +
      +
    • A submission that only works under gcc or clang does not work as well +as submissions that can work under either compiler.
      • +
    +
    + +
    +
      +
    • Shrinking an existing open-source program to meet rule 2 size might be an impressive feat of code shrinking, but it might not be enough to make it into the final rounds of judging. Originality is key, and this -might not be the most innovative approach.

      • -

    • If your submission relies on mathematical algorithms, be sure that the -C code that implements the mathematics is well obfuscated.

      • -

    • Just a friendly reminder that before you upload your submissions, +might not be the most innovative approach.

      • +
    +
    + +
    +
    + +
    +
    + +
    +
      +
    • If your submission relies on mathematical algorithms, be sure that the +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 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.

      • +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.

    Encouragement for those who did not win this year

    We know many of you that submitted to the IOCCC put in a ton of effort diff --git a/bugs.html b/bugs.html index 89b875e681..ff3441b8e9 100644 --- a/bugs.html +++ b/bugs.html @@ -3615,11 +3615,42 @@

    STATUS: known bug - please hel

    Source code: 2024/carlini/prog.c

    Information: 2024/carlini/index.html

    When printing a 0 digit, the fib.bin 4004 program will print a space instead of a “0”.

    +
    +

    2024/ferguson1

    +
    +

    Jump to: top

    +

    STATUS: INABIAF - please DO NOT fix

    +

    Source code: 2024/ferguson1/prog.c

    +

    Information: 2024/ferguson1/index.html

    +

    Upon starting this game you will immediately have a sinful night and playing it +will lead you directly to a date with the Devil in HELL after things such as:

    +
      +
    • having delusions and hallucinations
      • +
    • engaging in robbery, accidental killings and cannibalism
      • +
    • engaging in or thinking about illicit affairs
      • +
    • encountering and trying to defend yourself against +Blackbeard aka Edward Teach on his +flagship Queen Anne’s +Revenge
      • +
    • dying of dysentery
      • +
    • dying of starvation after all your oxen are consumed and nobody else is left
      • +
    • being eaten by a dragon
      • +
    • being eaten by Tyrannosauruses
      • +
    • eating spaghetti and being strangled by +it
      • +
    • encountering the famous Spaghetti Tree
      • +
    • and a whole host of other wild and exciting things!
      • +
    +

    Whether or not you make it to Oregon Trail be prepared to meet the DEVIL in +HELL!

    +

    And MAKE SURE to say hi to +him! :-) +He is waiting. 😈

    2024/ferguson2

    Jump to: top

    -

    STATUS: INABIAF - please DO NOT fix

    +

    STATUS: INABIAF - please DO NOT fix

    Source code: 2024/ferguson2/prog.c

    Information: 2024/ferguson2/index.html

    As the language is a spoken language and as spaces are required to separate @@ -3647,6 +3678,7 @@

    Information: top

    2024/howe

    @@ -3691,7 +3723,7 @@

    Information: 2024/kurdyukov4

    Jump to: top

    -

    STATUS: INABIAF - please DO NOT fix

    +

    STATUS: INABIAF - please DO NOT fix

    Source code: 2024/kurdyukov4/prog.c

    Information: 2024/kurdyukov4/index.html

    The 2024/kurdyukov4/try.sh script @@ -3700,6 +3732,8 @@

    Information: 2024/kurdyukov4/index.html.

    Jump to: top

    @@ -3713,8 +3747,6 @@

    Final words

    request or otherwise, we thank you as well for the help! We will happily add you to the thanks file as well.

    -

    For more information see the “Large input size issues” section of -2024/kurdyukov4/index.html.

    Jump to: top