These programs simulate the 'Game of Life'.

This is played on a grid of pixels, which may be on or off.

If a pixel is OFF and has exactly 3 neighbors (adjacent and diagonal),
it turns ON;  otherwise it stays OFF.
If a pixel is ON and has exactly 2 or 3 neighbors, it stays ON;
otherwise it turns OFF.

All changes happen simultaneously.

---------------------------------------------------------------------

There have been a lot of contests for the fastest/smallest Life program.

Here is a description of these Life programs:

---------- LIFE

Simple approach using the boundary count method, quite fast.

---------- LIFE2

This came very close on the smallest contest.  76 bytes.  Color coded,
with current cells in bright orange and last generation's cells in blue.

---------- LIFE3

This won the smallest-program contest.  72 bytes.  Uses a weird trick
with a RCL instruction to calculate the next cell value.

---------- LIFEHI

Bitwise algorithm with a 64K lookup table generated at runtime.
This one is in high-resolution mode, 640x480.  Tied for fastest
real mode version at 6.0 clocks/pixel on a Pentium.

---------- LIFEK

Same algorithm as LIFEHI, but in 320x200 mode.  Tied for fastest
real mode version.

---------- LIFEX

Same algorithm as LIFE, but colorized and with an edit feature:

While running:

  E         = switch to edit mode
  Q, Escape = quit

While editing:

  Enter     = restart
  Arrows    = move cursor
  Space     = flip pixel
  C         = clear field

---------- LIFE4ax

32-bit, calculates 4 pixels at once with simplistic algorithm,
same speed as LIFE and LIFEX overall.

---------- LIFE32, LIFE32H

Bitwise algorithm with a 256K lookup table generated at runtime,
calculates in vertical strips for extra speed (the inner loop is
only 25 lines long!).  LIFE32 is 320x200, and LIFE32H is 640x480.

These are the fastest overall, at 4.5 clocks/pixel on a Pentium.
(This means 700 generations per second on a Pentium-200!!)

---------- QLIFE

Uses souped-up boundary count algorithm calculating 3 pixels at once.
Tied for fastest real-mode version.  Fastest of all for sparse fields
but slower on average than LIFE32.  Also, it's huge (77K compressed).