Move 1988-2004 entries into subdirs
We we move 1988-2004 entries from all of a year's winning entries in a single directory to each winner being in their own sub-directory under the given year directory.
This commit is contained in:
Landon Curt Noll committed
1 parent
1e82e8aa3e
commit
d2a42f42e8
478 files changed
No files matched your search
@@ -0,0 +1,446 @@
|
||||
#include <stdio.h>
|
||||
#define k *(int*)
|
||||
#define a if(
|
||||
#define c ad()
|
||||
#define i else
|
||||
#define p while(
|
||||
#define x *(char*)
|
||||
#define b ==
|
||||
#define V =calloc(1,99999)
|
||||
#define f ()
|
||||
#define J return
|
||||
#define l ae(
|
||||
#define n e)
|
||||
#define u d!=
|
||||
#define F int
|
||||
#define y (j)
|
||||
#define r m=
|
||||
#define t +4
|
||||
F d,z,C,h,P,K,ac,q,G,v,Q,R,D,L,W,M;
|
||||
E(n{
|
||||
x D++=e;
|
||||
}
|
||||
o f{
|
||||
a L){
|
||||
h=x L++;
|
||||
a h b 2){
|
||||
L=0;
|
||||
h=W;
|
||||
}
|
||||
}
|
||||
i h=fgetc(Q);
|
||||
}
|
||||
X f{
|
||||
J isalnum(h)|h b 95;
|
||||
}
|
||||
Y f{
|
||||
a h b 92){
|
||||
o f;
|
||||
a h b 110)h=10;
|
||||
}
|
||||
}
|
||||
c{
|
||||
F e,j,m;
|
||||
p isspace(h)|h b 35){
|
||||
a h b 35){
|
||||
o f;
|
||||
c;
|
||||
a d b 536){
|
||||
c;
|
||||
E(32);
|
||||
k d=1;
|
||||
k(d t)=D;
|
||||
}
|
||||
p h!=10){
|
||||
E(h);
|
||||
o f;
|
||||
}
|
||||
E(h);
|
||||
E(2);
|
||||
}
|
||||
o f;
|
||||
}
|
||||
C=0;
|
||||
d=h;
|
||||
a X f){
|
||||
E(32);
|
||||
M=D;
|
||||
p X f){
|
||||
E(h);
|
||||
o f;
|
||||
}
|
||||
a isdigit(d)){
|
||||
z=strtol(M,0,0);
|
||||
d=2;
|
||||
}
|
||||
i{
|
||||
x D=32;
|
||||
d=strstr(R,M-1)-R;
|
||||
x D=0;
|
||||
d=d*8+256;
|
||||
a d>536){
|
||||
d=P+d;
|
||||
a k d b 1){
|
||||
L=k(d t);
|
||||
W=h;
|
||||
o f;
|
||||
c;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i{
|
||||
o f;
|
||||
a d b 39){
|
||||
d=2;
|
||||
Y f;
|
||||
z=h;
|
||||
o f;
|
||||
o f;
|
||||
}
|
||||
i a d b 47&h b 42){
|
||||
o f;
|
||||
p h){
|
||||
p h!=42)o f;
|
||||
o f;
|
||||
a h b 47)h=0;
|
||||
}
|
||||
o f;
|
||||
c;
|
||||
}
|
||||
i{
|
||||
e="++#m--%am*@R<^1c/@%[_[H3c%@%[_[H3c+@.B#d-@%:_^BKd<<Z/03e>>`/03e<=0f>=/f<@.f>@1f==&g!='g&&k||#l&@.BCh^@.BSi|@.B+j~@/%Yd!@&d*@b";
|
||||
p j=x e++){
|
||||
r x e++;
|
||||
z=0;
|
||||
p(C=x e++-98)<0)z=z*64+C+64;
|
||||
a j b d&(m b h|m b 64)){
|
||||
a m b h){
|
||||
o f;
|
||||
d=1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
l g){
|
||||
p g&&g!=-1){
|
||||
x q++=g;
|
||||
g=g>>8;
|
||||
}
|
||||
}
|
||||
A(n{
|
||||
F g;
|
||||
p n{
|
||||
g=k e;
|
||||
k e=q-e-4;
|
||||
e=g;
|
||||
}
|
||||
}
|
||||
s(g,n{
|
||||
l g);
|
||||
k q=e;
|
||||
e=q;
|
||||
q=q t;
|
||||
J e;
|
||||
}
|
||||
H(n{
|
||||
s(184,n;
|
||||
}
|
||||
B(n{
|
||||
J s(233,n;
|
||||
}
|
||||
S(j,n{
|
||||
l 1032325);
|
||||
J s(132+j,n;
|
||||
}
|
||||
Z(n{
|
||||
l 49465);
|
||||
H(0);
|
||||
l 15);
|
||||
l e+144);
|
||||
l 192);
|
||||
}
|
||||
N(j,n{
|
||||
l j+131);
|
||||
s((e<512)<<7|5,n;
|
||||
}
|
||||
T y{
|
||||
F g,e,m,aa;
|
||||
g=1;
|
||||
a d b 34){
|
||||
H(v);
|
||||
p h!=34){
|
||||
Y f;
|
||||
x v++=h;
|
||||
o f;
|
||||
}
|
||||
x v=0;
|
||||
v=v t&-4;
|
||||
o f;
|
||||
c;
|
||||
}
|
||||
i{
|
||||
aa=C;
|
||||
r z;
|
||||
e=d;
|
||||
c;
|
||||
a e b 2){
|
||||
H(m);
|
||||
}
|
||||
i a aa b 2){
|
||||
T(0);
|
||||
s(185,0);
|
||||
a e b 33)Z(m);
|
||||
i l m);
|
||||
}
|
||||
i a e b 40){
|
||||
w f;
|
||||
c;
|
||||
}
|
||||
i a e b 42){
|
||||
c;
|
||||
e=d;
|
||||
c;
|
||||
c;
|
||||
a d b 42){
|
||||
c;
|
||||
c;
|
||||
c;
|
||||
c;
|
||||
e=0;
|
||||
}
|
||||
c;
|
||||
T(0);
|
||||
a d b 61){
|
||||
c;
|
||||
l 80);
|
||||
w f;
|
||||
l 89);
|
||||
l 392+(e b 256));
|
||||
}
|
||||
i a n{
|
||||
a e b 256)l 139);
|
||||
i l 48655);
|
||||
q++;
|
||||
}
|
||||
}
|
||||
i a e b 38){
|
||||
N(10,k d);
|
||||
c;
|
||||
}
|
||||
i{
|
||||
g=k e;
|
||||
a!g)g=dlsym(0,M);
|
||||
a d b 61&j){
|
||||
c;
|
||||
w f;
|
||||
N(6,g);
|
||||
}
|
||||
i a u 40){
|
||||
N(8,g);
|
||||
a C b 11){
|
||||
N(0,g);
|
||||
l z);
|
||||
c;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
a d b 40){
|
||||
a g b 1)l 80);
|
||||
r s(60545,0);
|
||||
c;
|
||||
j=0;
|
||||
p u 41){
|
||||
w f;
|
||||
s(2393225,j);
|
||||
a d b 44)c;
|
||||
j=j t;
|
||||
}
|
||||
k r j;
|
||||
c;
|
||||
a!g){
|
||||
e=e t;
|
||||
k e=s(232,k n;
|
||||
}
|
||||
i a g b 1){
|
||||
s(2397439,j);
|
||||
j=j t;
|
||||
}
|
||||
i{
|
||||
s(232,g-q-5);
|
||||
}
|
||||
a j)s(50305,j);
|
||||
}
|
||||
}
|
||||
O y{
|
||||
F e,g,m;
|
||||
a j--b 1)T(1);
|
||||
i{
|
||||
O y;
|
||||
r 0;
|
||||
p j b C){
|
||||
g=d;
|
||||
e=z;
|
||||
c;
|
||||
a j>8){
|
||||
r S(e,m);
|
||||
O y;
|
||||
}
|
||||
i{
|
||||
l 80);
|
||||
O y;
|
||||
l 89);
|
||||
a j b 4|j b 5){
|
||||
Z(n;
|
||||
}
|
||||
i{
|
||||
l n;
|
||||
a g b 37)l 146);
|
||||
}
|
||||
}
|
||||
}
|
||||
a m&&j>8){
|
||||
r S(e,m);
|
||||
H(e^1);
|
||||
B(5);
|
||||
A(m);
|
||||
H(n;
|
||||
}
|
||||
}
|
||||
}
|
||||
w f{
|
||||
O(11);
|
||||
}
|
||||
U f{
|
||||
w f;
|
||||
J S(0,0);
|
||||
}
|
||||
I y{
|
||||
F m,g,e;
|
||||
a d b 288){
|
||||
c;
|
||||
c;
|
||||
r U f;
|
||||
c;
|
||||
I y;
|
||||
a d b 312){
|
||||
c;
|
||||
g=B(0);
|
||||
A(m);
|
||||
I y;
|
||||
A(g);
|
||||
}
|
||||
i{
|
||||
A(m);
|
||||
}
|
||||
}
|
||||
i a d b 352|d b 504){
|
||||
e=d;
|
||||
c;
|
||||
c;
|
||||
a e b 352){
|
||||
g=q;
|
||||
r U f;
|
||||
}
|
||||
i{
|
||||
a u 59)w f;
|
||||
c;
|
||||
g=q;
|
||||
r 0;
|
||||
a u 59)r U f;
|
||||
c;
|
||||
a u 41){
|
||||
e=B(0);
|
||||
w f;
|
||||
B(g-q-5);
|
||||
A(n;
|
||||
g=e t;
|
||||
}
|
||||
}
|
||||
c;
|
||||
I(&m);
|
||||
B(g-q-5);
|
||||
A(m);
|
||||
}
|
||||
i a d b 123){
|
||||
c;
|
||||
ab(1);
|
||||
p u 125)I y;
|
||||
c;
|
||||
}
|
||||
i{
|
||||
a d b 448){
|
||||
c;
|
||||
a u 59)w f;
|
||||
K=B(K);
|
||||
}
|
||||
i a d b 400){
|
||||
c;
|
||||
k j=B(k j);
|
||||
}
|
||||
i a u 59)w f;
|
||||
c;
|
||||
}
|
||||
}
|
||||
ab y{
|
||||
F m;
|
||||
p d b 256|u-1&!j){
|
||||
a d b 256){
|
||||
c;
|
||||
p u 59){
|
||||
a j){
|
||||
G=G t;
|
||||
k d=-G;
|
||||
}
|
||||
i{
|
||||
k d=v;
|
||||
v=v t;
|
||||
}
|
||||
c;
|
||||
a d b 44)c;
|
||||
}
|
||||
c;
|
||||
}
|
||||
i{
|
||||
A(k(d t));
|
||||
k d=q;
|
||||
c;
|
||||
c;
|
||||
r 8;
|
||||
p u 41){
|
||||
k d=m;
|
||||
r m t;
|
||||
c;
|
||||
a d b 44)c;
|
||||
}
|
||||
c;
|
||||
K=G=0;
|
||||
l 15042901);
|
||||
r s(60545,0);
|
||||
I(0);
|
||||
A(K);
|
||||
l 50121);
|
||||
k r G;
|
||||
}
|
||||
}
|
||||
}
|
||||
main(g,n{
|
||||
Q=stdin;
|
||||
a g-->1){
|
||||
e=e t;
|
||||
Q=fopen(k e,"r");
|
||||
}
|
||||
D=strcpy(R V," int if else while break return for define main ")+48;
|
||||
v V;
|
||||
q=ac V;
|
||||
P V;
|
||||
o f;
|
||||
c;
|
||||
ab(0);
|
||||
J(*(int(*)f)k(P+592))(g,n;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
Best abuse of the rules:
|
||||
|
||||
Fabrice Bellard
|
||||
451 chemin du mas de Matour
|
||||
34790 GRABELS
|
||||
France
|
||||
|
||||
http://bellard.org
|
||||
|
||||
|
||||
Judges' Comments:
|
||||
|
||||
To build:
|
||||
|
||||
make bellard
|
||||
|
||||
Try:
|
||||
|
||||
./bellard bellard.otccex.c
|
||||
|
||||
<JUDGES_COMMENTS>
|
||||
|
||||
|
||||
Selected Author's Comments:
|
||||
|
||||
OTCC is an Obfuscated Tiny C Compiler for i386-linux. It generates
|
||||
FAST! i386 32 bit code (no bytecode) and it is powerful enough to
|
||||
compile itself. OTCC supports a strict subset of C. This subset is
|
||||
compilable by a standard ANSI C compiler. OTCC compiles,
|
||||
assembles, links and runs C code without the need of any other
|
||||
program.
|
||||
|
||||
You can use it by typing:
|
||||
|
||||
./bellard bellard.c [args]...
|
||||
|
||||
or by giving the C source to its standard input.
|
||||
|
||||
'args' are given to the 'main' function of bellard.c (argv[0] is
|
||||
bellard.c).
|
||||
|
||||
Examples:
|
||||
|
||||
- Sample compilation and execution:
|
||||
|
||||
./bellard bellard.otccex.c 10
|
||||
|
||||
- Self compilation:
|
||||
|
||||
./bellard bellard.c bellard.otccex.c 10
|
||||
|
||||
- Self compilation iterated...
|
||||
|
||||
./bellard bellard.c bellard.c bellard.otccex.c 10
|
||||
|
||||
An alternate syntax is to use it as a script interpreter: you can
|
||||
put '#!/usr/local/bin/otcc' at the beginning of your C source if
|
||||
you installed otcc at this place.
|
||||
|
||||
Supported C language subset (read joint example 'otccex.c' to have
|
||||
an introduction to OTCC dialect):
|
||||
|
||||
- Expressions:
|
||||
|
||||
* binary operators, by decreasing priority order: '*' '/' '%',
|
||||
'+' '-', '>>' '<<', '<' '<=' '>' '>=', '==' '!=', '&',
|
||||
'^', '|', '=', '&&', '||'.
|
||||
|
||||
* '&&' and '||' have the same semantics as C : left to right
|
||||
evaluation and early exit.
|
||||
|
||||
* Parenthesis are supported.
|
||||
|
||||
* Unary operators: '&', '*' (pointer indirection), '-'
|
||||
(negation), '+', '!', '~', post fixed '++' and '--'.
|
||||
|
||||
* Pointer indirection ('*') only works with explicit cast to
|
||||
'char *', 'int *' or 'int (*)()' (function pointer).
|
||||
|
||||
* '++', '--', and unary '&' can only be used with variable
|
||||
lvalue (left value).
|
||||
|
||||
* '=' can only be used with variable or '*' (pointer
|
||||
indirection) lvalue.
|
||||
|
||||
* Function calls are supported with standard i386 calling
|
||||
convention. Function pointers are supported with explicit
|
||||
cast. Functions can be used before being declared.
|
||||
|
||||
- Types: only signed integer ('int') variables and functions can
|
||||
be declared. Variables cannot be initialized in
|
||||
declarations. Only old K&R function declarations are parsed
|
||||
(implicit integer return value and no types on arguments).
|
||||
|
||||
- Any function or variable from the libc can be used because OTCC
|
||||
uses the libc dynamic linker to resolve undefined symbols.
|
||||
|
||||
- Instructions: blocks ('{' '}') are supported as in C. 'if' and
|
||||
'else' can be used for tests. The 'while' and 'for' C constructs
|
||||
are supported for loops. 'break' can be used to exit
|
||||
loops. 'return' is used for the return value of a function.
|
||||
|
||||
- Identifiers are parsed the same way as C. Local variables are
|
||||
handled, but there is no local name space (not a problem if
|
||||
different names are used for local and global variables).
|
||||
|
||||
- Numbers can be entered in decimal, hexadecimal ('0x' or '0X'
|
||||
prefix), or octal ('0' prefix).
|
||||
|
||||
- '#define' is supported without function like arguments. No macro
|
||||
recursion is tolerated. Other preprocessor directives are
|
||||
ignored.
|
||||
|
||||
- C Strings and C character constants are supported. Only '\n',
|
||||
'\"', '\'' and '\\' escapes are recognized.
|
||||
|
||||
- C Comments can be used (but no C++ comments).
|
||||
|
||||
- No error is displayed if an incorrect program is given.
|
||||
|
||||
- Memory: the code, data, and symbol sizes are limited to 100KB
|
||||
(it can be changed in the source code).
|
||||
|
||||
Obfuscation:
|
||||
|
||||
No special effort was needed because obfuscation is almost
|
||||
unavoidable for such a program :-) Defines must be used to
|
||||
compress the code, and integrated i386 code generator leads to non
|
||||
obvious code.
|
||||
|
||||
Portability:
|
||||
|
||||
OTCC only works on i386 linux because it generates i386 code. OTCC
|
||||
also relies on little endianness, unaligned memory accesses and
|
||||
ASCII representation of characters. It also supposes that no valid
|
||||
pointers are less than 512. If all those constraints are met, then
|
||||
OTCC could be theoretically used to "cross compile", although no
|
||||
such support is currently integrated.
|
||||
|
||||
It was successfully compiled with gcc version 2.95.2. You get some
|
||||
warnings because old K&R protos are used, some casts are implicit
|
||||
and some functions are used before being defined. OTCC uses the
|
||||
dynamic linker to resolve symbols with 'dlsym()', so '-ldl' must
|
||||
be used as library when you compile it.
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
/* #!/usr/local/bin/otcc */
|
||||
/*
|
||||
* Sample OTCC C example. You can uncomment the first line and install
|
||||
* otcc in /usr/local/bin to make otcc scripts !
|
||||
*/
|
||||
|
||||
/* Any preprocessor directive except #define are ignored. We put this
|
||||
include so that a standard C compiler can compile this code too. */
|
||||
#include <stdio.h>
|
||||
|
||||
/* defines are handled, but macro arguments cannot be given. No
|
||||
recursive defines are tolerated */
|
||||
#define DEFAULT_BASE 10
|
||||
|
||||
/*
|
||||
* Only old style K&R prototypes are parsed. Only int arguments are
|
||||
* allowed (implicit types).
|
||||
*
|
||||
* By benchmarking the execution time of this function (for example
|
||||
* for fib(35)), you'll notice that OTCC is quite fast because it
|
||||
* generates native i386 machine code.
|
||||
*/
|
||||
fib(n)
|
||||
{
|
||||
if (n <= 2)
|
||||
return 1;
|
||||
else
|
||||
return fib(n-1) + fib(n-2);
|
||||
}
|
||||
|
||||
/* Identifiers are parsed the same way as C: begins with letter or
|
||||
'_', and then letters, '_' or digits */
|
||||
fact(n)
|
||||
{
|
||||
/* local variables can be declared. Only 'int' type is supported */
|
||||
int i, r;
|
||||
r = 1;
|
||||
/* 'while' and 'for' loops are supported */
|
||||
for(i=2;i<=n;i++)
|
||||
r = r * i;
|
||||
return r;
|
||||
}
|
||||
|
||||
/* Well, we could use printf, but it would be too easy */
|
||||
print_num(n, b)
|
||||
{
|
||||
int tab, p, c;
|
||||
/* Numbers can be entered in decimal, hexadecimal ('0x' prefix) and
|
||||
octal ('0' prefix) */
|
||||
/* more complex programs use malloc */
|
||||
tab = malloc(0x100);
|
||||
p = tab;
|
||||
while (1) {
|
||||
c = n % b;
|
||||
/* Character constants can be used */
|
||||
if (c >= 10)
|
||||
c = c + 'a' - 10;
|
||||
else
|
||||
c = c + '0';
|
||||
*(char *)p = c;
|
||||
p++;
|
||||
n = n / b;
|
||||
/* 'break' is supported */
|
||||
if (n == 0)
|
||||
break;
|
||||
}
|
||||
while (p != tab) {
|
||||
p--;
|
||||
printf("%c", *(char *)p);
|
||||
}
|
||||
free(tab);
|
||||
}
|
||||
|
||||
/* 'main' takes standard 'argc' and 'argv' parameters */
|
||||
main(argc, argv)
|
||||
{
|
||||
/* no local name space is supported, but local variables ARE
|
||||
supported. As long as you do not use a globally defined
|
||||
variable name as local variable (which is a bad habbit), you
|
||||
won't have any problem */
|
||||
int s, n, f, base;
|
||||
|
||||
/* && and || operator have the same semantics as C (left to right
|
||||
evaluation and early exit) */
|
||||
if (argc != 2 && argc != 3) {
|
||||
/* '*' operator is supported with explicit casting to 'int *',
|
||||
'char *' or 'int (*)()' (function pointer). Of course, 'int'
|
||||
are supposed to be used as pointers too. */
|
||||
s = *(int *)argv;
|
||||
help(s);
|
||||
return 1;
|
||||
}
|
||||
/* Any libc function can be used because OTCC uses dynamic linking */
|
||||
n = atoi(*(int *)(argv + 4));
|
||||
base = DEFAULT_BASE;
|
||||
if (argc >= 3) {
|
||||
base = atoi(*(int *)(argv + 8));
|
||||
if (base < 2 || base > 36) {
|
||||
/* external variables can be used too (here: 'stderr') */
|
||||
fprintf(stderr, "Invalid base\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
printf("fib(%d) = ", n);
|
||||
print_num(fib(n), base);
|
||||
printf("\n");
|
||||
|
||||
printf("fact(%d) = ", n);
|
||||
if (n > 12) {
|
||||
printf("Overflow");
|
||||
} else {
|
||||
/* why not using a function pointer ? */
|
||||
f = &fact;
|
||||
print_num((*(int (*)())f)(n), base);
|
||||
}
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* functions can be used before being defined */
|
||||
help(name)
|
||||
{
|
||||
printf("usage: %s n [base]\n", name);
|
||||
printf("Compute fib(n) and fact(n) and output the result in base 'base'\n");
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user