We have received a number of requests for a reposting of the
International Obfuscated C Code Contest rules and guidelines.  Also
some people requested that these rules be posted to a wider set of
groups.  Sorry for the cross posting.

Some technical clarifications were made to the rules and guidelines
(See the diff marks at the right hand edge).  The rules and guidelines
for this year remain the same, so people who have already or are
in the process of submitting entries for the 1993 IOCCC need not worry 
about these changes.

chongo <Landon Curt Noll> /\cc/\        chongo@toad.com
Larry Bassel                            lab@sun.com

=-=

#!/bin/sh
# This is a shell archive (shar 3.32)
# made 04/05/1993 23:00 UTC by chongo@toad.com
# Source directory /tmp
#
# existing files WILL be overwritten
#
# This shar contains:
# length  mode       name
# ------ ---------- ------------------------------------------
#   8971 -r--r--r-- rules
#  25592 -r--r--r-- guidelines
#  34482 -r--r--r-- mkentry.c
#   6418 -r--r--r-- obfuscate.info
#
# ============= rules ==============
echo "x - extracting rules (Text)"
sed 's/^X//' << 'SHAR_EOF' > rules &&
X10th International Obfuscated C Code Contest Rules
X
XCopyright (c) Landon Curt Noll & Larry Bassel, 1993.
XAll Rights Reserved.  Permission for personal, education or non-profit use is
Xgranted provided this this copyright and notice are included in its entirety
Xand remains unaltered.  All other uses must receive prior permission in writing
Xfrom both Landon Curt Noll and Larry Bassel.
X
X    Obfuscate:  tr.v.  -cated, -cating, -cates.  1. a.  To render obscure.
X		b.  To darken.  2. To confuse:  his emotions obfuscated his
X		judgment.  [LLat. obfuscare, to darken : ob(intensive) +
X		Lat. fuscare, to darken < fuscus, dark.] -obfuscation n.
X		obfuscatory adj.
X
X
XGOALS OF THE CONTEST:
X
X    * To write the most Obscure/Obfuscated C program under the rules below.
X    * To show the importance of programming style, in an ironic way.
X    * To stress C compilers with unusual code.
X    * To illustrate some of the subtleties of the C language.
X    * To provide a safe forum for poor C code.  :-)
X
X
XNOTE: Changes from the 1993 draft are noted by change bars.  --->	      |
X
X
XRULES:
X
X    To help us with the volume of entries, we ask that you follow these rules:
X
X    1) Your entry must be a complete program.
X
X    2) Your entry must be <= 3217 bytes in length.  The number of characters
X       excluding whitespace (tab, space, newline), and excluding any ; { or }
X       followed by either whitespace or end of file, must be <= 1536.
X
X    3) Your entry must be submitted in the following format:
X
X---entry---
Xrule:	1993
Xfix:	y or n   (n => this is a new entry, y => this replaces an older entry)
Xtitle:	title of entry  		    (see comments below)
Xentry:	Entry number from 0 to 7 inclusive  (your 1st entry should by 0)
Xdate:	Date/time of submission in UTC	    (see comments below)
Xhost:	Machine(s) and OS(s) under which your entry was tested
X	Use tab indented lines if needed
X---remark---
X    Place remarks about this entry in this section.  It would be helpful if
X    you were to indent your remarks with 4 spaces, though it is not a
X    requirement.  Also, if possible, try to avoid going beyond the 79th
X    column.  Blank lines are permitted.
X---author---
Xname:	your name
Xorg:	School/Company/Organization
Xaddr:	postal address
X	use tab indented lines to continue
X	don't forget to include the country
Xemail:  Email address from a well known site or registered domain.
X        If you give several forms, list them on separate tab indented lines.
Xanon:	y or n   (y => remain anonymous, n => ok to publish this info)
X---info---
XIf your program needs an info file, place a uuencoded copy of it in
Xthis section.  In the case of multiple info files, use multiple info
Xsections.  If your entry does not need a info file, skip this section.
X---build---
XPlace a uuencoded copy of the command(s) used to compile/build your program
Xin this section.  It must uudecode into a file named 'build'.  The resulting
Xfile must be 255 bytes or less.
X---program---
XPlace a uuencoded copy of your program in this section.  It must uudecode
Xinto a file named is 'prog.c'.  The resulting file must follow rule #2.
X---end---
X
X      Regarding the above format:
X
X	* The title must match the expression: [a-zA-Z0-9_=][a-zA-Z0-9_=+-]*
X	  and must be 1 to 12 characters in length.
X
X	  It is suggested, but not required, that the title should
X	  incorporate your username; in the case of multiple authors,
X	  consider using parts of the usernames of the authors.
X
X	* The date in the ---entry--- section should be given with respect
X	  to UTC.  The format of the date should be as returned by asctime()
X	  using the C locale.  (see guidelines for more info)
X
X	* You may correct/revise a previously submitted entry by sending
X	  it to the contest email address.  Be sure to set 'fix' in the
X	  ---entry--- section to 'n'.  The corrected entry must use the same
X	  title and entry number as submittion that is being corrected.  Be
X	  sure that you note the resubmittion in the ---remark--- as well.
X
X	* With the exception of the header, all text outside of the above
X	  format may be ignored by the judges.  If you need tell the judges
X	  something, put it in the ---remark--- section, or send a separate
X	  Email message to the judges.
X
X	* Information from the ---author--- section will be published unless
X	  'y' was given to the respective author's 'anon' line.
X
X	* To credit multiple authors, include an ---author--- section for
X	  each author.  Each should start with ---author--- line, and
X	  should be found between the ---entry--- and ---build--- sections.
X
X	* The entry's remarks should include:
X	    - what this program does
X	    - how to run the program (sample args or input)
X	    - special compile or execution instructions, if any
X	    - special filename requirements (see rule 4 and 5)
X	    - information about any ---data--- files
X	    - why you think the program is obfuscated
X	    - note if this entry is a re-submission of a previous entry.
X	    - any other remarks (humorous or otherwise)
X
X	* Do not rot13 your entry's remarks.  You may suggest that certain
X	  portions of your remarks be rot13ed if your entry wins an award.
X
X        * Info files should be used only to supplement your entry.  They
X	  should not be required to exist.
X
X	  If your entry does not need an info file, skip the ---info---
X	  section.  If your entry needs multiple info files, use multiple
X	  ---info--- sections, one per info file.  You should describe
X	  each info file in the ---remark--- section.
X
X    4) If your entry is selected as a winner, it will be modified as follows:
X
X	   'build' is incorporated into a makefile, and 'build' is removed
X	   'prog.c' is renamed to your entry's title, followed by an optional
X	       digit, followed by '.c'
X	   your entry is compiled into a file with the name of your entry's
X	       title, possibly followed by a digit
X
X       If your entry requires that a build file exist, state so in your
X       entry's remark section.  The makefile will be arranged to execute a
X       build shell script containing the 'build' information.  The name of
X       this build shell script will be your entry's title, possibly followed
X       by a digit, followed by '.sh'.
X
X       If needed, your entry's remarks should indicate how your entry must
X       be changed in order to deal with the new filenames.
X
X    5) The build file, the source and the resulting executable should be
X       treated as read-only files.  If your entry needs to modify these files,
X       it should make and modify a copy of the appropriate file.  If this
X       occurs, state so in your entry's remarks.
X
X    6) Entries that cannot be compiled by an ANSI C compiler will be rejected.
X       Use of common C (K&R + extensions) is permitted, as long as it does not
X       cause compile errors for ANSI C compilers.
X
X    7) The program must be of original work.  All programs must be in the
X       public domain.  All copyrighted programs will be rejected.
X
X    8) Entries must be received prior to 07-May-93 0:00 UTC.  (UTC is
X       essentially equivalent to Greenwich Mean Time)  Email your entries to:
X
X		...!{apple,pyramid,sun,uunet}!hoptoad!obfuscate
X		obfuscate@toad.com
X
X       We request that your message use the subject 'ioccc entry'.
X
X       If possible, we request that you hold off on Emailing your entries
X       until 1-Mar-93 0:00 UTC.  Early entries will be accepted, however.
X       We will attempt to email a confirmation to the the first author for
X       all entries received after 1-Mar-93 0:00 UTC.
X
X    9) Each person may submit up to 8 entries per contest year.  Each entry
X       must be sent in a separate Email letter.
X
X   10) Entries requiring human interaction to be built are not allowed.
X       Compiling an entry produce a file (or files) which may be executed.
X
X   11) Programs that require special privileges (setuid, setgid, super-user,
X       special owner or group) are not allowed.
X
X
XFOR MORE INFORMATION:
X
X    The Judging will be done by Landon Noll and Larry Bassel.  Please send
X    questions or comments about the contest, to:
X
X	...!{apple,pyramid,sun,uunet}!hoptoad!judges	(not the address for  |
X	judges@toad.com					 submitting entries)  |
X
X    The rules and the guidelines may (and often do) change from year to
X    year.  You should be sure you have the current rules and guidelines
X    prior to submitting entries.  To obtain them, send Email to the address   |
X    above and use the subject 'send rules'.				      |
X
X    One may obtain winners of previous contests (1984 to date), via ftp from: |
X
X	host: ftp.uu.net	(192.48.96.9)				      |
X	user: anonymous
X	pass: yourname@yourhost
X	dir:  ~/pub/ioccc						      |
X
X    As a last resort, previous winners may be obtained by sending Email       |
X    to the above address.  Please use the subject 'send YEAR winners',        |
X    where YEAR is a single 4 digit year, a year range, or 'all'.	      |
X
X
Xchongo <Landon Curt Noll> /\cc/\  	chongo@toad.com			      |
XLarry Bassel			  	lab@sun.com			      |
SHAR_EOF
chmod 0444 rules ||
echo "restore of rules failed"
set `wc -c rules`;Wc_c=$1
if test "$Wc_c" != "8971"; then
	echo original size 8971, current size $Wc_c
fi
# ============= guidelines ==============
echo "x - extracting guidelines (Text)"
sed 's/^X//' << 'SHAR_EOF' > guidelines &&
X10th International Obfuscated C Code Contest Guidelines, Hints and Comments
X
XCopyright (c) Landon Curt Noll & Larry Bassel, 1993.
XAll Rights Reserved.  Permission for personal, education or non-profit use is
Xgranted provided this this copyright and notice are included in its entirety
Xand remains unaltered.  All other uses must receive prior permission in writing
Xfrom both Landon Curt Noll and Larry Bassel.
X
XABOUT THIS FILE:
X
X    This file is intended to help people who wish to submit entries to
X    the International Obfuscated C Code Contest (IOCCC for short).
X
X    This is not the IOCCC rules, though it does contain comments about
X    them.  The guidelines should be viewed as hints and suggestions.
X    Entries that violate the guidelines but remain within the rules are
X    allowed.  Even so, you are safer if you remain within the guidelines.
X
X    You should read the current IOCCC rules, prior to submitting entries.
X    The rules are typically sent out with these guidelines.
X
X    Changes from the 1993 draft are noted by change bars.  --->		      |
X
X
XWHAT IS NEW IN 1993:
X
X    The entry format is better (for us anyway).  The program mkentry.c
X    has been updated.  See ENTRY FORMAT.
X
X    We will reject entries that cannot be compiled using an ANSI C
X    compiler.  Certain old Obfuscation hacks that cause ANSI C compilers
X    fits are no longer permitted.  Some of the new issues deal with
X    non-integral array types, variable number of arguments, C preprocessor
X    directives and the exit() function.  See OUR LIKES AND DISLIKES.
X
X
XHINTS AND SUGGESTIONS:
X
X    You are encouraged to examine the winners of previous contests.  See
X    FOR MORE INFORMATION for details on how to get previous winners.
X
X    Keep in mind that rules change from year to year, so some winning entries
X    may not be valid entries this year.  What was unique and novel one year
X    might be 'old' the next year.
X
X    An entry is usually examined in a number of ways.  We typically apply
X    a number of tests to an entry:
X
X	* look at the original source
X	* convert ANSI tri-graphs to ASCII
X	* C pre-process the source ignoring '#include' lines
X	* C pre-process the source ignoring '#define' and '#include' lines
X	* run it through a C beautifier
X	* examine the algorithm
X	* lint it
X	* compile it
X	* execute it
X
X    You should consider how your entry looks in each of the above tests.
X    You should ask yourself if your entry remains obscure after it has been
X    'cleaned up' by the C pre-processor and a C beautifier.
X
X    Your entry need not do well under all, or in most tests.  In certain
X    cases, a test is not important.  Entries that compete for the
X    'strangest/most creative source layout' need not do as well as
X    others in terms of their algorithm.  On the other hand, given
X    two such entries, we are more inclined to pick the entry that
X    does something interesting when you run it.
X
X    We try to avoid limiting creativity in our rules.  As such, we leave
X    the contest open for creative rule interpretation.  As in real life
X    programming, interpreting a requirements document or a customer request
X    is important.  For this reason, we often award 'worst abuse of the
X    rules' to an entry that illustrates this point in an ironic way.
X
X    If you do plan to abuse the rules, we suggest that you let us know
X    in the remarks section.  Please note that an invitation to abuse
X    is not an invitation to break.  We are strict when it comes to the
X    3217 byte size limit.  Also, abusing the entry format tends to
X    annoy more than amuse.
X
X    We do realize that there are holes in the rules, and invite entries
X    to attempt to exploit them.  We will award 'worst abuse of the rules'
X    and then plug the hole next year.  Even so, we will attempt to use
X    the smallest plug needed, if not smaller.  :-)
X
X    Check out your program and be sure that it works.  We sometimes make
X    the effort to debug an entry that has a slight problem, particularly
X    in or near the final round.  On the other hand, we have seen some
X    of the best entries fall down because they didn't work.
X
X    We tend to look down on a prime number printer, that claims that
X    16 is a prime number.  If you do have a bug, you are better off
X    documenting it.  Noting "this entry sometimes prints the 4th power
X    of a prime by mistake" would save the above entry.  And sometimes,
X    a strange bug/feature can even help the entry!  Of course, a correctly
X    working entry is best.
X
X
XOUR LIKES AND DISLIKES:
X
X    Doing masses of #defines to obscure the source has become 'old'.  We
X    tend to 'see thru' masses of #defines due to our pre-processor tests
X    that we apply.  Simply abusing #defines or -Dfoo=bar won't go as far
X    as a program that is more well rounded in confusion.
X
X    Many ANSI C compilers dislike the following code, and so do we:
X
X	#define d define
X	#d foo		   <-- don't expect this to turn into #define foo
X
X	int i;
X	j;		   <-- don't use such implicit type declaration
X	int k;
X
X    We suggest that you compile your entry with an ANSI C compiler.  If you
X    must use non-ANSI C, such as K&R C, you must avoid areas that result in
X    compile/link errors for ANSI C compilers.
X
X    Unfortunately, some ANSI C compilers require array indexes to be of       |
X    integral type.  Thus, the following classical obfuscation hacks should    |
X    not be used in 1993.  This rule may be relaxed in future contests.	      |
X
X	int i;
X	char *c;
X	i[c];		   <--- use c[i] instead
X	(i+3)["string"];   <--- use "string"[i+3] instead
X
X    If your entry uses functions that have a variable number of
X    arguments, be careful. Systems implement va_list as a wide variety
X    of ways.  Because of this, a number of operations using va_list are
X    not portable and must not be used:
X
X	* assigning a non-va_list variable to/from a va_list variable
X	* casting a non-va_list variable into/from a va_list variable
X	* passing a va_list variable to a function expecting a non-va_list arg
X	* passing a non-va_list variable to a function expecting a va_list arg
X	* performing arithmetic on va_list variables
X	* using va_list as a structure or union
X
X    In particular, do not treat va_list variables as if they were a char **'s.
X
X    Avoid using <varargs.h>, use <stdarg.h> instead.
X
X    If you use C preprocessor directives (#define, #if, #ifdef, ...),
X    the leading '#' must be the first character on a line.  While some
X    C preprocessors allow whitespace the leading '#', many do not.
X
X    Because the exit() function returns void on some systems, entries
X    must not assume that it returns an int.
X
X    Small programs are best when they are short, obscure and concise.
X    While such programs are not as complex as other winners, they do
X    serve a useful purpose.  They are often the only program that people
X    attempt to completely understand.  For this reason, we look for
X    programs that are compact, and are instructional.
X
X    One line programs should be short one line programs, say around 80
X    bytes long.  Getting close to 160 bytes is a bit too long in our opinion.
X
X    We tend to dislike programs that:
X
X	* are very hardware specific
X	* are very OS or Un*x version specific
X	     (index/strchr differences are ok, but socket/streams specific
X	      code is likely not to be)
X	* dump core or have compiler warnings
X	     (it is ok only if you warn us in the 'remark' header item)
X	* won't compile under both BSD or SYS V Un*x
X	* abusing the build file to get around the size limit
X	* obfuscate by excessive use of ANSI tri-graphs
X	* are longer than they need to be
X	* are similar to previous winners
X	* are identical to previous losers  :-)
X
X    Unless you are cramped for space, or unless you are entering the
X    'best one liner' category, we suggest that you format your program
X    in a more creative way than simply forming excessively long lines.
X
X    The build file should not be used to try and get around the size
X    limit.  It is one thing to make use of a several -D's to help out,
X    but it is quite another to use 200+ bytes of -D's in order to
X    try and squeeze the source under the size limit.  You should feel
X    free to make use of the build file space, but you are better off
X    if you show some amount of restraint.
X
X    We allowed whitespace, and in certain cases ; { or } do not impact
X    your program size (up to a certain point), because we want to get
X    away from source that is simply a compact blob of characters.
X
X    Given two versions of the same program, one that is a compact blob
X    of code, and the other that is formatted more like a typical C
X    program, we tend to favor the second version.  Of course, a third
X    version of the same program that is formatted in an interesting
X    and/or obfuscated way, would definitely win over the first two!
X
X    We suggest that you avoid trying for the 'smallest self-replicating'
X    program.  We are amazed at the many different sizes that claim
X    to be the smallest.  There is nothing wrong with self-replicating
X    programs.  In fact, a number of winners have been self-replicating.
X    You might want to avoid the claim of 'smallest', lest we (or others)
X    know of a smaller one!
X
X    X client entries should be as portable as possible.  Entries that
X    adapt to a wide collection of environments will be favored.  Don't
X    depend on a particular type of display.  For example, don't depend
X    on color or a given size.  Don't require backing store.
X
X    X client entries should avoid using X related libraries and
X    software that is not in wide spread use.  We ask that such X client
X    entries restrict themselves to only the low level Xlib and the
X    Athena widget set (libX11.a, libXaw.a, libXmu.a and libXt.a).
X    Don't use M*tif, Xv*ew, or OpenL*ok toolkits, since not everyone
X    has them.  Avoid depending on a particular window manager.  Not
X    everyone has X11r5, and some people are stuck back in X11r4 (or
X    earlier), so try to target X11r5 without requiring X11r5.  Better
X    yet, try to make your entry run on all version 11 X Window Systems.
X
X    X client entries should not to depend on particular items on
X    .Xdefaults.  If you must do so, be sure to note the required lines
X    in the ---remark--- section.
X
X    We like programs that:
X
X	* are as concise and small as they need to be
X	* do something at least quasi-interesting
X	* pass lint without complaint (not a requirement, but it is nice)
X	* are portable
X	* are unique or novel in their obfuscation style
X	* MAKE USE OF A NUMBER OF DIFFERENT TYPES OF OBFUSCATION
X	* make us laugh and/or throw up  :-)
X
X    Some types of programs can't excel in some areas.  Of course, your
X    program doesn't have to excel in all areas, but doing well in several
X    areas really does help.
X
X    We freely admit that interesting, creative or humorous comments in
X    the ---remark--- section helps your chance of winning.  If you had to
X    read of many twisted entries, you too would enjoy a good laugh or two.
X    We think the readers of the contest winners do as well.
X
X    Be creative!
X
X
XENTRY FORMAT:
X
X    In order to help us process the many entries, we must request your
X    assistance by formatting your entries in a certain way.  This format,
X    in addition, allows us to quickly separate information about the
X    author from the program itself.  (see JUDGING PROCESS)
X
X    We have provided the program, mkentry, as an example of how to
X    format entries.  You should be aware of the following warning that
X    is found in mkentry.c:
X
X	This program attempts to implement the IOCCC rules.  Every
X	attempt has been made to make sure that this program produces
X	an entry that conforms to the contest rules.  In all cases,
X	where this program differs from the contest rules, the
X	contest rules will be used.  Be sure to check with the
X	contest rules before submitting an entry.
X
X    You are not required to use mkentry.  It is convenient, however,
X    as it attempts to uuencode the needed files, and attempt to check
X    the entry against the size rules.
X
X    If you have any suggestions, comments, fixes or complaints about
X    the mkentry.c program, please send Email to the judges.  (see below)
X
X    The following is a sample entry:
X
X---entry---
Xrule:	1993
Xfix:	n
Xtitle:	chonglab
Xentry:	0
Xdate:	Mon Mar  1 08:45:20 1993
Xhost:	Un*x v6, pdp11/45
X	2.9BSD, pdp11/70
X---remark---
X    This is a non-obfuscated obfuscated C program.
X
X    It is likely not to win a prize.  But what do you expect from
X    a short example!
X---author---
Xname:	Landon Curt Noll
Xorg:	IOCCC Judging Group
Xaddr:	Toad Hall
X	PO Box 170608
X	San Francisco, California
X	94117-0608
X	USA
Xemail:	chongo@toad.com
Xanon:	n
X---author---
Xname:	Larry Bassel
Xorg:	IOCCC Judging Group
Xaddr:	Toad Hall
X	PO Box 170608
X	San Francisco, California
X	94117-0608
X	USA
Xemail:	hoptoad!sun!lab
X	lab@sun.com
Xanon:	n
X---info---
Xbegin 444 info.file
XM0V]P>7)I9VAT("AC*2!,86YD;VX@0W5R="!.;VQL+"`Q.3DS+@I!;&P@4FEG
XM:'1S(%)E<V5R=F5D+B`@4&5R;6ES<VEO;B!F;W(@<&5R<V]N86PL(&5D=6-A
XM=&EO;B!O<B!N;VXM<')O9FET('5S92!I<PIG<F%N=&5D('!R;W9I9&5D('1H
XM:7,@=&AI<R!C;W!Y<FEG:'0@86YD(&YO=&EC92!A<F4@:6YC;'5D960@:6X@
XM:71S(&5N=&ER971Y"F%N9"!R96UA:6YS('5N86QT97)E9"X@($%L;"!O=&AE
XM<B!U<V5S(&UU<W0@<F5C96EV92!P<FEO<B!P97)M:7-S:6]N(&EN('=R:71I
XM;F<*9G)O;2!,86YD;VX@0W5R="!.;VQL+@H*5&AA="!T:&%T(&ES+"!I<RX*
XM5&AA="!T:&%T(&ES(&YO="P*("`@(&ES(&YO="!T:&%T('1H870@;F]T(&ES
XM+@I4:&%T(&ES+"!T:&%T('1H870@:7,@;F]T+"!I<R$*"@D)+2T@8VAO;F=O
XM(#$Y-S0*"DQA<W0@>65A<BP@;VYE('!E<G-O;B!T;VQD('5S('1H870@=&AE
XM>2!A8W1U86QL>2!D96-O9&5D('1H:7,@9FEL92X*22!W;VYD97(@:&]W(&UA
X9;GD@=VEL;"!D;R!I="!T:&ES('EE87(_"@``
X`
Xend
X---build---
Xbegin 444 build
X28V,@<')O9RYC("UO('!R;V<*
X`
Xend
X---program---
Xbegin 444 prog.c
XM;6%I;B@I"GL*(VEF(&1E9FEN960H05]214=)4U1%4D5$7U9/5$527TE.7U-5
XM3DY95D%,15]#04Q)1D]23DE!7U5302D*("`@('!R:6YT9B@B5F]T92!,86YD
XM;VX@3F]L;"!F;W(@4W5N;GEV86QE($-I='D@0V]U;F-I;"!S96%T(",Q+EQN
X:(BD["B-E;F1I9@H@("`@97AI="@P*3L*?0H`
X`
Xend
X---end---
X
X    Typically the build file should assume that the source is prog.c
X    and will compile into prog.  If an entry wins, we will rename
X    its source and binary to avoid filename collision.  By tradition,
X    we use the name of the entry's title, followed by an optional
X    digit in case of name conflicts.
X
X    If the above entry somehow won the 'least likely to win' award,
X    we would use chonglab.c and chonglab.
X
X    If your entry depends on, or requires that your build, source
X    and/or binary files be a particular name, please say so in the
X    ---remark--- section.  If this case applies, it would be be helpful
X    if you did one of the following:
X
X	* Tell us how to change the filename(s) in your entry.
X
X	* Have the build file make copies of the files.  For example:
X
X		cc prog.c -o special_name		need special binary
X
X	    or  rm -f special_src.c			need special source
X		cp prog.c special_src.c
X		cc special_src.c -o special_name
X
X	    or  rm -f special_build			need special build
X		tail +4 build > special_build
X		sh < special_build
X
X	* Assume that we will use the entry title.  Send us a version of
X	  your build/program files that uses the name convention.  You
X	  should uuencode these files in ---data--- sections.
X
X    If your entry needs to modify its source, info or binary files,
X    please say so in the ---remark--- section.  You should try to avoid
X    touching your original build, source and binary files.  You should
X    arrange to make copies of the files you intend to modify.  This
X    will allow people to re-generate your entry from scratch.
X
X    Remember that your entry may be built without a build file.  We
X    typically incorporate the build lines into a Makefile.  If the
X    build file must exist, say so in the ---remark--- section.
X
X    If your entry needs special info files, you should uuencode them
X    into ---info--- sections.  In the case of multiple info files,
X    use multiple ---info--- sections.  If no info files are needed,
X    then skip the ---info--- section.
X
X    Info files are intended to be input, or detailed information that
X    does not fit well into the ---remark--- section.  For example, an
X    entry that implements a compiler might want to provide some sample
X    programs for the user to compile.  An entry might want to include a
X    lengthy design document, that might not be appropriate for a
X    'hints' file.
X
X    Info files should be used only to supplement your entry.  For
X    example, info files may provide sample input or detailed
X    information about your entry.  Because they are supplemental,
X    the entry should not require them exist.
X
X    In some cases, your info files might be renamed to avoid name
X    conflicts.  If info files should not be renamed for some reason,
X    say so in the ---remark--- section.
X
X    Info files must uudecode into the current directory.  If they
X    absolutely must be renamed, or moved into a sub-directory, say
X    so in the ---remark--- section.
X
X    When submitting multiple entries, be sure that each entry has
X    a unique entry number from 0 to 7.  Your first entry should
X    have entry number 0.
X
X    With the exception of the header, all text outside of the entry
X    format may be ignored.  That is, don't place text outside of the
X    entry and expect the judges to see it.  (Our decoding tools aren't
X    AI progs!) If you need tell the the something, put it in the
X    ---remark--- section, or send a Email to the judges at:
X
X	...!{apple,pyramid,sun,uunet}!hoptoad!judges	(not the address for
X	judges@toad.com					 submitting entries)
X
X    The date should be given with respect to UTC.  (Some systems refer
X    to this as GMT or GMT0)  The format of the date should be that as
X    returned by asctime() in the C locale.  An example of such a string is:
X
X	Thr Apr 01 00:47:00 1993
X
X    This format is similar to the output of the date(1) command.  The
X    string does not include the timezone name before the year.  On many
X    systems, one of the following command will produce a similar string:
X
X	date -u "+%a %h %d %T 19%y"
X	date -u | sed -e 's/... \(19[0-9][0-9]\)$/\1/'
X	sh -c 'TZ=UTC date | sed -e "s/... \(19[0-9][0-9]\)$/\1/"'
X	sh -c 'TZ=GMT date | sed -e "s/... \(19[0-9][0-9]\)$/\1/"'
X	sh -c 'TZ=GMT0 date | sed -e "s/... \(19[0-9][0-9]\)$/\1/"'
X
X    You are allowed to update/fix/revise your entry.  To do so, set
X    the 'fix' line in the ---entry--- section to 'y' instead of 'n'.
X    Be sure that the resubmittion uses the same title and entry number
X    as well, as these are used to determine which entry is to be
X    replaced.
X
X
XJUDGING PROCESS:
X
X    Entries are judged by Larry Bassel and Landon Curt Noll.
X
X    Entries are unpacked into individual directories.  The Email message
X    is unpacked into individual files, each containing:
X
X	---entry--- section
X	all ---author--- sections
X	all ---info--- sections
X	---build--- section
X	---program--- section
X	any other text, including the Email message headers
X
X    Prior to judging, the 'any other text' file is scanned to be sure
X    it does not contain useful information (or in case the entry was
X    malformed and did not unpack correctly).  Information from the
X    ---author--- sections are not read until the judging process is
X    complete, and then only from entries that have won an award.
X
X    The above process helps keep us biased for/against any one particular
X    individual.  We are usually kept in the dark as much as you are
X    until the final awards are given.  We like the surprise of finding
X    out in the end, who won and where they were from.
X
X    We attempt to keep all entries anonymous, unless they win an award.
X    Because the main 'prize' of winning is being announced, we make all
X    attempts to send non-winners into oblivion.  We remove all non-winning
X    files, and shred all related paper.  By tradition, we do not even
X    reveal the number of entries that we received.  (for the curious,
X    we do indicate the volume of paper consumed when presenting the IOCCC
X    winners at talks)
X
X    After the Usenix announcement, we attempt to send Email to the
X    authors of the winning entries.  One reason we do this is to give
X    the authors a chance to comment on the way we have presented their
X    entry.  They are given the chance to correct mistakes, typos.  We
X    often accept their suggestions/comments about our remarks as well.
X    This is done prior to posting the winners to the wide world.
X
X    Judging consists of a number of elimination rounds.  During a round,
X    the collection of entries are divided into two roughly equal piles;
X    the pile that advances on to the next round, and the pile that does
X    not.  We also re-examine the entries that were eliminated in the
X    previous round.  Thus, an entry gets at least two readings.
X
X    A reading consists of a number of actions:
X
X	* reading the ---entry--- section
X	* reading the uudecoded ---build--- section
X	* reading the uudecoded ---program--- section
X	* reading the uudecoded ---info--- section(s), if any
X	* passing the source thru the C pre-processor
X	    shipping over any #include files
X	* performing a number of C beautify/cleanup edits on the source
X	* passing the beautified source thru the C pre-processor
X	    shipping over any #include files
X
X    In later rounds, other actions are performed:
X
X	* linting the source
X	* compiling/building the source
X	* running the program
X	* performing misc tests on the source and binary
X
X    Until we reduce the stack of entries down to about 25 entries, entries
X    are judged on an individual basis.  An entry is set aside because it
X    does not, in our opinion, meet the standard established by the round.
X    When the number of entries thins to about 25 entries, we begin to form
X    award categories.  Entries begin to compete with each other for awards.
X    An entry often will compete in several categories.
X
X    The actual award category list will vary depending on the types of entries
X    we receive.  A typical category list might be:
X
X	* best small one line program
X	* best small program
X	* strangest/most creative source layout
X	* most useful obfuscated program
X	* best game that is obfuscated
X	* most creatively obfuscated program
X	* most deceptive C code
X	* best X client (see OUR LIKES AND DISLIKES)
X	* best abuse of ANSI C
X	* worst abuse of the rules
X	* <anything else so strange that it deserves an award>
X
X    We do not limit ourselves to this list.  For example, a few entries are so
X    good/bad that they are declared winners at the start of the final round.
X    We will invent awards categories for them, if necessary.
X
X    In the final round process, we perform the difficult tasks of
X    reducing the remaining entries (typically about 25) down to 8 or 10
X    winners.  Often we are confident that the entries that make it into
X    the final round are definitely better than the ones that do not
X    make it.  The selection of the winners out of the final round, is
X    less clear cut.
X
X    Sometimes a final round entry good enough to win, but is beat out
X    by a similar, but slightly better entry.  For this reason, it is
X    sometimes worthwhile to re-enter an improved version of an entry
X    that failed to win in a previous year.  This assumes, of course,
X    that the entry is worth improving in the first place!
X
X    More often that not, we select a small entry (usually one line), a
X    strange/creative layout entry, and an entry that abuses the contest
X    rules in some way.
X
X    In the end, we traditionally pick one entry as 'best'.  Sometimes such
X    an entry simply far exceeds any of the other entry.  More often, the
X    'best' is picked because it does well in a number of categories.
X
X
XANNOUNCEMENT OF WINNERS:
X
X    The first announcement, occurs at a Summer Usenix conference.  By tradition,
X    this is done during the latter part of the UUNET/IOCCC BOF, just prior to
X    the Berkeley BSD, and BSDI BOF.
X
X    Winning entries will be posted in late June to the following groups:
X
X	    comp.lang.c		  comp.unix.wizards	alt.sources
X
X    In addition, pointers to these postings are posted to the following
X
X	    comp.sources.d	  alt.sources.d		misc.misc
X	    comp.sources.misc	  comp.windows.x
X
X    Winning entries will be deposited into the uunet archives.  See
X    below for details.
X
X    Often, winning entries are published in selected magazines.  Winners
X    have appeared in books ("The New Hackers Dictionary") and on T-Shirts.
X
X    Last, but not least, winners receive international fame and flames!  :-)
X
X
XFOR MORE INFORMATION:
X
X    You may contact the judges by sending Email to the following address:
X
X	...!{apple,pyramid,sun,uunet}!hoptoad!judges	(not the address for
X	judges@toad.com					 submitting entries)
X
X    Questions and comments about the contest are welcome.
X
X    The rules and the guidelines may (and often do) change from year to	      |
X    year.  You should be sure you have the current rules and guidelines	      |
X    prior to submitting entries.  To obtain them, send Email to the address   |
X    above and use the subject 'send rules'.				      |
X
X    One may obtain winners of previous contests (1984 to date), via ftp from: |
X
X	host: ftp.uu.net	(192.48.96.9)				      |
X	user: anonymous
X	pass: yourname@yourhost
X	dir:  ~/pub/ioccc						      |
X
X    As a last resort, previous winners may be obtained by sending Email	      |
X    to the above address.  Please use the subject 'send YEAR winners',	      |
X    where YEAR is a single 4 digit year, a year range, or 'all'.	      |
X
X
Xchongo <Landon Curt Noll> /\cc/\  	chongo@toad.com			      |
XLarry Bassel			  	lab@sun.com			      |
SHAR_EOF
chmod 0444 guidelines ||
echo "restore of guidelines failed"
set `wc -c guidelines`;Wc_c=$1
if test "$Wc_c" != "25592"; then
	echo original size 25592, current size $Wc_c
fi
echo "End of part 1, continue with part 2"
exit 0