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.

2000/anderson/anderson.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+
+char
+*T="IeJKLMaYQCE]jbZRskc[SldU^V\\X\\|/_<[<:90!\"$434-./2>]s",
+K[3][1000],*F,x,A,*M[2],*J,r[4],*g,N,Y,*Q,W,*k,q,D;X(){r  [r
+[r[3]=M[1-(x&1)][*r=W,1],2]=*Q+2,1]=x+1+Y,*g++=((((x&     7)
+-1)>>1)-1)?*r:r[x>>3],(++x<*r)&&X();}E(){A||X(x=0,g       =J
+),x=7&(*T>>A*3),J[(x[F]-W-x)^A*7]=Q[x&3]^A*(*M)[2         +(
+x&1)],g=J+((x[k]-W)^A*7)-A,g[1]=(*M)[*g=M[T+=A            ,1
+][x&1],x&1],(A^=1)&&(E(),J+=W);}l(){E(--q&&l              ()
+);}B(){*J&&B((D=*J,Q[2]<D&&D<k[1]&&(*g++=1                ),
+!(D-W&&D-9&&D-10&&D-13)&&(!*r&&(*g++=0)                   ,*
+r=1)||64<D&&D<91&&(*r=0,*g++=D-63)||D                     >=
+97&&D<123&&(*r=0,*g++=D-95)||!(D-k[                       3]
+)&&(*r=0,*g++=12)||D>k[3]&&D<=k[                          1]
+-1&&(*r=0,*g++=D-47),J++));}j(                            ){
+putchar(A);}b(){(j(A=(*K)[D*                              W+
+r[2]*Y+x]),++x<Y)&&b();}t                                 ()
+{(j((b(D=q[g],x=0),A=W)                                   ),
+++q<(*(r+1)<Y?*(r+1):                                     Y)
+)&&t();}R(){(A=(t(                                        q=
+0),'\n'),j(),++r                                          [2
+]<N)&&R();}O()                                            {(
+j((r[2]=0,R(                                              ))
+),r[1]-=q)                                                &&
+O(g-=-q)                                                  ;}
+C(){(                                                     J=
+gets                                                      (K
+[1]))&&C((B(g=K[2]),*r=!(!*r&&(*g++=0)),(*r)[r]=g-K[2],g=K[2
+],r[
+1]&&
+O())
+);;}
+main
+(){C
+((l(
+(J=(
+A=0)
+[K],
+A[M]
+=(F=
+(k=(
+M[!A
+]=(Q
+=T+(
+q=(Y
+=(W=
+32)-
+(N=4
+))))
++N)+
+2)+7
+)+7)
+),Y=
+N<<(
+*r=!
+-A))
+);;}

2000/anderson/anderson.hint

@@ -0,0 +1,76 @@
+Best Use of Flags:
+
+    Glyn Anderson
+    Jl. Raya Serang KM 18.2
+    Desa Bojong
+    Cikupa, Tangerang, 15710
+    Indonesia
+
+
+Judges' Comments:
+
+    To build:
+
+       make anderson
+
+    To run:
+
+       echo Obfuscate | ./anderson
+
+    This small program might be a nice addition to a digital personal
+    organizer; just in case you are stranded on a desert island and need to
+    signal your distress to passing ships.
+
+    The obfuscation in this program is truly masterful.  The program is
+    very cleverly obscured without the use of a single #define!
+    Reformatting this program by hand :-) is the easiest way to understand
+    what is going on.
+
+
+Selected Author's Comments:
+
+    This program is a simple filter that translates ASCII text into
+    semaphore code.  It reads from standard input and converts all
+    alphanumeric characters to their corresponding semaphore codes.
+    Consecutive whitespace is translated as a single 'break' code.  Newlines
+    also cause the next code to be output on a new line.  All other
+    characters are ignored.  The codes themselves are written to standard
+    output as a depiction of a person holding two flags, using only ASCII
+    characters (semaphore smileys, if you will).  For example, given the
+    input "Hello, world!", the output will be:
+
+                  <>       <>       <>    <>                  <>     <>
+      _()       ()/      ()/      ()/     _\)       ()       (/_     _\)
+    [] /^      |^^      /^^      /^^    [] ^^      |^^|      ^^ [] [] ^^
+      <>[      [][     <>][     <>][       ][      [][]      ][       ][
+
+
+                  <>    []
+      _()_      ()/     |()       ()
+    [] ^^ []   /^^       ^^|     |^^|
+       ][     <>][       ][]     [][]
+
+    The program is obfuscated without the use of the preprocessor or any
+    special compilation parameters.  In fact, the program doesn't even
+    bother using any keywords, save the single 'char' at the beginning.
+    This program was crafted using only operator precedence rules,
+    short-circuit evaluation and recursion.  Each function contains a
+    single, non-empty statement.  (I did have to add a couple of empty
+    statements to format the code properly.)  There is a single string
+    constant which encodes the flag positions and other data needed for
+    drawing the semaphore codes.
+
+    The preprocessor will provide no help in un-obfuscating this code, and a
+    C beautifier won't get you very far either.  You just have to crunch
+    through it.
+
+    An ANSI C compiler will generate several warnings when it compiles this
+    program, as none of the functions declare their return type, nor do they
+    return anything.  This was necessary to keep the program free of
+    keywords.  It's valid in K&R C, and compiles in ANSI C.  There are also
+    warnings about conversion from 'int' to 'char' and the resulting loss of
+    data.  Again, if it's OK with K&R, it's OK with me.
+
+    This program is a great teaching tool for learning the semaphore code;
+    and if you don't have any flags handy you can just use two copies of the
+    source file.