#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 2 (of 7)."
# Contents:  README.T2 geneban1/0072etq.tie
# Wrapped by ray@life on Mon Nov  4 22:56:31 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'README.T2' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'README.T2'\"
else
echo shar: Extracting \"'README.T2'\" \(50854 characters\)
sed "s/^X//" >'README.T2' <<'END_OF_FILE'
X
X6)  LISTING OF DISTRIBUTION FILES
X
XThe distribution includes the following files:
X
XREADME.T1 & README.T2 - this file, on line documentation
X
Xarg.c - the main module for the assembler/disassembler, written by Tom Uffner.
X     This program converts ascii assembler files into binary files which can
X     be executed by the Tierran virtual computer
X
Xarg.prj - the Turbo C V 2.0 project file for compiling the
X     assember/disassembler
X
Xarginst.h - a file containing a structure used by arg.c to map assembler
X     mnemonics to executable opcodes.
X
Xbookeep.c - source code for bookeeping routines, which keep track of how many
X     of what kind of creatures are in the soup, and other stuff like that.
X
Xccarg - a file for compiling the assembler/disassembler on unix systems.
X     This file should be made executable (chmod +x ccarg).
X
Xcctierra - a file for compiling Tierra on unix systems.
X     This file should be made executable (chmod +x cctierra).
X
Xconfigur.h - a file for configuring Tierra.  You probably won't need to
X     touch this unless you get into advanced stuff.
X
Xdebug.h - this file claims to provide some useful debugging stuff, I don't
X     know, I didn't create it.
X
Xdeclare.h - all global variables are declared in this file, except those
X     whose values are set by soup_in.  Those globals are declared in soup_in.h.
X     declare.h is included by tierra.c which contains the main function.
X
Xdepend - a listing of interdependencies of the source code files
X
Xextern.h - all global variables are delcared as extern in this file, and this
X     file is included by all *.c files except tierra.c which includes
X     delcare.h instead.
X
Xextract.c - functions for extracting creatures from the soup and saving their
X     genomes to disk.
X
Xfrontend.c - functions for handling input/output for Tierra.  Hopefully this
X     module will grow in the near future as we put a better interface on
X     Tierra.
X
Xgenebank.c - functions for managing the genebank.  This module has benefited
X     from a lot of work by Tom Uffner.
X
Xgenio.c - functions for input/output of creatures.  This stuff is also used
X     by arg.c, the assembler/disassembler.  This module has benefited from
X     a lot of work by Tom Uffner.
X
Xinstruct.c - this module contains generalized executable functions.  These
X     generalized functions are mapped to specific functions by the parsing
X     functions in the parse.c module.
X
Xmemalloc.c - functions for handling memory allocation in the soup, the stuff
X     that ``cell membranes'' are made of.
X
Xparse.c - the parsing functions interpret the executable code of the creatures,
X     and map it onto the executable functions contained in the instruct.c
X     module.
X
Xportable.c - functions for portability between operating systems.
X
Xportable.h - definitions for portability between operating systems and
X     architectures.
X
Xprototyp.h - all functions in Tierra are prototyped here.
X
Xqueues.c - queue management functions for the slicer and reaper queues. 
X
Xslicers.c - interchangeable slicer functions.  This file contains some
X     experiments in the allocation of cpu time to creatures.  This is
X     an interesting thing to play with.
X
Xsoup_in - the ascii file read by Tierra on startup, which contains all
X     the global parameters that determine the environment, and a list of
X     creatures to use in innoculating the soup at the start of a run.
X
Xsoup_in.h - this file defines the default values of all the soup_in variables,
X     and defines the instruction set by mapping the assember mnemonics to the
X     opcodes, parser functions, and executables.
X
Xtierra.c - this file contains the main function, and the central code
X     driving the virtual computer.
X
Xtierra.h - this file contains all the structure definitions.  It is a good
X     source of documentation for anyone trying to understand the code.
X
Xtierra.prj - the Turbo C V. 2.0 project file for compiling Tierra.
X
Xtrand.c - random number generation routines from Numerical Recipes in C.
X
Xtsetup.c - routines called when Tierra starts up and comes down.  Tom Uffner
X     has been putting some work into this module as well.
X
Xgeneban1: - a subdirectory containing the genomes of the creatures saved
X     during a run.
X
X0080aaa.tie - the ancestor, written by a human, mother of all other creatures.
X
X0022abn.tie - the smallest non-parasitic self-replicating creature to evolve.
X
X0045aaa.tie - the archtypical parasite
X
X0072etq.tie - a phenomenal example of optimization through evolution,
X     involving the unrolling of the copy loop.
X
Xlist - a list of genotypes in the genebank, which will be read by Tierra
X     at startup.  All genotypes listed in soup_in must also be listed in
X     this file.  This file will be written to when the system is saved.
X     Therefore to start a fresh run, you must start with a fresh copy of
X     the list file.  Therefore we provide the two files below, list4580 and
X     list80, which allow you to make a fresh start either with the genome
X     0080aaa, or 0080aaa and 0045aaa together.
X
Xlist4580 - a fresh list file for starting runs with the genotypes 0080aaa and
X     0045aaa together.  To use this file just copy it to a file named list.
X
Xlist80 - a fresh list file for starting runs with the genotype 0080aaa
X     To use this file just copy it to a file named list.
X
Xtiedat: - a subdirectory where a complete record of births and deaths will
X     be written.
X
Xbreak.1 - a file containing a record of births and deaths.
X
X7)  SOUP_IN PARAMETERS
X
XA typical soup_in file looks like the following:
X
X/* begin soup_in file */
X
Xtierra core: 6-10-91 
X
Xalive = 50            how many millions of instruction will we run
XBrkupSiz = 5120      size of output file in K, named break.1, break.2 ...
XCellsSize = 600       initial size of cells array of structures
Xdebug = 0               0 = off, 1 = on, printf statements for debugging
XDiskOut = 1            output data to disk (1 = on, 0 = off)
XDistFreq = .1       frequency of disturbance, factor of recovery time
XDistProp = .4       proportion of population affected by distrubance
XDivSameGen = 1 cells must produce offspring of same genotype, to stop evolution
XDivSameSiz = 0 cells must produce offspring of same size, to stop size change
XDropDead = 5 stop system if no reproduction in the last x million instructions
XGeneBnker = 1   turn genebanker on and off
XGenebankPath = geneban1/  path for genebanker output
XGenPerBkgMut = 12 mutation rate control by generations ("cosmic ray")
XGenPerFlaw = 16       flaw control by generations
XGenPerMovMut = 8    mutation rate control by generations (copy mutation)
Xhangup = 1            0 = exit on error, 1 = hangup on error for debugging
XMaxFreeBlocks = 500     initial number of structures for memory allocation
XMaxMalMult = 3        multiple of cell size allowed for mal()
XMinCellSize = 8       minimum size for cells
XMinTemplSize = 3       minimum size for templates
XMovPropThrDiv = .7       minimum proportion of daughter cell filled by mov
Xnew_soup = 1          1 = this a new soup, 0 = restarting an old run
XNumCells = 3      number of creatures and gaps used to inoculate new soup
XOutPath = tiedat/  path for data output
XPhotonPow = 1.5               power for photon match slice size
XPhotonWidth = 8               amount by which photons slide to find best fit
XPhotonWord = chlorophill      word used to capture photon
XRamBankSiz = 20000 array size for genotypes in ram, use with genebanker
XSaveFreq = 10        frequency of saving core_out, soup_out and list
XSavThrMem = .015  threshold memory occupancy to save genotype
XSavThrPop = .015  threshold population proportion to save genotype
XSearchLimit = 5
Xseed = 0 seed for random number generator, 0 uses time to set seed
XSizDepSlice = 0  set slice size by size of creature
XSlicePow = 1    set power for slice size, use when SizDepSlice = 1
XSliceSize = 25    slice size when SizDepSlice = 0
XSliceStyle = 2   choose style of determining slice size
XSlicFixFrac = 0   fixed fraction of slice size
XSlicRanFrac = 2   random fraction of slice size
XSoupSize = 60000 size of soup in instructions
XWatchExe = 0     mark executed instructions in genome in genebank
XWatchMov = 0     set mov bits in genome in genebank
XWatchTem = 0     set template bits in genome in genebank
X
X0080aaa
X0045aaa
X0080aaa
X
X/* end soup_in file */
X
XThe meaning of each of these parameters is explained below:
X
Xalive = 50           how many millions of instruction will we run
X
X     This tells the simulator how long to run, in millions of instructions.
X
XBrkupSiz = 5120      size of output file in K, named break.1, break.2 ...
X
X     If this value is set to zero (0) the record of births and deaths will
Xbe written to a single file named tierra.run.  However, if BrkupSiz has a
Xnon-zero value, birth and death records will be written to a series of files
Xwith the names break.1, break.2, etc.  Each of these files will have the
Xsize specified, in K (1024 bytes).  The value 5120 indicates that the
Xbreak files will each be five megabytes in size.  The output file(s) will
Xbe in the path specified by OutPath (see below).  See also DiskOut.
X
XCellsSize = 600       initial size of cells array of structures
X
X     The initial size of the ``cells array'' which contains all the demographic
Xdata, as well as the CPU of each creature.  Due to a bug in the Borland
XTurbo C farrealloc function, care must be taken to be sure that this array
Xis initially large enough that it does not need to be reallocated.  A good
Xrule of thumb is to let CellsSize = SoupSize / 100.  If a compiler other than
XBorland is used, don't worry, any initial value will do.
X
Xdebug = 0               0 = off, 1 = on, printf statements for debugging
X
X     This is used during code development, to turn on and off print statements
Xfor debugging purposes.
X
XDiskOut = 1            output data to disk (1 = on, 0 = off)
X
X     If this parameter is set to zero (0), no birth and death records will
Xbe saved.  Any other value will cause birth and death records to be saved
Xto a file whose name is discussed under BrkupSiz above, in the path discussed
Xunder OutPath below.
X
XDistFreq = .1       frequency of disturbance, factor of recovery time
X
X     The frequency of disturbance, as a factor of recovery time.  This and
Xthe next option control the pattern of disturbance.  If you do not want the
Xsystem to be disturbed, set DistFreq to a negative value.  If DistFreq has
Xa non-negative value, when the soup fills up the reaper will be invoked to
Xkill cells until it has freed a proportion DistProp of the soup.  The system
Xwill then keep track of the time it takes for the creatures to recover from
Xthe disturbance by filling the soup again.  Let's call this recovery time:
Xrtime.  The next disturbance will occur: (rtime X DistFreq) after recovery
Xis complete.  Therefore, if DistFreq = 0, each disturbance will occur
Ximmediately after recovery is complete.  If DistFreq = 1, the time between
Xdisturbances will be twice the recovery time, that is, the soup will remain
Xfull for a period equal to the recovery time, before another disturbance hits.
X
XDistProp = .4       proportion of population affected by distrubance
X
X     The proportion of the soup that is freed of cells by each disturbance.
XThe occurs by invoking the reaper to kill cells until the total amount of
Xfree memory is greater than or equal to: (DistProp X SoupSize).  Note that
Xcells are not killed at random, they are killed off the top of the reaper
Xqueue.
X
XDivSameGen = 0 cells must produce offspring of same genotype, to stop evolution
X
X     This causes attempts at cell division to abort if the offspring is of
Xa genotype different from the parent.  This can be used when the mutation rates
Xare set to zero, to prevent sex from causing evolution.
X
XDivSameSiz = 0 cells must produce offspring of same size, to stop evolution
X
X     Like DivSameGen, but cell division aborts only if the offspring is of
Xa different size than the parent.  Changes in genotype are not prevented,
Xonly changes in size are prevented.
X
XDropDead = 5 stop system if no reproduction in the last x million instructions
X
X     Sometimes the soup dies, such as when mutation rates are too high.
XThis parameter watches the time elapsed since the last cell division, and
Xbrings the system down if it is greater than DropDead million instructions.
X
XGeneBnker = 1   turn genebanker on and off
X
X     The parameter turns the genebanker on and off.  The value zero turns
Xthe genebanker off, any other value turns it on.  With the genebanker off,
Xthe record of births and deaths will contain the sizes of the creatures,
Xbut not their genotypes.  Also no genomes will be saved in the genebank.
XWhen the genebanker is turned on, the record of births and deaths will
Xcontain a three letter unique name for each genotype, as well as the size
Xof the creatures.  Also, any genome whose frequency exceeds the thresholds
XSavThrMem and SavThrPop (see below) will be saved to the genebank, in
Xthe path indicated by GenebankPath (see below).
X
XGenebankPath = geneban1/  path for genebanker output
X
X     This is a string variable which describes the path to the genebank
Xwhere the genomes will be saved.  The path name should be terminated by
Xa forward slash.
X
XGenPerBkgMut = 12    mutation rate control by generations ("cosmic ray")
X
X     Control of the background mutation rate ("cosmic ray").  The value 12
Xindicates that in each generation, roughly one in twelve cells will be hit
Xby a mutation.  These mutations occur completely at random, and also affect
Xfree space where there are no cells.  If the value of GenPerBkgMut were 0.5,
Xit would mean that in each generation, each cell would be hit by roughly
Xtwo mutations.
X
XGenPerFlaw = 16       flaw control by generations
X
X     Control of the flaw rate.  The value 16 means that in each generation,
Xroughly one in sixteen individuals will experience a flaw.  Flaws cause
Xinstructions to produce results that are in error by plus or minus one,
Xin some sense.  If the value of GenPerFlaw were 0.5, it would mean that in
Xeach generation, each cell would be hit by roughly two flaws.
X
XGenPerMovMut = 8    mutation rate control by generations (copy mutation)
X
X     Control of the move mutation rate (copy mutation).  The value 8
Xindicates that in each generation, roughly one in eight cells will be hit
Xby a mutation.  These mutations only affect copies of instructions made
Xduring replication (by the double indirect mov instruction).  When an
Xinstruction is affected by a mutation, one of its five bits is selected
Xat random and flipped.  If the value of GenPerMovMut were 0.5, it would
Xmean that in each generation, each cell would be hit by roughly two mutations.
X
Xhangup = 1            0 = exit on error, 1 = hangup on error for debugging
X
X     If an error occurs which is serious enough to bring down the system,
Xhaving hangup set to 1 will prevent the program from exiting.  In this case,
Xthe program will hang in a simple loop so that it remains active for
Xdebugging purposes.
X
XMaxFreeBlocks = 500     initial number of structures for memory allocation
X
X     There is an array of structures used for the virtual memory allocator.
XThis parameter sets the initial size of the allocated array, at startup.
X
XMaxMalMult = 3        multiple of cell size allowed for mal()
X
X     When a cell attempts to allocate a second block of memory (presumably
Xto copy its genome into), this parameter is checked.  If the amount of memory
Xrequested is greater than MaxMalMult times the size of the mother cell, the
Xrequest will fail.  This prevents mutants from requesting the entire soup,
Xwhich would invoke the reaper to cause a massive kill off.
X
XMinCellSize = 8       minimum size for cells
X
X     When a cell attempts to divide, this parameter is checked.  If the
Xdaughter cell would be smaller than MinCellSize instructions, divide will
Xfail.  The reason this is needed is that with no lower limit, there is a
Xtendency for some mutants to spawn large numbers of very small cells.
X
XMinTemplSize = 3       minimum size for templates
X
X     When an instruction (like jump) attempts to use a template, this parameter
Xis checked.  If the actual template is smaller than MinTemplSize instructions,
Xthe instruction will fail.  This is a matter of taste.
X
XMovPropThrDiv = .7       minimum proportion of daughter cell filled by mov
X
X     When a cell attempts to divide, this parameter is checked.  If the mother
Xcell has moved less than MovPropThrDiv times the mother cell size, of
Xinstructions into the daughter cell, cell division will abort.  A value of .7
Xmeans that the mother must at least fill the daughter 70% with instructions
X(though all these instructions could have been moved to the same spot in
Xthe daughter cell).  The reason this parameter exists is that without it,
Xmutants will attempt to spew out large numbers of empty cells.
X
Xnew_soup = 1          1 = this a new soup, 0 = restarting an old run
X
X     This value is checked on startup, to determine if this is a new soup,
Xor if this is restarting an old run where it left off.  When the system
Xcomes down, all soup_in parameter (and many other global variables) are
Xsaved in a file called soup_out.  The value of new_soup is set to 0 in
Xsoup_out.  In order to restart an old run, just use soup_out as the input
Xfile rather than soup_in.  This is done by using soup_out as a command line
Xparameter at startup: tierra soup_out
X
XNumCells = 5      number of creatures and gaps used to inoculate new soup
X
X     This parameter is checked at startup, and the system will look for a
Xlist of NumCells creatures at the end of the soup_in file.  The value 5
Xindicates that the soup will initially be innoculated by five cells.
XHowever, NumCells also counts gaps that are placed between cells (without
Xgaps, all cells are packed together at the bottom of the soup at startup).
XThe gap control feature does not work at present, so don't use it.  Notice
Xthat after the list of parameters in the soup_in file, there is a blank
Xline, followed by a list of genotypes.  The system will read the first 
XNumCells genotypes from the list, and place them in the soup in the same
Xorder that they occur in the list.
X
XOutPath = tiedat/  path for data output
X
X     The record of births and deaths will be written to files in a directory
Xspecified by OutPath.  See BrkupSiz above for a discussion of the name of
Xthe file(s) containing the birth and death records.
X
XPhotonPow = 1.5         power for photon match slice size
X
X     If SliceStyle (see below) is set to the value 1, then the allocation
Xof CPU cycles to creatures is based on a photon - chlorophyll metaphor.
XImagine that photons are raining down on the soup at random.  The cell hit
Xby the photon gets a time slice that is proportional to the goodness of fit
Xbetween the pattern of instructions that are hit, and an arbitrary pattern
X(defined by PhotonWord, see below).
X
X     The template of instructions defined by PhotonWord is laid over the
Xsequence of instructions at the site hit by the photon.  The number of
Xinstructions that match between the two is used to determine the slice
Xsize.  However, the number of matching instructions is raised to the power
XPhotonPow, to calculate the slice size.
X
XPhotonWidth = 8   amount by which photons slide to find best fit
X
X     When a photon hits the soup, it slides a distance PhotonWidth, counting
Xthe number of matching characters at each position, and the slice size will
Xbe equal to the number of characters in the best match (raised to the power
XPhotonPow, see above).  If PhotonWidth equals 8, the center of the template
Xwill start 4 instructions to the left of the site hit by the photon, and
Xslide to 4 instructions to the right of the site hit.
X
XPhotonWord = chlorophill  word used to capture photon
X
X     This string determines the arbitrary pattern that absorbs the photon.
XIt uses a base 32 numbering system: the digits 0-9 followed by the characters
Xa-v.  The characters w, x, y and z are not allowed (that is why chlorophyll
Xis misspelled).  The string may be any length up to 79 characters.
X
XRamBankSiz = 20000 array size for genotypes in ram, use with genebanker
X
X     Places an upper limit on the number of genomes that may be stored
Xin the genebank maintained in RAM at any one time.  This is a memory
Xmanagement feature provided for DOS systems.  When the RAM genebank
Xfills, genomes start swapping out to disk.  The genomes that have not
Xbeen checked for the longest time are swapped out first.  At this time
Xthe RAM bank management scheme does not work.  For this reason, you should
Xbe sure that this parameter is set high enough that the bank does not
Xfill up during the run.
X
XSaveFreq = 10        frequency of saving core_out, soup_out and list
X
X     Every SaveFreq million instructions, the complete state of the
Xvirtual machine is saved.  This is a useful feature for long runs, so that
Xthe system can be restarted if it is interrupted for some reason.
X
XSavThrMem = .015  threshold memory occupancy to save genotype
X
X     If a particular genotype fills SavThrMem of the total space available
Xin the soup, it will be assigned a permanent unique name, and saved to disk.
XNote that an adjustment is made because only adult cells are counted, and
Xembryos generally fill half the soup.  Therefore adult cells of a particular
Xgenotype need only occupy SavThrMem * 0.5 of the space to be saved.
X
XSavThrPop = .015  threshold population proportion to save genotype
X
X     If a particular genotype amounts to SavThrPop of the total population
Xof (adult) cells in the soup, it will be assigned a permanent unique name,
Xand saved to disk.
X
XSearchLimit = 5
X
X     This parameter controls how far instructions may search to match
Xtemplates.  The value five means that search is limited to five times the
Xaverage adult cell size.  The actual distance is updated every million
Xinstructions.
X
Xseed = 0 seed for random number generator, 0 uses time to set seed
X
X     The seed for the random number generator.  If you use the value zero,
Xthe system clock is used to set the seed.  If you use any other value, it
Xwill be the seed.  The starting seed (even when provided by the clock) will
Xbe written to standard output, and also saved in the soup_out file when the
Xsimulator comes down.  By using the original seed and all the same initial
Xparameter settings in soup_in, a run may be repeated exactly.
X
XSizDepSlice = 0  set slice size by size of creature
X
X     This determines a major slicer option.  If this parameter is set to
Xzero, the slice size will either be a constant set by SliceSize (see below)
Xor a uniform random variate, or a mix of the two.  The mix is determined by
Xthe relative values of SlicFixFrac and SlicRanFrac (see below).  The actual
Xslice size will be:
X
X(SlicFixFrac * SliceSize) + (tlrand() % (I32s) ((SlicRanFrac * SliceSize) + 1))
X
X     If SizDepSlice is set to a non-zero value, the slice size will be
Xproportional to the size of the genome.  In this case, the base slice size
Xwill be the genome size raised to the power SlicePow (see below).  To clarify
Xlet slic_siz = genome_size ^ SlicePow, the actual slice size will be:
X
X(SlicFixFrac * slic_siz) + (tlrand() % (I32s) ((SlicRanFrac * slic_siz) + 1))
X
XSlicePow = 1    set power for slice size, use when SizDepSlice = 1
X
X     This parameter is only used when SizDepSlice = 1.  In this case, the
Xgenome size is raised to the power SlicePow to determine the slice size
X(see algorithm under SizDepSlice above).  If SlicePow = 1, the run will be
Xsize neutral, selection will not be biased toward either large or small
Xcreatures (the probability of an instruction being executed is not dependent
Xon the size of the genome it is located in).  If SlicePow > 1, selection will
Xfavor larger genomes.  If SlicePow < 1, selection will favor small genomes.
X
XSliceSize = 25    slice size when SizDepSlice = 0
X
X     This parameter determines the base slice size when SizDepSlice = 0.
XThe actual slice size in this case depends on the values of SlicFixFrac
Xand SlicRanFrac (see below).  The way the slice size is actually calculated
Xis explained under SizDepSlice above.
X
XSliceStyle = 2   choose style of determining slice size
X
X     The slicer is a pointer to function, and the function actually used
Xis determined by this parameter.  At present there are three choices (0-2).
XThe pointer to function is assigned in the setup.c module, and the slicer
Xfunctions themselves are contained in the slicers.c module.
X0 = SlicerQueue() - slice sizes without a random component
X1 = SlicerPhoton() - slice size based on photon interception metaphor
X2 = RanSlicerQueue() - slice size with a fixed and a random component
X
XSlicFixFrac = 0   fixed fraction of slice size
X
X     When SliceStyle = 2, the slice size has a fixed component and a random
Xcomponent.  This parameter determines the fixed component as a multiple
Xof SliceSize, or genome_size ^ SlicePow.
X
XSlicRanFrac = 2   random fraction of slice size
X
X     When SliceStyle = 2, the slice size has a fixed component and a random
Xcomponent.  This parameter determines the random component as a multiple
Xof SliceSize, or genome_size ^ SlicePow.
X
XSoupSize = 60000 size of soup in instructions
X
X     This variable sets the size of the soup, measured in instructions.
X
XWatchExe = 0     mark executed instructions in genome in genebank
X
X     If the genebank is on, setting this parameter to a non-zero value
Xwill turn on a watch of which instructions are being executed in each
Xpermanent genotype (this helps to distinguish junk code from code that is
Xexecuted), and also, who is executing whose instructions.  There
Xis a bit field in struct g_list (bit definitions are defined in the tierra.h
Xmodule) that keeps track of whether a creature executes its own instructions,
Xthose of another creature, if another creature executes this creatures
Xinstructions, etc:
X
X    bit  2  EXs = executes own instructions (self)
X    bit  3  EXd = executes daughter's instructions
X    bit  4  EXo = executes other cell's instructions
X    bit  5  EXf = executes instructions in free memory
X    bit  6  EXh = own instructions are executed by other creature (host)
X
XWatchMov = 0     set mov bits in genome in genebank
X
X     If the genebank is on, setting this parameter to a non-zero value
Xwill turn on a watch of who moves whose instructions and where.  This
Xinformation is recorded in the bit field in struct g_list:
X
X    bit 17  MFs = moves instruction from self
X    bit 18  MFd = moves instruction from daughter
X    bit 19  MFo = moves instruction from other cell
X    bit 20  MFf = moves instruction from free memory
X    bit 21  MFh = own instructions are moved by other creature (host)
X    bit 22  MTs = moves instruction to self
X    bit 23  MTd = moves instruction to daughter
X    bit 24  MTo = moves instruction to other cell
X    bit 25  MTf = moves instruction to free memory
X    bit 26  MTh = is written on by another creature (host)
X    bit 27  MBs = executing other creatures code, moves inst from self
X    bit 28  MBd = executing other creatures code, moves inst from daughter
X    bit 29  MBo = executing other creatures code, moves inst from other cell
X    bit 30  MBf = executing other creatures code, moves inst from free memory
X    bit 31  MBh = other creature uses another cpu to move your instructions
X
XWatchTem = 0     set template bits in genome in genebank
X
X     If the genebank is on, setting this parameter to a non-zero value
Xwill turn on a watch of whose templates are matched by whom.  This
Xinformation is recorded in the bit field in struct g_list:
X
X    bit  7  TCs = matches template complement of self
X    bit  8  TCd = matches template complement of daughter
X    bit  9  TCo = matches template complement of other
X    bit 10  TCf = matches template complement of free memory
X    bit 11  TCh = own template complement is matched by other creature (host)
X    bit 12  TPs = uses template pattern of self
X    bit 13  TPd = uses template pattern of daughter
X    bit 14  TPo = uses template pattern of other
X    bit 15  TPf = uses template pattern of free memory
X    bit 16  TPh = own template pattern is used by other creature (host)
X
X0080aaa
X0045aaa
X0080aaa
X0045aaa
X0080aaa
X
X     This is the list of cells that will be loaded into the soup when
Xthe simulator starts up.  This example indicates that five cells will
Xbe loaded at startup, the ancestor 0080aaa alternating with the parasite
X0045aaa.  These cells will be loaded in the bottom of the soup, with no
Xspace between them.  Only NumCells genotypes from the list will actually
Xbe loaded, so the NumCells parameter should be modified when you change
Xthe number of genotypes that you wish to have loaded.  Also, all genotypes
Xto be loaded must also be listed in the file geneban1/list, and all of the
Xgenotypes must occur in the genebank.
X
X8)  THE ANCESTOR & WRITING A CREATURE
X
X  8.1) The Ancestor
X
X     The ASCII assembler code file with comments, for the ancestor, is listed
Xbelow.  Below the listing I have some explanatory material.
X
X**** begin genome file (note blank line at head of file)
X
Xformat: 1  bits: 45750471  EXsh TCsh TPs MFsofh MTdf MB
Xgenotype: 0080aaa  parent genotype: 0666god
X1st_daughter:  flags: 0  inst: 827  mov_daught: 80  breed_true: 1
X2nd_daughter:  flags: 0  inst: 809  mov_daught: 80  breed_true: 1
XInstExe.m: 0  InstExe.i: 0  origin: 662270168  Wed Dec 26 22:56:08 1990
XMaxPropPop: 0.8306  MaxPropInst: 0.4239
Xploidy: 1  track: 0
X
Xtrack 0: prot
X          xwr
Xnop_1   ; 010 110 01   0 beginning marker
Xnop_1   ; 010 110 01   1 beginning marker
Xnop_1   ; 010 110 01   2 beginning marker
Xnop_1   ; 010 110 01   3 beginning marker
Xzero    ; 010 110 04   4 put zero in cx
Xor1     ; 010 110 02   5 put 1 in first bit of cx
Xshl     ; 010 110 03   6 shift left cx (cx = 2)
Xshl     ; 010 110 03   7 shift left cx (cx = 4)
Xmov_cd  ; 010 110 18   8 move cx to dx (dx = 4)
Xadrb    ; 010 110 1c   9 get (backward) address of beginning marker -> ax
Xnop_0   ; 010 100 00  10 complement to beginning marker
Xnop_0   ; 010 100 00  11 complement to beginning marker
Xnop_0   ; 010 100 00  12 complement to beginning marker
Xnop_0   ; 010 100 00  13 complement to beginning marker
Xsub_ac  ; 010 110 07  14 subtract cx from ax, result in ax
Xmov_ab  ; 010 110 19  15 move ax to bx, bx now contains start address of mother
Xadrf    ; 010 110 1d  16 get (forward) address of end marker -> ax
Xnop_0   ; 010 100 00  17 complement to end marker
Xnop_0   ; 010 100 00  18 complement to end marker
Xnop_0   ; 010 100 00  19 complement to end marker
Xnop_1   ; 010 100 01  20 complement to end marker
Xinc_a   ; 010 110 08  21 increment ax, to include dummy instruction at end
Xsub_ab  ; 010 110 06  22 subtract bx from ax to get size, result in cx
Xnop_1   ; 010 110 01  23 reproduction loop marker
Xnop_1   ; 010 110 01  24 reproduction loop marker
Xnop_0   ; 010 110 00  25 reproduction loop marker
Xnop_1   ; 010 110 01  26 reproduction loop marker
Xmal     ; 010 110 1e  27 allocate space (cx) for daughter, address to ax
Xcall    ; 010 110 16  28 call template below (copy procedure)
Xnop_0   ; 010 100 00  29 copy procedure complement
Xnop_0   ; 010 100 00  30 copy procedure complement
Xnop_1   ; 010 100 01  31 copy procedure complement
Xnop_1   ; 010 100 01  32 copy procedure complement
Xdivide  ; 010 110 1f  33 create independent daughter cell
Xjmp     ; 010 110 14  34 jump to template below (reproduction loop)
Xnop_0   ; 010 100 00  35 reproduction loop complement
Xnop_0   ; 010 100 00  36 reproduction loop complement
Xnop_1   ; 010 100 01  37 reproduction loop complement
Xnop_0   ; 010 100 00  38 reproduction loop complement
Xif_cz   ; 010 000 05  39 dummy instruction to separate templates
Xnop_1   ; 010 110 01  40 copy procedure template
Xnop_1   ; 010 110 01  41 copy procedure template
Xnop_0   ; 010 110 00  42 copy procedure template
Xnop_0   ; 010 110 00  43 copy procedure template
Xpush_ax ; 010 110 0c  44 push ax onto stack
Xpush_bx ; 010 110 0d  45 push bx onto stack
Xpush_cx ; 010 110 0e  46 push cx onto stack
Xnop_1   ; 010 110 01  47 copy loop template
Xnop_0   ; 010 110 00  48 copy loop template
Xnop_1   ; 010 110 01  49 copy loop template
Xnop_0   ; 010 110 00  50 copy loop template
Xmov_iab ; 010 110 1a  51 move contents of [bx] to [ax] (copy one instruction)
Xdec_c   ; 010 110 0a  52 decrement cx (size)
Xif_cz   ; 010 110 05  53 if cx == 0 perform next instruction, otherwise skip it
Xjmp     ; 010 110 14  54 jump to template below (copy procedure exit)
Xnop_0   ; 010 110 00  55 copy procedure exit complement
Xnop_1   ; 010 110 01  56 copy procedure exit complement
Xnop_0   ; 010 110 00  57 copy procedure exit complement
Xnop_0   ; 010 110 00  58 copy procedure exit complement
Xinc_a   ; 010 110 08  59 increment ax (address in daughter to copy to)
Xinc_b   ; 010 110 09  60 increment bx (address in mother to copy from)
Xjmp     ; 010 110 14  61 bidirectional jump to template below (copy loop)
Xnop_0   ; 010 100 00  62 copy loop complement
Xnop_1   ; 010 100 01  63 copy loop complement
Xnop_0   ; 010 100 00  64 copy loop complement
Xnop_1   ; 010 100 01  65 copy loop complement
Xif_cz   ; 010 000 05  66 this is a dummy instruction to separate templates
Xnop_1   ; 010 110 01  67 copy procedure exit template
Xnop_0   ; 010 110 00  68 copy procedure exit template
Xnop_1   ; 010 110 01  69 copy procedure exit template
Xnop_1   ; 010 110 01  70 copy procedure exit template
Xpop_cx  ; 010 110 12  71 pop cx off stack (size)
Xpop_bx  ; 010 110 11  72 pop bx off stack (start address of mother)
Xpop_ax  ; 010 110 10  73 pop ax off stack (start address of daughter)
Xret     ; 010 110 17  74 return from copy procedure
Xnop_1   ; 010 100 01  75 end template
Xnop_1   ; 010 100 01  76 end template
Xnop_1   ; 010 100 01  77 end template
Xnop_0   ; 010 100 00  78 end template
Xif_cz   ; 010 000 05  79 dummy instruction to separate creature
X**** end genome file
X
X     Each genome file begins with some header information.  Let me explain
Xeach item:
X
X     format: 1  because we occasionally change the format of the genome files,
Xthis parameter is included for backwards compatibility.  It is used by the
Xassembler/disassembler to know how to read and write the files.
X
X     bits: 45750471  this is the bit field associated with each genome in the
Xgenebank.  If the genebanker is on and if any of the parameters: WatchExe,
XWatchMov, or WatchTem are set to a non-zero value, then bits in this field
Xwill be set to characterize the ecological characteristics of the genotype.
XThe definitions of the bits in the field are given in the tierra.h module,
Xand above in the description of the soup_in parameters.  For more specific
Xdetails, follow the Watch variables in the source modules to see exactly what
Xthey are doing.
X
X     EXsh TCsh TPs MFsofh MTdf MB this is an ASCII summary of the meaning of
Xthe bits that are set in the bit field.  The meanings of these abbreviations
Xare given in the tierra.h file and above in the description of the soup_in
Xparameters.
X
X     genotype: 0080aaa  This is the name of this genotype.  The name has two
Xparts.  The first part is numeric and must be equal to the size of the cell
Xof this creature (how large is its allocated block of memory).  The cell size
Xusually, but not always, corresponds to the size of the genome.  The second
Xpart is a unique (and arbitrary) three letter code to distinguish this
Xparticular genotype from others of the same size.
X
X     parent genotype: 0666god  This is the name of the genotype of the
Ximmediate ancestor of this genotype.  The immediate ancestor is the creature,
Xwhose cpu gave rise to the first individual of this genotype.  The original
Xcreature, 0080aaa was created by god and the devil.
X
X     1st_daughter:  This is a set of metabolic data about what transpired
Xduring the production of the first daughter by this genotype.  flags: 0  This
Xtells us how many errors (flags) were generated during the first reproduction.
XThe generation of errors indicates invalid execution of instructions and causes
Xthe creature to move up the reaper queue, closer to death.  inst: 827  This
Xtells us how many instructions were executed during the first reproduction,
Xthis is an indication of metabolic costs and efficiency.  mov_daught: 80  This
Xtells us how many instructions were copied from the mother to the daughter
Xduring the first reproduction.  breed_true: 1  This tells us if the first
Xdaughter ever has the same genotype as the mother.
X
X     2nd_daughter:  flags: 0  inst: 809  mov_daught: 80  breed_true: 1
XThis is a set of metabolic data about what transpired during the production
Xof the second daughter by this genotype.  The data are the same as those
Xfrom the first daughter.  The second daughter and those that follow generally
Xhave the same metabolic data, but they also generally differ from the first
Xdaughter, because the second time through, the parent often does not examine
Xitself again, and it does not start the algorithm from the same place.
X
X     InstExe.m: 0  At the time this genotype first appeared, the system had
Xexecuted this many millions of instructions, plus the remainder indicated
Xby the InstExe.i parameter.
X
X     InstExe.i: 0  At the time this genotype first appeared, the system had
Xexecuted this many instructions, plus however many millions indicated by
Xthe InstExe.m parameter.
X
X     origin: 662270168  This is the system clock time at the first origin
Xof this genotype.
X
X     Wed Dec 26 22:56:08 1990  This is the system clock time at the first
Xorigin of this genotype.
X
X     MaxPropPop: 0.8306  The maximum proportion of the population of cells of
Xadult cells in the soup, attained by this genotype.
X
X     MaxPropInst: 0.4239  The maximum proportion of space in the soup attained
Xby adults of this genotype.
X
X     ploidy: 1  The ploidy level of this genotype (i.e., this genotype
Xis haploid).
X
X     track: 0  Which copy of the genome will start executing at birth.  This
Xis only used when the ploidy level is greater than one (i.e., diploid).
X
Xtrack 0: prot
X          xwr
Xnop_1   ; 010 110 01   0 beginning marker
X
X     track 0: prot  This tells us that the assembler code that follows is
Xtrack one.  If the genotype has a ploidy of 2, a second assembler listing
Xwill follow, and it will be labeled track 1.  The word prot refers to the
Xprotection bits: xwr, or x = execute, w = write, r = read.
X
Xnop_1   ; 010 110 01   0 beginning marker
X
X     This is the first line of the actual genome.  The first word, nop_1 is
Xthe assembler mnemonic for one of the two no-operation instructions.  The
Xsemicolon indicates the beginning of comments.
X
X     The digits 010 tell us what protection this instruction will have at
Xbirth.  Only the write bit is set, so this instruction will be write protected,
Xbut open to reading or execution at birth.
X
X     The digits 110 are a record of which instructions were executed by this
Xcreature's own CPU (first digit), and the CPUs of other creatures' (second
Xdigit), the third digit is not used at present.  These bits are set when the
XWatchExe parameter is set.  That the first two digits are set to one indicates
Xthat this instruction was executed both by its own CPU and by the CPU of
Xanother creature (perhaps a parasite, or a lost instruction pointer).
X
X     The digits 01 are the actual hexadecimal op code of the instruction.  It
Xis this value that will actually be stored in the soup.
X
X     The digit 0 just before the words ``beginning marker'' is a count of
Xthe Nth instruction in the genome.  This is the first instruction, so it is
Xnumbered zero.
X
X     The words ``beginning marker'' are a comment describing the intended
Xpurpose of this instruction.
X
X     If you study the code of the ancestor, you may be perplexed by the
Xreason for including the following instructions:
X
Xzero    ; 010 110 04   4 put zero in cx
Xor1     ; 010 110 02   5 put 1 in first bit of cx
Xshl     ; 010 110 03   6 shift left cx (cx = 2)
Xshl     ; 010 110 03   7 shift left cx (cx = 4)
Xmov_cd  ; 010 110 18   8 move cx to dx (dx = 4)
X
X     In the original version of the simulator, the size of the templates
Xwas determine by the value in the dx register.  These five instructions
Xloaded the dx register with the value 4, which is the size of the templates
Xin this creature.  Later, it was decided that this was a stupid way to
Xdetermine template sizes.  Now the parser just looks to see how many nops
Xfollow any instruction using them, and the number of consecutive nops determine
Xthe template size.  Therefore, these five instructions don't do any useful
Xwork in the present model, but they have been left in place because the code
Xstill works.
X
X  8.2) Writing a Creature
X
X     If you write your own creature, you must obey the following conventions:
X
X**** begin genome file (note blank line at top of file)
X
Xformat: 1  bits: 3
Xgenotype: 0080aaa  parent genotype: 0666god
X
Xtrack 0: prot
X          xwr
Xnop_1   ; 010
Xnop_1   ; 010
X**** end genome file
X
X     Yank the above lines into the file you are going to write, to use as
Xa template.  You must have the following:
X
X     1) a blank line at the top of the file.
X     2) a line declaring the format and bits, just use the line given.
X     3) a line stating the genome size and three letter name, and that of
X        the parent genotype.  The genome size must match the actual number
X        of instructions in the genome.  The three letter name is arbitrary,
X        you can make up any name, but I advise using a low letter name like
X        aaa because these names are used in a base 26 numbering system by
X        the genebanker, and the genebanker must allocate an array as big
X        as the largerst of these numbers.  You may make up the parent genotype
X        size and age, it won't be used for anything, so its details don't
X        matter, but it should have the format of four numeric digits followed
X        by three letters.
X     4) a blank line
X     5) the line: track 0: prot, just use the line provided
X     6) the line:           xwr, just use the line provided
X     7) the listing of assembler mnemonics, followed by a semicolon and a
X        three digit code indicating the protection at birth.  I recomment that
X        you use the protection indicated.  The listing of the 32 assembler
X        mnemonics can be found at the end of the soup_in.h file.  For a
X        description of what they actually do, study the comments on the
X        code of the ancestor listed above, and study the corresponding
X        parser and execute functions in the two modules in parse.c and
X        instruct.c.
X
X9)  IF YOU WANT TO MODIFY THE SOURCE CODE
X
X     If you make some significant improvements to Tierra, we would welcome
Xreceiving the source code, so that we may integrate it into our version, and
Xthen make it available to others.
X
X     All lines of source code should be 78 characters or less, or it will
Xmess up the formatting of the code for distribution.
X
X     The simulator has been designed so that it can be brought down, and then
Xbrought back up where it left off.  This means that there can be no static
Xlocal variables.  Any variables that hang around must be global.  They
Xare declared and defined in soup_in.h if they are also soup_in parameters.
XOtherwise they are declared in declare.h, and all global variables are
Xdeclared as externals in extern.h.
X
X     The code for bringing the simulator up and down is in the tsetup.c
Xmodule.  The system is brought up by GetSoup(), which calls GetAVar()
Xto read soup_in.  All soup_in variables are read by the GetAVar() function.
XIf a new simulation is being started, GetSoup() calls GetNewSoup().  If an
Xold simulation is being restarted, GetSoup() calls GetOldSoup().  GetOldSoup()
Xwill read all global variables not contained in soup_in, and will also read
Xin all arrays, such as the soup, the cells array, and the free_mem array.
XWhen the simulator goes down, and periodically during a run, all global
Xvariables are written to a file soup_out, and all global arrays such as
Xsoup, the cells array, the free_mem array, and the random number generator
Xarray, and some structures, are written to a binary file called core_out.
XThus if you create any new global variables or arrays, be sure they are read
Xby GetOldSoup(), and written by WriteSoup().
X
X     There are several obvious projects that I would like to comment on:
X
X  9.1) Creating a Frontend
X
X     All I/O to the console is routed through the frontend.c module, so that
Xit can be handled by a variety of front ends now under development.  The
Xsimplest of these just uses printf to write to standard out.  The frontend.c
Xmodule is just a sketch at the moment.  If your are going to work on the
Xfrontend, please get back to us for an updated version of the frontend.c
Xmodule.  The module is guaranteed to have been completely rewritten by the
Xend of October 1991.
X
X  9.2) Creating New Instruction Sets
X
X     If you want to create a new instruction set, more power to you.  The
Xrelevant modules to study are: instruct.c, parse.c, soup_in.h, arginst.h, and
Xconfigur.h.  You will also need to study the definitions of struct cpu,
Xstruct InstDef, struct ArgInstDef, and struct inst, all in the tierra.h module.
XNote that the cpu structure includes an array of registers.  The idea is that
Xyou may change the size of this array to make just about any changes you might
Xwant to the CPU architecture.  You should avoid actually having to alter the
Xstructure definition in the tierra.h file.
X
X  9.3) Creating New Slicer Mechanisms
X
X     If you want to experiment with artificial rather than natural selection,
Xconsider that selection is both a carrot and a stick.  The carrot in this
Xmodel is CPU time which is allocated by the slicers.  The stick is the reaper.
XIf you want to try to evolve algorithms that do useful work, your evaluation
Xfunctions should be embedded into the slicer, and should allocate more CPU
Xtime to creatures who rank high.
X
X  9.4) Creating a Sexual Model
X
X     Sex emerges spontaneously in runs whenever parasites appear.  However,
Xthis sex is primitive and disorganized.  I believe that the easiest way to
Xengineer organized sex is to work with diploid creatures.  The infrastructure
Xto allow multiple ploidy levels is already in place.  Notice that the
Xdefinition of Instruction, the type of which the soup is composed is:
X
Xtypedef struct Inst  Instruction[PLOIDY];
X
X     This means that if PLOIDY is defined as two, there are two parallel
Xtracks for genomes.  The instruction pointer will run down the track
Xspecified by the ce->c.tr variable in the cpu structure.  We have not
Ximplemented any other controls over the tracking of the instruction pointer
Xin diploid or higher models.  This is future work.
X
X  9.5) Creating a Multi-cellular Model
X
X     Multi-cellularity was the hallmark of the Cambrian explosion of
Xdiversity, and thus is likely a biological feature worth including in Tierra.
XAlso, it is likely that a multi-cellular model is the appropriate one for
Xevolving large application programs on massively parallel machines.  How
Xcan we implement multi-cellularity?  What does it mean in the context of
XTierran creatures?
X
X     Consider that at the conceptual core, multi-cellularity means that the
Xmother cell determines what portion of the genome its daughter cell will
Xexpress.  For many daughter cells, the mother cells narrows their options
Xby preventing them from expressing (executing) large portions of their
Xgenome (code).  In the organic world this is done by loading the daughter
Xcell with regulatory proteins which determine which genes will be expressed.
X
X     In the Tierran world, the same result can be achieved by allowing the
Xmother cell to set the position of the instruction pointer in the daughter
Xcell, and also the initial values of the CPU registers.  These acts can
Xplace the daughter cell into a portion of its code from which it may never
Xbe able to reach certain other parts of its code.  In this way the mother
Xcell determines what parts of the code are executed by the daughter.
X
X     To facilitate this process, the divide instruction has been broken into
Xthree steps: 1) Create and initialize a CPU for the daughter.  2) Start the
Xdaughter CPU running.  3) Become independent from the daughter by loosing
Xwrite privelages on the daughter space.  Now, between steps 1 and 2, the
Xmother can place values into the CPU registers and instruction pointer of
Xthe daughter.  This will require and inter-CPU move instruction.  The divide
Xinstruction takes an argument that determines which of the three steps is
Xbeing performed.
X
X10) KNOWN BUGS
X
X     When Tierra runs, if the genebanker is on, a growing number of genomes
Xwill accumulate in RAM, causing memory useage to increase throughout a run.
XThis will eventually lead to a memory allocation failure on DOS systems, or
Xto thrashing on Unix systems due to the need to use virtual memory.  The
Xparameter RamBankSiz is designed to prevent the accumulation of too many
Xgenomes in the RAM bank, by swapping out the least used genomes when there
Xare more than RamBankSize genomes in the genebank.  At present this memory
Xmanagement does not work.  Even when this is fixed, memory demands will
Xstill grow during a run because the genebanker must keep track of genomes
Xswapped out to disk.
X
X     When compiled with a Borland C compiler, Tierra will use the farrealloc()
Xfunction to realloc several arrays during a run.  The farrealloc() function
Xis supposed to be able to reallocate arrays larger than 64K.  Unfortunately
Xthe function does not work for arrays larger than 64K in most versions of
XBorland's compilers.  The most recent versions of Borland C++ have fixed this
Xbug.  If you have an older version of the compiler, you can usually avoid
Xthe problem by setting CellsSize = SoupSize / 100
XThis should prevent the need to reallocate the Cells array, which is what
Xusually generates the problem.  Just be sure that the initial value of
XCellsSize is large enough that it does not need to be increased.
X
X     When the system is brought down, and then brought back up where it left
Xoff, it continues writing birth and death records to the tierra.run or
Xbreak.X files.  However, if the system comes down due to being killed or
Xdue to a hardware crash, when it is brought back up, it will resume execution
Xfrom the state when the simulator was last saved (see SaveFreq variable
Xin section 5 above).  The problem is that the birth and death records will
Xnow be appended to the end of the a file that contained all records up to the
Xlast buffered write before the crash.  This means that the last part of the
Xbirth and death records will be incorrect.  This bug will be fixed soon.
X
X                             Tom Ray
X                       University of Delaware
X                  School of Life & Health Sciences
X                      Newark, Delaware  19716
X                     ray@tierra.slhs.udel.edu
X                      ray@life.slhs.udel.edu
X                        ray@brahms.udel.edu
X                         302-451-2281 (FAX)
X                            302-451-2753
END_OF_FILE
if test 50854 -ne `wc -c <'README.T2'`; then
    echo shar: \"'README.T2'\" unpacked with wrong size!
fi
# end of 'README.T2'
fi
if test -f 'geneban1/0072etq.tie' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'geneban1/0072etq.tie'\"
else
echo shar: Extracting \"'geneban1/0072etq.tie'\" \(2186 characters\)
sed "s/^X//" >'geneban1/0072etq.tie' <<'END_OF_FILE'
X
Xformat: 1  bits: 2  EX TC TP MF MT MB
Xgenotype: 0072etq  parent genotype: 0072fon
X1st_daughter:  flags: 14  inst: 232  mov_daught: 36  breed_true: 1
X2nd_daughter:  flags: 13  inst: 228  mov_daught: 36  breed_true: 0
XInstExe.m: 15289  InstExe.i: 800022  origin: 667500367 Mon Feb 25 11:46:07 1991
XMaxPropPop: 0.0025  MaxPropInst: 0.0012
Xploidy: 1  track: 0
X
Xtrack 0: prot
X          xwr
Xnop_1   ; 010 000 01   0
Xadrb    ; 010 000 1c   1
Xnop_0   ; 010 000 00   2
Xdivide  ; 010 000 1f   3
Xsub_ac  ; 010 000 07   4
Xmov_ab  ; 010 000 19   5
Xadrf    ; 010 000 1d   6
Xnop_0   ; 010 000 00   7
Xinc_a   ; 010 000 08   8
Xcall    ; 010 000 16   9
Xsub_ab  ; 010 000 06  10
Xpush_bx ; 010 000 0d  11
Xshl     ; 010 000 03  12
Xmal     ; 010 000 1e  13
Xnop_0   ; 010 000 00  14
Xmov_iab ; 010 000 1a  15
Xdec_c   ; 010 000 0a  16
Xdec_c   ; 010 000 0a  17
Xjmpb    ; 010 000 15  18
Xdec_c   ; 010 000 0a  19
Xinc_a   ; 010 000 08  20
Xinc_b   ; 010 000 09  21
Xmov_iab ; 010 000 1a  22
Xdec_c   ; 010 000 0a  23
Xinc_a   ; 010 000 08  24
Xinc_b   ; 010 000 09  25
Xmov_iab ; 010 000 1a  26
Xdec_c   ; 010 000 0a  27
Xor1     ; 010 000 02  28
Xif_cz   ; 010 000 05  29
Xret     ; 010 000 17  30
Xinc_a   ; 010 000 08  31
Xinc_b   ; 010 000 09  32
Xjmpb    ; 010 000 15  33
Xnop_1   ; 010 000 01  34
Xif_cz   ; 010 000 05  35
Xnop_1   ; 010 000 01  36
Xadrb    ; 010 000 1c  37
Xnop_0   ; 010 000 00  38
Xdivide  ; 010 000 1f  39
Xsub_ac  ; 010 000 07  40
Xmov_ab  ; 010 000 19  41
Xadrf    ; 010 000 1d  42
Xnop_0   ; 010 000 00  43
Xinc_a   ; 010 000 08  44
Xcall    ; 010 000 16  45
Xsub_ab  ; 010 000 06  46
Xpush_bx ; 010 000 0d  47
Xshl     ; 010 000 03  48
Xmal     ; 010 000 1e  49
Xnop_0   ; 010 000 00  50
Xmov_iab ; 010 000 1a  51
Xdec_c   ; 010 000 0a  52
Xdec_c   ; 010 000 0a  53
Xjmpb    ; 010 000 15  54
Xdec_c   ; 010 000 0a  55
Xinc_a   ; 010 000 08  56
Xinc_b   ; 010 000 09  57
Xmov_iab ; 010 000 1a  58
Xdec_c   ; 010 000 0a  59
Xinc_a   ; 010 000 08  60
Xinc_b   ; 010 000 09  61
Xmov_iab ; 010 000 1a  62
Xdec_c   ; 010 000 0a  63
Xor1     ; 010 000 02  64
Xif_cz   ; 010 000 05  65
Xret     ; 010 000 17  66
Xinc_a   ; 010 000 08  67
Xinc_b   ; 010 000 09  68
Xjmpb    ; 010 000 15  69
Xnop_1   ; 010 000 01  70
Xif_cz   ; 010 000 05  71
END_OF_FILE
if test 2186 -ne `wc -c <'geneban1/0072etq.tie'`; then
    echo shar: \"'geneban1/0072etq.tie'\" unpacked with wrong size!
fi
# end of 'geneban1/0072etq.tie'
fi
echo shar: End of archive 2 \(of 7\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 4 5 6 7 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 7 archives.
    echo "Please see the README file(s) 
    for detailed instructions"
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
