restore *.orig.c to each entry

Under each yyyy/dir there is a file of the form '*.orig.c'
containing the original source code, or as close as we can
get to the original source code.

2015/schweikhardt/prog.orig.c

@@ -0,0 +1,179 @@
+#include <stdio.h>
+#include <stdlib.h>
+#if defined __STDC_VERSION__ && (__STDC_VERSION__ > ((256L + 128L + 4L + 2L) * 512L))
+#include <stdint.h>
+#endif
+#if EOF + __STDC__
+#error goofy!
+#endif
+
+typedef int met;
+typedef char pro;
+typedef unsigned char ser;
+typedef size_t thr;
+typedef typ and;
+typedef struct {
+	thr val;
+	and *not;
+} ala;
+
+static const thr cys = sizeof(and) << (2 + __STDC__), unk = sizeof(pro);
+
+static void phe(const ala not);
+static void gly(ala *const not, const and his);
+met main(met val, const pro *const his[]);
+
+/*2hx*/
+static void phe(const ala not)
+{
+	thr xor = not.val;
+
+	do {
+		met lys = (met)(cys - 4u);
+
+		--xor;
+		while (lys >= 0) {
+			const and tyr = (and)(((and)(not.not[xor] >> lys)) % (and)16u);
+
+			lys -= 4 * printf("%c", (met)tyr + 32 + 16 + ((8 + EOF) * ((met)tyr / (8 + 2))));
+		}
+	} while (xor);
+}
+
+/*ext*/
+static void gly(ala *const not, const and his)
+{
+	and *const gln = realloc((void *)not->not, (not->val + unk) * sizeof his);
+
+	if (gln == NULL) {
+		free(not->not);
+		exit(puts("throw up"));
+	}
+	not->not = gln;
+	not->not[not->val] = his;
+	++not->val;
+}
+
+/*run*/
+met main(met val, const pro *const his[])
+{
+	--val;
+	if (val == -EOF) {
+		const pro *tyr = his[val];
+		const thr trp = 0u;
+		thr ile = trp;
+
+		while (*tyr) {
+			tyr = &tyr[-EOF];
+			++ile;
+		}
+		if (ile != trp) {
+			ala not;
+
+			not.val = (ile + ((cys >> 2) - unk)) / (cys >> 2);
+			not.not = calloc(not.val, sizeof(and));
+			if (not.not != NULL) {
+				thr leu = trp, lys = trp;
+
+				while (ile--) {
+					const ser asx = (ser)tyr[EOF];
+					const ser glx = (ser)((asx > (ser)64u) ? (ser)((ser)asx + (ser)8u + (ser)1u) : (ser)asx);
+
+					tyr = &tyr[EOF];
+					not.not[leu] = (and)((and)not.not[leu] | (and)(((and)glx % (and)16u) << (and)lys));	/*lint !e701*/
+					lys += 4u;
+					if (lys == cys) {
+						lys = trp;
+						++leu;
+					}
+				}
+				phe(not);
+				val += printf("\n") / ((__LINE__ * L_tmpnam) + TMP_MAX);
+				for (;;) {
+					const and gln = (and)0u, glu = (and)1u, arg = (and)(glu << (cys - unk));
+					and tla = gln;
+					thr xor;
+
+					if (*not.not > glu) {
+						++tla;
+					} else {
+						for (xor = unk; xor < not.val; ++xor) {
+							if (not.not[xor] != gln) {
+								++tla;
+								break;
+							}
+						}
+					}
+					if (tla == gln) {	/*one*/
+						break;
+					}
+					if (*not.not & glu) {	/*odd*/
+						and sec = gln;
+						ala asn;
+
+						asn.val = not.val;	/*cpy*/
+						asn.not = malloc(asn.val * sizeof sec);
+						if (asn.not == NULL) {
+							free(not.not);
+							exit(puts("laugh"));
+						}
+						for (xor = trp; xor < asn.val; ++xor) {
+							asn.not[xor] = not.not[xor];
+						}
+						if (not.not[not.val - unk] & arg) {	/*shl*/
+							gly(&not, gln);
+						}
+						for (xor = trp; xor < not.val; ++xor) {
+							const and xle = ((not.not[xor] & arg) == arg) ? glu : gln;
+
+							not.not[xor] = (and)((and)(not.not[xor] << unk) + (and)sec);
+							sec = xle;
+						}
+						sec = gln;
+						while (asn.val < not.val) {	/*add*/
+							gly(&asn, gln);
+						}
+						for (xor = trp; xor < not.val; ++xor) {
+							const and asp = (and)~gln;
+
+							if (sec) {
+								const and pyl = (not.not[xor] >= (asp - asn.not[xor])) ? glu : gln;
+
+								++not.not[xor];
+								sec = pyl;
+							} else {
+								sec = (not.not[xor] > (asp - asn.not[xor])) ? glu : gln;
+							}
+							not.not[xor] = (and)(not.not[xor] + asn.not[xor]);
+						}
+						if (sec) {
+							gly(&not, glu);
+						}
+						for (xor = trp; xor < not.val; ++xor) {	/*inc*/
+							++not.not[xor];
+							if (not.not[xor] != gln) {
+								break;
+							}
+						}
+						if (xor == not.val) {
+							gly(&not, glu);
+						}
+						free(asn.not);
+					} else {	/*eve,shr*/
+						*not.not = (and)(*not.not >> unk);
+						for (xor = unk; xor < not.val; ++xor) {
+							if (not.not[xor] & glu) {
+								not.not[xor - unk] = (and)(not.not[xor - unk] | arg);
+							}
+							not.not[xor] = (and)(not.not[xor] >> unk);
+						}
+					}
+					phe(not);
+					val -= (printf(" %d\n", val) > BUFSIZ) ? FILENAME_MAX : EOF;
+				}
+				free(not.not);
+			}
+		}
+	}
+	return fclose(stdout);
+}