Pārlūkot izejas kodu

Initial revision

sater 40 gadi atpakaļ
vecāks
revīzija
e0872423d9
21 mainītis faili ar 7189 papildinājumiem un 0 dzēšanām
  1. 1121 0
      doc/em/addend.n
  2. 488 0
      doc/em/app.nr
  3. 756 0
      doc/em/assem.nr
  4. 164 0
      doc/em/descr.nr
  5. 377 0
      doc/em/dspace.nr
  6. 9 0
      doc/em/even.c
  7. 178 0
      doc/em/exam.e
  8. 40 0
      doc/em/exam.p
  9. 180 0
      doc/em/intro.nr
  10. 376 0
      doc/em/iotrap.nr
  11. 6 0
      doc/em/ip.awk
  12. 61 0
      doc/em/ispace.nr
  13. 2525 0
      doc/em/itables
  14. 390 0
      doc/em/mach.nr
  15. 16 0
      doc/em/macr.nr
  16. 245 0
      doc/em/mapping.nr
  17. 80 0
      doc/em/mem.nr
  18. 5 0
      doc/em/print
  19. 4 0
      doc/em/show
  20. 38 0
      doc/em/title.nr
  21. 130 0
      doc/em/types.nr

+ 1121 - 0
doc/em/addend.n

@@ -0,0 +1,1121 @@
+.lg 0
+.ta 8 16 24 32 40 48 56 64 72 80
+.hw iden-ti-fi-er
+.nr a 0 1
+.nr f 1 1
+.de x1
+'sp 2
+'tl '''%'
+'sp 2
+.ns
+..
+.wh 0 x1
+.de fo
+'bp
+..
+.wh 60 fo
+.ll 79
+.lt 79
+.de HT
+.ti -4
+..
+.de PP
+.sp
+.ne 2
+.ti +5
+..
+.de SE
+.bp
+\fB\\n+a. \\$1\fR
+.nr b 0 1
+..
+.de SB
+.br
+.ne 10
+.sp 5
+\fB\\na.\\n+b. \\$1\fR
+..
+.de DC
+.ti -14
+DECISION~\\$1:
+..
+.de IN
+.in +6
+..
+.de OU
+.in -6
+..
+.tr ~
+.sp 5
+.rs
+.sp 10
+.ce 3
+Changes in EM-1
+
+Addendum to Informatica Rapport IR-54
+.sp 5
+.PP
+This document describes a revision of EM-1.
+A list of differences is presented roughly in the order IR-54
+describes the original architecture.
+A complete list of EM-1 pseudo's and instructions is also included.
+.SE Introduction
+.PP
+EM is a family of intermediate languages, resembling assembly
+language for a stack machine.
+EM defines the layout of data memory and a partitioning
+of instruction memory.
+EM has can do operations on five basic types:
+pointers, signed integers, unsigned integers, floating point numbers
+and sets of bits.
+The size of pointers is fixed in each member,
+in contrast to the sizes of the other types.
+Each member has one more fixed size: the word size.
+This is the mimimum size of any object on the stack.
+The sizes of all objects on the stack are assumed to
+multiples of the word size.
+We assume that pointer and word-sizes are both powers of two.
+.PP
+It is possible to load objects smaller then the word size from memory.
+These objects are converted to objects of the word size by
+clearing the most significant bytes.
+(A separate conversion instruction can do sign extension).
+While storing objects smaller then the word size are stored in memory,
+the most significant bytes are ignored.
+The size of such objects has to be a divisor of the word size.
+.PP
+Put in other terms, instructions such as LOC, LOL, LOE, STF, etc.
+manipulate WORDS.  Up until now, a word was defined as 16 bits.
+It is now possible to define a word size other than 16 bits.  For
+example, MES 2,1,2 defines a word to be 8 bits and a pointer to be
+16 bits.  As another example, MES 2,4,4 defines a word to be 32 bits
+and a pointer to be 32 bits.
+.PP
+If a compiler receives flags telling it to use 32 bit integers, it now
+has a choice of setting the word length to 16 bits and using LDL etc
+for dealing with integers, or setting the word length to 32 bits and using
+LOL etc for integers.
+For example, x:=a+b for 32-bit integers would become:
+
+  MES 2,2,4                          MES 2,4,4
+  LDL a                              LOL a
+  LDL b                              LOL b
+  ADI 4                              ADI 4
+  SDL x                              STL x
+
+In many cases, the target machine code that is finally produced from either
+of the above sequences will not show any traces of the stack machine, however
+for some instructions actual pushes and pops at run time will be necessary.
+Choosing a wider EM word will usually produce fewer stack operations than
+a narrower word, but it eliminates the possibility of doing arithmetic on
+quantities smaller than a word.  If, for example, a compiler chooses a 32-bit
+EM word, it will be difficult to add two 16 bit integers with ADI, since
+the argument must be multiple of the word size.
+(The operation can be done by converting the operands to 32 bits using CII,
+adding the 32-bit numbers, and reconverting the result.)
+On the other hand, choosing a 16-bit EM word makes it possible to do both
+16-bit adds (ADI 2) and 32-bit adds (ADI 4), 
+but the price paid is that 32-bit operations will be viewed as double
+precision, and may be slightly less efficient on target machines with a
+32-bit word, i.e. the EM to target translator may not take full advantage
+of the 32 bit facilities.
+.PP
+Note that since LOC pushes a WORD on the stack, the argument of LOC
+must fit ina word.  LOC 256 on an EM machine with a 1-byte word length
+is not allowed.  LDC 256 is allowed, however.
+.PP
+A general rule of thumb is that the compiler should choose an EM word
+length equal to the width of a single precision integer.
+Obviously, compilers should be well parameterized to allow the integer
+size(s) and word size(s) to be changed by just changing a few constants.
+.PP
+The size of a instruction space pointer in is the same
+as the size of a data space pointer.
+.PP
+EM assumes two's complement arithmetic on signed integers,
+but does not define an ordering of the bytes in a integer.
+The lowest numbered byte of a two-byte object can contain
+either the most or the least significant part.
+.SE Memory
+.PP
+EM has two separate addressing spaces, instruction and data.
+The sizes of these spaces are not specified.
+The layout of instruction space in not defined.
+Any interpreter or translator may assume a layout fitting his/her needs.
+The layout of data memory is specified by EM.
+EM data memory consists of a sequence of 8-bit bytes each separately
+addressable.
+Certain alignment restrictions exist for object consisting of multiple bytes.
+Objects smaller then the word size can only be addressed
+at multiples of the object size.
+For example: in a member with a four-byte word size, two-byte integers
+can only be accessed from even addresses.
+Objects larger then the word size can only be placed at multiples
+of the word size.
+For example: in a member with a four-byte word size,
+eight-byte floating point numbers can be fetched at addresses
+0, 4, 8, 12, etc.
+.SB "Procedure identifiers"
+.PP
+Procedure identifiers in EM have the same size
+as pointers.
+Any implementation of EM is free to use any method of identifying procedures.
+Common methods are indices into tables containing further information
+and addresses of the first instructions of procedures.
+.SB "Heap and Stack in global data"
+.PP
+The stack grows downward, the heap grows upward.
+The stack pointer points to the lowest occupied word on the stack.
+The heap pointer marks the first free word in the heap area.
+.br
+.ne 39
+.sp 1
+.nf
+       65534 -> |-------------------------------|
+                |///////////////////////////////|
+		|//// unimplemented memory /////|
+                |///////////////////////////////|
+          SB -> |-------------------------------|
+		|				|
+		|     stack and local area      | <- LB
+                |                               |
+		|				|
+                |-------------------------------| <- SP
+		|///////////////////////////////|
+		|// implementation dependent  //|
+		|///////////////////////////////|
+                |-------------------------------| <- HP
+		|				|
+		|           heap area           |
+		|				|
+		|                               |
+                |-------------------------------|
+		|				|
+		|          global area          |
+		|				|
+          EB -> |-------------------------------|
+		|				|
+		|				|
+                |         program text          | <- PC
+		|				|
+		|				|
+          PB -> |-------------------------------|
+		|///////////////////////////////|
+		|////////// undefined //////////|
+		|///////////////////////////////|
+           0 -> |-------------------------------|
+
+	   Fig. \nf.  Example of memory layout showing typical register
+           positions during execution of an EM program.
+.fi
+.SB "Data addresses as arguments"
+.PP
+Anywhere previous versions of the EM assembly language
+allowed identifiers of objects in
+data space,
+it is also possible to use 'identifier+constant' or 'identifier-constant'.
+For example, both "CON LABEL+4" and "LAE SAVED+3" are allowed.
+More complicated expressions are illegal.
+.SB "Local data area"
+.PP
+The mark block has been banished.
+When calling a procedure,
+the calling routine first has to push the actual parameters.
+All language implementations currently push their arguments
+in reverse order, to be compatible with C.
+Then the procedure is called using a CAL or CAI instruction.
+Either the call or the procedure prolog somehow has to save
+the return address and dynamic link.
+The prolog allocates the space needed for locals and is free to
+surround this space with saved registers and other information it
+deems necessary.
+.PP
+The locals are now accessed using negative offsets in LOL, LDL, SDL, LAL,
+LIL, SIL and STL instructions.
+The parameters are accessed using positive offsets in LOL, LDL, SDL, LAL,
+LIL, STL and
+STL instructions.
+The prolog might have stored information in the area between parameters and
+locals.
+As a consequence there are two bases, AB(virtual) and LB.
+AB stands for Argument Base and LB stands for Local Base.
+Positive arguments to LOL etc ... are interpreted as offsets from AB,
+negative arguments as offsets from LB.
+.PP
+The BEG instruction is not needed to allocate the locals because
+storage for locals is set aside in the prolog.
+The instruction still exists under the name ASP (Adjust Stack Pointer).
+.PP
+Procedures return using the RET instruction.
+The RET pops the function result from the stack and
+brings the stack pointer and other relevant registers to the state
+they had just before the procedure was called.
+The RET instruction expects that - aside from possible function results -
+the stack pointer has the value it had after execution of the prolog.
+RET finally returns control to the calling routine.
+The actual parameters have to be removed from the stack by the calling routine,
+and not by the called procedure.
+.sp 1
+.ne 38
+.nf
+
+
+
+		|===============================|
+                |     actual argument  n        |
+		|-------------------------------|
+                |              .                |
+                |              .                |
+                |              .                |
+		|-------------------------------|
+                |     actual argument  1        | ( <- AB )
+		|===============================|
+		|///////////////////////////////|
+		|// implementation dependent  //|
+		|///////////////////////////////|   <- LB
+                |===============================|
+                |                               |
+                |       local variables         |
+                |                               |
+		|-------------------------------|
+                |                               |
+                |      compiler temporaries     |
+                |                               |
+		|===============================|
+		|///////////////////////////////|
+		|// implementation dependent  //|
+		|///////////////////////////////|
+                |===============================|
+                |                               |
+                |   dynamic local generators    |
+                |                               |
+		|===============================|
+                |           operand             |
+		|-------------------------------|
+                |           operand             | <- SP
+		|===============================|
+
+                A sample procedure frame.
+
+.fi
+.sp 1
+This scheme allows procedures to be called with a variable number
+of parameters.
+The parameters have to be pushed in reverse order,
+because the called procedure has to be able to locate the first one.
+.PP
+.PP
+Since the mark block has disappeared, a new mechanism for static
+links had to be created.
+All compilers use the convention that EM procedures needing
+a static link will find a link in their zero'th parameter,
+i.e. the last one pushed on the stack.
+This parameter should be invisible to users of the compiler.
+The link needs to be in a fixed place because the lexical instructions
+have to locate it.
+The LEX instruction is replaced by two instructions: LXL and LXA.
+\&"LXL~n" finds the LB of a procedure n static levels removed.
+\&"LXA~n" finds the (virtual) AB.
+The value used for static link is LB.
+.PP
+When a procedure needing a static link is called, first the actual
+parameters are pushed, then the static link is pushed using LXL
+and finally the procedure is called with a CAL with the procedure's
+name as argument.
+.br
+.ne 40
+.nf
+
+
+
+		|===============================|
+                |     actual argument  n        |
+		|-------------------------------|
+                |              .                |
+                |              .                |
+                |              .                |
+		|-------------------------------|
+                |     actual argument  1        |
+		|-------------------------------|
+                |        static link            | ( <- AB )
+		|===============================|
+		|///////////////////////////////|
+		|// implementation dependent  //|
+		|///////////////////////////////|   <- LB
+                |===============================|
+                |                               |
+                |       local variables         |
+                |                               |
+		|-------------------------------|
+                |                               |
+                |      compiler temporaries     |
+                |                               |
+		|===============================|
+		|///////////////////////////////|
+		|// implementation dependent  //|
+		|///////////////////////////////|
+                |===============================|
+                |                               |
+                |   dynamic local generators    |
+                |                               |
+		|===============================|
+                |           operand             |
+		|-------------------------------|
+                |           operand             | <- SP
+		|===============================|
+
+                A procedure frame with static link.
+
+.fi
+.sp 1
+.sp 1
+.PP
+Pascal and other languages have to use procedure
+instance identifiers containing
+the procedure identifier
+'ul
+and
+the static link the procedure has to be called with.
+A static link having a value of zero signals
+that the called procedure does not need a static link.
+C uses the same convention for pointers to C-routines.
+In pointers to C-routines the static link is set to zero.
+.PP
+Note: The distance from LB to AB must be known for each procedure, otherwise
+LXA can not be implemented.
+Most implementations will have a fixed size area between
+the parameter and local storage.
+The zone between the compiler temporaries and the dynamic
+local generators can be used
+to save a variable number of registers.
+.PP
+.ne 11
+Prolog examples:
+.sp 2
+.nf
+
+	       proc1                       proc2
+	   
+	   mov lb,-(sp)                mov lb,-(sp)
+	   mov sp,lb                   mov sp,lb
+	   sub $loc_size,sp            sub $loc_size,sp
+	   mov r2,-(sp) ; save r2      mov r2,-(sp)
+	   mov r4,-(sp) ; save r4
+
+.fi
+.SB "Return values"
+.PP
+The return value popped by RET is stored in an unnamed 'function return area'.
+This area can be different for different sized objects returned,
+e.g. one register for two byte objects,
+two registers for four byte objects,
+memory for larger objects.
+The area is available for 'READ-ONCE' access using the LFR instruction.
+The result of a LFR is only defined if the sizes used to store and
+fetch are identical.
+The only instructions guaranteed not to destroy the contents of
+any 'function return area' are ASP and BRA.
+Thus parameters can be popped before fetching the function result.
+The maximum size of all function return areas is
+implementation dependant,
+but allows procedure instance identifiers and all
+implemented objects of type integer, unsigned, float
+and pointer to be returned.
+
+.SE "EM Assembly Language"
+.nr b 0 1
+.SB "Object types and instructions"
+.PP
+EM knows five basic object types:
+pointers,
+signed integers,
+unsigned integers,
+floating point numbers and
+sets of bits.
+Operations on objects of the last four types do not assume
+a specific size.
+Pointers (including procedure identifiers) have a fixed size in each
+implementation.
+Instructions acting on one or more objects of the last four types need
+explicit size information.
+This information can be given either as the argument of the
+instruction or on top of the stack.
+.sp 1
+For example:
+.nf
+addition of integers         LOL a, LOL b, ADI 2
+subtraction of two floats    LDL a, LDL b, SBF 4
+integer to float             LOL a, LOC 2, LOC 4, CIF, SDL b
+.fi
+.sp
+Note that conversion instructions always expect size
+before and size after conversion on the stack.
+.sp
+No obligation exists to implement all operations on all possible sizes.
+.PP
+The EM assembly language
+allows constants as instruction arguments up to a size of four bytes.
+In all EM's it is possible to initialize any type and size object.
+BSS, HOL, CON and ROM allow type and size indication in initializers.
+.SB "Conversion instructions"
+.PP
+The conversion operators can convert from any type and size to any
+type and size.
+The types are specified by the instruction,
+the sizes should be in words on top of the stack.
+Normally the sizes are multiples of the word size,
+There is one exception: the CII instructions sign-extends if the
+size of the source is a divisor of the word size.
+.SB "CSA and CSB"
+.PP
+The tables used by these instructions do not contain the procedure
+identifier any more.
+See also "Descriptors".
+.SB EXG
+.PP
+The EXG instruction is deleted from the EM instruction set.
+If future applications show any need for this instruction,
+it will be added again.
+.SB "FIL"
+.PP
+A FIL instruction has been introduced.
+When using separate compilation,
+the LIN feature of EM was insufficient.
+FIL expects as argument an address in global data.
+This address is stored in a fixed place in memory,
+where it can be used by any implementation for diagnostics etc.
+Like LIN, it provides access to the ABS fragment at the start
+of external data.
+.SB "LAI and SAI"
+.PP
+LAI and SAI have been dropped, they thwarted register optimization.
+.SB LNC
+.PP
+The LNC instruction is deleted from the instruction set.
+LOC -n wil do what it is supposed to.
+.SB "Branch instructions"
+.PP
+The branch instructions are allowed to branch both forward and backward.
+Consequently BRF and BRB are deleted and a BRA instruction is added.
+BRA branches unconditionally in any direction.
+.SB LDC
+.PP
+Loads a double word constant on the stack.
+.SB LEX
+.PP
+LXA and LXL replace LEX.
+.SB LFR
+.PP
+LFR loads the function result stored by RET.
+.SB "LIL and SIL"
+.PP
+They replace LOP and STP. (Name change only)
+.SB "Traps and Interrupts"
+.PP
+The numbers used for distinguishing the various types
+of traps and interrupts have been reassigned.
+The new instructions LIM and SIM
+allow setting and clearing of bits in a mask.
+The bits in the mask control the action taken upon encountering certain
+errors at runtime.
+A 1 bit causes the corresponding error to be ignored,
+a 0 bit causes the run-time system to trap.
+.SB LPI
+.PP
+Loads a procedure identifier on the stack.
+LOC cannot be used to do this anymore.
+.SB "ZER and ZRF"
+.PP
+ZER loads S zero bytes on the stack.
+ZRF loads a floating point zero of size S.
+.SB "Descriptors"
+.PP
+All instructions using descriptors have the size of the integer used
+in the descriptor as argument.
+The descriptors are: case descriptors (CSA and CSB),
+range check descriptors (RCK) and
+array descriptors ( LAR, SAR, AAR).
+.SB "Case descriptors"
+.PP
+The value used in a case descriptor to indicate the absence of a label
+is zero instead of -1.
+.SE "EM assembly language"
+.SB "Instruction arguments"
+.PP
+The previous EM had different instructions for distinguishing
+between operand on the stack and explicit argument in the instruction.
+For example, LOI and LOS.
+This distinction has been removed.
+Several instructions have two possible forms:
+with explicit argument and with implicit argument on top of the stack.
+The size of the implicit argument is the word size.
+The implicit argument is always popped before all other operands.
+Appendix 1 shows what is allowed for each instruction.
+.SB Notation
+.PP
+First the notation used for the arguments of
+instructions and pseudo instructions.
+.in +12
+.ti -11
+<num>~~=~~an integer number in the range -32768..32767
+.ti -11
+<off>~~=~~an offset -2**31..2**31~-~1
+.ti -11
+<sym>~~=~~an identifier
+.ti -11
+<arg>~~=~~<off> or <sym> or <sym>+<off> or <sym>-<off>
+.ti -11
+<con>~~=~~integer constant,
+unsigned constant,
+floating point constant
+.ti -11
+<str>~~=~~string constant (surrounded by double quotes),
+.ti -11
+<lab>~~=~~instruction label ('*' followed by an integer in the range
+0..32767).
+.ti -11
+<pro>~~=~~procedure number ('$' followed by a procedure name)
+.ti -11
+<val>~~=~~<arg>,
+<con>,
+<pro> or
+<lab>.
+.ti -11
+<...>*~=~~zero or more of <...>
+.ti -11
+<...>+~=~~one or more of <...>
+.ti -11
+[...]~~=~~optional ...
+.in -12
+.SB Labels
+.PP
+No label, instruction or data, can have a (pseudo) instruction
+on the same line.
+.SB Constants
+.PP
+All constants in EM are interpreted in the decimal base.
+.PP
+In BSS, HOL, CON and ROM pseudo-instructions
+numbers must be followed by I, U or F
+indicating Integer, Unsigned or Float.
+If no character is present I is assumed.
+This character can be followed by an even positive number or a 1.
+The number indicates the size in bytes of the object to be initialized,
+up to 32766.
+Double precision integers can no longer be indicated by a trailing L.
+As said before CON and ROM also allow expressions of the form:
+\&"LABEL+offset" and "LABEL-offset".
+The offset must be an unsigned decimal number.
+The 'IUF' indicators cannot be used with the offsets.
+.PP
+Areas reserved in the global data area by HOL or BSS can be
+initialized.
+BSS and HOL have a third parameter indicating whether the initialization
+is mandatory or optional.
+.PP
+Since EM needs aligment of objects, this alignment is enforced by the
+pseudo instructions.
+All objects are aligned on a multiple of their size or the word size
+whichever is smaller.
+Switching to another type of fragment or placing a label forces word-alignment.
+There are three types of fragments in global data space: CON, ROM and BSS-HOL.
+.sp
+.SB "Pseudo instructions"
+.PP
+The LET, IMC and FWC pseudo's have disappeared.
+The only application of these pseudo's was in postponing the
+specification of the size of the local storage to just before
+the END of the procedure.
+A new mechanism has been introduced to handle this problem.
+.ti +5
+The pseudos involved in separate compilation and linking have
+been reorganized.
+.ti +5
+PRO and END are altered and reflect the new calling sequence.
+EOF has disappeared.
+.ti +5
+BSS and HOL allow initialization of the requested data areas.
+.sp 2
+Four pseudo instructions request global data:
+.sp 2
+  BSS <off>,<val>,<num>
+.IN
+Reserve <off> bytes.
+<val> is the value used to initialize the area.
+<off> must be a multiple of the size of <val>.
+<num> is 0 if the initialization is not strictly necessary,
+1 otherwise.
+.OU
+.sp
+  HOL <off>,<val>,<num> 
+.IN
+Idem, but all following absolute global data references will
+refer to this block.
+Only one HOL is allowed per procedure,
+it has to be placed before the first instruction.
+.OU
+.sp
+  CON <val>+ 
+.IN
+Assemble global data words initialized with the <val> constants.
+.OU
+.sp
+  ROM <val>+ 
+.IN
+Idem, but the initialized data will never be changed by the program.
+.OU
+.sp 2
+Two pseudo instructions partition the input into procedures:
+.sp 2
+  PRO <sym>[,<off>] 
+.IN
+Start of procedure.
+<sym> is the procedure name.
+<off> is the number of bytes for locals.
+The number of bytes for locals must be specified in the PRO or
+END pseudo-instruction.
+When specified in both, they must be identical.
+.OU
+.sp
+  END  [<off>]
+.IN
+End of Procedure.
+<off> is the number of bytes for locals.
+The number of bytes for locals must be specified in either the PRO or
+END pseudo-instruction or both.
+.OU
+.PP
+Names of data and procedures in a EM module can either be
+internal or external.
+External names are known outside the module and are used to link
+several pieces of a program.
+Internal names are not known outside the modules they are used in.
+Other modules will not 'see' an internal name.
+.ti +5
+In order to reduce the number of passes needed,
+it must be known at the first occurrence whether
+a name is internal or external.
+If the first occurrence of a name is in a definition,
+the name is considered to be internal.
+If the first occurrence of a name is a reference,
+the name is considered to be external.
+If the first occurrence is in one of the following pseudo instructions,
+the effect of the pseudo has precedence.
+.sp 2
+  EXA <sym> 
+.IN
+External name.
+<sym> is external to this module.
+Note that <sym> may be defined in the same module.
+.OU
+.sp
+  EXP <pro>
+.IN
+External procedure identifier.
+Note that <sym> may be defined in the same module.
+.OU
+.sp
+  INA <sym>
+.IN
+Internal name.
+<sym> is internal to this module and must be defined in this module.
+.OU
+.sp
+  INP <pro> 
+.IN
+Internal procedure.
+<sym> is internal to this module and must be defined in this module.
+.OU
+.sp 2
+Two other pseudo instructions provide miscellaneous features:
+.sp 2
+  EXC <num1>,<num2> 
+.IN
+Two blocks of instructions preceding this one are
+interchanged before being processed.
+<num1> gives the number of lines of the first block.
+<num2> gives the number of lines of the second one.
+Blank and pure comment lines do not count.
+.OU
+.sp
+  MES <num>,<val>* 
+.IN
+A special type of comment.  Used by compilers to communicate with the
+optimizer, assembler, etc. as follows:
+.br
+  MES 0 -
+.IN
+An error has occurred, stop further processing.
+.OU
+.br
+  MES 1 -
+.IN
+Suppress optimization
+.OU
+.br
+  MES 2,<num1>,<num2>
+.IN
+Use word-size <num1> and pointer size <num2>.
+.OU
+.br
+  MES 3,<off>,<num1>,<num2> -
+.IN
+Indicates that a local variable is never referenced indirectly.
+<off> is offset in bytes from LB if positive
+and offset from AB if negative.
+<num1> gives the size of the variable.
+<num2> indicates the class of the variable.
+.OU
+.br
+  MES 4,<num>,<str>
+.IN
+Number of source lines in file <str> (for profiler).
+.OU
+.br
+  MES 5 -
+.IN
+Floating point used.
+.OU
+.br
+  MES 6,<val>* -
+.IN
+Comment.  Used to provide comments in compact assembly language (see below).
+.OU
+.sp 1
+Each back end is free to skip irrelevant MES pseudos.
+.OU
+.SB "The Compact Assembly Language"
+.PP
+The assembler accepts input in a highly encoded form.  This
+form is intended to reduce the amount of file transport between the compiler
+and assembler, and also reduce the amount of storage required for storing
+libraries.
+Libraries are stored as archived compact assembly language, not machine language.
+.PP
+When beginning to read the input, the assembler is in neutral state, and
+expects either a label or an instruction (including the pseudoinstructions).
+The meaning of the next byte(s) when in neutral state is as follows, where b1, b2 
+etc. represent the succeeding bytes.
+.sp
+       0   Reserved for future use
+   1-129   Machine instructions, see Appendix 2, alphabetical list
+ 130-149   Reserved for future use
+ 150-161   BSS,CON,END,EXC,EXA,EXP,HOL,INA,INP,MES,PRO,ROM
+ 162-179   Reserved for future pseudoinstructions
+ 180-239   Instruction labels 0 - 59  (180 is local label 0 etc.)
+ 240-244   See the Common Table below
+ 245-255   Not used
+
+After a label, the assembler is back in neutral state; it can immediately
+accept another label or an instruction in the very next byte.  There are
+no linefeeds used to separate lines.
+.PP
+If an opcode expects no arguments,
+the assembler is back in neutral state after
+reading the one byte containing the instruction number.  If it has one or
+more arguments (only pseudos have more than 1), the arguments follow directly,
+encoded as follows:
+.sp
+   0-239     Offsets from -120 to 119
+.br
+ 240-255     See the Common Table below
+.sp 2
+If an opcode has one optional argument,
+a special byte is used to announce that the argument is not present.
+.ce 1
+Common Table for Neutral State and Arguments
+.sp
+.nf
+<lab>   240 b1                Instruction label b1  (Not used for branches)
+<lab>   241 b1 b2             16 bit instruction label  (256*b2 + b1)
+<sym>   242 b1                Global label .0-.255, with b1 being the label
+<sym>   243 b1 b2             Global label .0-.32767
+			      with 256*b2+b1 being the label
+<sym>   244 <string>          Global symbol not of the form .nnn
+. \" Only the previous can occur in neutral state.
+<num>   245 b1 b2             (16 bit constant) 256*b2+b1
+<off>   246 b1 b2 b3 b4       (32 bit constant) (256*(256*(256*b4)+b3)+b2)+b1
+<arg>   247 <sym><off>        Global label + (possibly negative) constant
+<pro>   248 <string>          Procedure name  (not including $)
+<str>   249 <string>          String used in CON or ROM (no quotes)
+<con>   250 <num><string>     Integer constant, size <num> bytes
+<con>   251 <num><string>     Unsigned constant, size <num> bytes
+<con>   252 <num><string>     Floating constant, size <num> bytes
+<end>   255                   Delimiter for argument lists or
+			      indicates absence of optional argument
+
+.fi
+.PP
+The notation <string> consists first of a length field, and then an
+arbitrary string of bytes.
+The length is specified by a <num>.
+.PP
+.ne 8
+The pseudoinstructions fall into several categories, depending on their
+arguments:
+.sp
+ Group 1 -- EXC, BSS, HOL have a known number of arguments
+ Group 2 -- EXA, EXP, INA, INP start with a string
+ Group 3 -- CON, MES, ROM have a variable number of various things
+ Group 4 -- END, PRO have a trailing optional argument.
+
+Groups 1 and 2
+use the encoding described above.
+Group 3 also uses the encoding listed above, with a <end> byte after the
+last argument to indicate the end of the list.  
+Group 4 uses
+a <end> byte if the trailing argument is not present.
+
+.ad
+.fi
+.sp 2
+.ne 12
+.nf
+Example  ASCII			Example compact
+(LOC = 66, BRA = 18 here):
+
+  2				182
+  1				181
+   LOC 10			66 130
+   LOC -10			66 110
+   LOC 300			66 245 44 1
+   BRA 19			18 139
+  300				241 44 1
+  .3				242 3 
+   CON 4,9,*2,$foo		151 124 130 240 2 248 3 102 111 111 255
+   LOC .35			66 242 35
+.fi
+.nr a 0 1
+.SE "ASSEMBLY LANGUAGE INSTRUCTION LIST"
+.PP
+For each instruction in the list the range of operand values
+in the assembly language is given.
+All constants, offsets and sizes are in the range -2**31~..~2**31-1.
+The column headed \fIassem\fP contains the mnemonics defined
+in 4.1.
+The following column indicates restrictions in the range of the operand.
+Addresses have to obey the restrictions mentioned in chapter 2 - Memory -.
+The size parameter of most instructions has to be a multiple
+of the word size.
+The classes of operands
+are indicated by letters:
+.ds b \fBb\fP
+.ds c \fBc\fP
+.ds d \fBd\fP
+.ds g \fBg\fP
+.ds f \fBf\fP
+.ds l \fBl\fP
+.ds n \fBn\fP
+.ds i \fBi\fP
+.ds p \fBp\fP
+.ds r \fBr\fP
+.ds s \fBs\fP
+.ds z \fBz\fP
+.ds - \fB-\fP
+.nf
+
+  \fIassem\fP       constraints            rationale
+
+\&\*c  off                                 1-word constant
+\&\*d  off                                 2-word constant
+\&\*l  off                                 local offset
+\&\*g  arg          >= 0                   global offset
+\&\*f  off                                 fragment offset
+\&\*n  num          >= 0                   counter
+\&\*s  off          > 0                    object size
+\&\*z  off          >= 0                   object size
+\&\*i  off          > 0                    object size *
+\&\*p  pro                                 pro identifier
+\&\*b  lab          >= 0                   label number
+\&\*r  num          0,1,2                  register number
+\&\*-                                      no operand
+
+.fi
+.PP
+The * at the rationale for \*i indicates that the operand
+can either be given as argument or on top of the stack.
+If the operand has to be fetched from the stack,
+it is assumed to be a word-sized unsigned integer.
+.PP
+Instructions that check for undefined operands and underflow or overflow
+are indicated by (*).
+.nf
+
+GROUP 1 - LOAD
+
+  LOC \*c : Load constant (i.e. push one word onto the stack)
+  LDC \*d : Load double constant ( push two words )
+  LOL \*l : Load word at \*l-th local (l<0) or parameter (l>=0)
+  LOE \*g : Load external word \*g
+  LIL \*l : Load word pointed to by \*l-th local or parameter
+  LOF \*f : Load offsetted. (top of stack + \*f yield address)
+  LAL \*l : Load address of local or parameter
+  LAE \*g : Load address of external
+  LXL \*n : Load lexical. (address of LB \*n static levels back)
+  LXA \*n : Load lexical. (address of AB \*n static levels back)
+  LOI \*s : Load indirect \*s bytes (address is popped from the stack)
+  LOS \*i : Load indirect. \*i-byte integer on top of stack gives object size
+  LDL \*l : Load double local or parameter (two consecutive words are stacked)
+  LDE \*g : Load double external (two consecutive externals are stacked)
+  LDF \*f : Load double offsetted (top of stack + \*f yield address)
+  LPI \*p : Load procedure identifier
+
+GROUP 2 - STORE
+
+  STL \*l : Store local or parameter
+  STE \*g : Store external
+  SIL \*l : Store into word pointed to by \*l-th local or parameter
+  STF \*f : Store offsetted
+  STI \*s : Store indirect \*s bytes (pop address, then data)
+  STS \*i : Store indirect. \*i-byte integer on top of stack gives object size
+  SDL \*l : Store double local or parameter
+  SDE \*g : Store double external
+  SDF \*f : Store double offsetted
+
+GROUP 3 - INTEGER ARITHMETIC
+
+  ADI \*i : Addition (*)
+  SBI \*i : Subtraction (*)
+  MLI \*i : Multiplication (*)
+  DVI \*i : Division (*)
+  RMI \*i : Remainder (*)
+  NGI \*i : Negate (two's complement) (*)
+  SLI \*i : Shift left (*)
+  SRI \*i : Shift right (*)
+
+GROUP 4 - UNSIGNED ARITHMETIC
+
+  ADU \*i : Addition
+  SBU \*i : Subtraction
+  MLU \*i : Multiplication
+  DVU \*i : Division
+  RMU \*i : Remainder
+  SLU \*i : Shift left
+  SRU \*i : Shift right
+
+GROUP 5 - FLOATING POINT ARITHMETIC   (Format not defined)
+
+  ADF \*i : Floating add (*)
+  SBF \*i : Floating subtract (*)
+  MLF \*i : Floating multiply (*)
+  DVF \*i : Floating divide (*)
+  NGF \*i : Floating negate (*)
+  FIF \*i : Floating multiply and split integer and fraction part (*)
+  FEF \*i : Split floating number in exponent and fraction part (*)
+
+GROUP 6 - POINTER ARITHMETIC
+
+  ADP \*f : Add \*c to pointer on top of stack
+  ADS \*i : Add \*i-byte value and pointer
+  SBS \*i : Subtract pointers in same fragment and push diff as size \*i integer
+
+GROUP 7 - INCREMENT/DECREMENT/ZERO
+
+  INC \*- : Increment top of stack by 1 (*)
+  INL \*l : Increment local or parameter (*)
+  INE \*g : Increment external (*)
+  DEC \*- : Decrement top of stack by 1 (*)
+  DEL \*l : Decrement local or parameter (*)
+  DEE \*g : Decrement external (*)
+  ZRL \*l : Zero local or parameter
+  ZRE \*g : Zero external
+  ZRF \*i : Load a floating zero of size \*i
+  ZER \*i : Load \*i zero bytes
+
+GROUP 8 - CONVERT    ( stack: source, source size, dest. size (top) )
+
+  CII \*- : Convert integer to integer (*)
+  CUI \*- : Convert unsigned to integer (*)
+  CFI \*- : Convert floating to integer (*)
+  CIF \*- : Convert integer to floating (*)
+  CUF \*- : Convert unsigned to floating (*)
+  CFF \*- : Convert floating to floating (*)
+  CIU \*- : Convert integer to unsigned
+  CUU \*- : Convert unsigned to unsigned
+  CFU \*- : Convert floating to unsigned
+
+GROUP 9 - LOGICAL
+
+  AND \*i : Boolean and on two groups of \*i bytes
+  IOR \*i : Boolean inclusive or on two groups of \*i bytes
+  XOR \*i : Boolean exclusive or on two groups of \*i bytes
+  COM \*i : Complement (one's complement of top \*i bytes)
+  ROL \*i : Rotate left a group of \*i bytes
+  ROR \*i : Rotate right a group of \*i bytes
+
+GROUP 10 - SETS
+
+  INN \*i : Bit test on \*i byte set (bit number on top of stack)
+  SET \*i : Create singleton \*i byte set with bit n on (n is top of stack)
+
+GROUP 11 - ARRAY
+ 
+  LAR \*i : Load array element, descriptor contains integers of size \*i
+  SAR \*i : Store array element
+  AAR \*i : Load address of array element
+
+GROUP 12 - COMPARE
+
+  CMI \*i : Compare \*i byte integers. Push negative, zero, positive for <, = or >
+  CMF \*i : Compare \*i byte reals
+  CMU \*i : Compare \*i byte unsigneds
+  CMS \*i : Compare \*i byte sets. can only be used for equality test.
+  CMP \*- : Compare pointers
+
+  TLT \*- : True if less, i.e. iff top of stack < 0
+  TLE \*- : True if less or equal, i.e. iff top of stack <= 0
+  TEQ \*- : True if equal, i.e. iff top of stack = 0
+  TNE \*- : True if not equal, i.e. iff top of stack non zero
+  TGE \*- : True if greater or equal, i.e. iff top of stack >= 0
+  TGT \*- : True if greater, i.e. iff top of stack > 0
+
+GROUP 13 - BRANCH
+
+  BRA \*b : Branch unconditionally to label \*b
+
+  BLT \*b : Branch less (pop 2 words, branch if top > second)
+  BLE \*b : Branch less or equal
+  BEQ \*b : Branch equal
+  BNE \*b : Branch not equal
+  BGE \*b : Branch greater or equal
+  BGT \*b : Branch greater
+
+  ZLT \*b : Branch less than zero (pop 1 word, branch negative)
+  ZLE \*b : Branch less or equal to zero
+  ZEQ \*b : Branch equal zero
+  ZNE \*b : Branch not zero
+  ZGE \*b : Branch greater or equal zero
+  ZGT \*b : Branch greater than zero
+
+GROUP 14 - PROCEDURE CALL
+
+  CAI \*- : Call procedure (procedure instance identifier on stack)
+  CAL \*p : Call procedure (with name \*p)
+  LFR \*s : Load function result
+  RET \*z : Return (function result consists of top \*z bytes)
+
+GROUP 15 - MISCELLANEOUS
+
+  ASP \*f : Adjust the stack pointer by \*f
+  ASS \*i : Adjust the stack pointer by \*i-byte integer
+  BLM \*z : Block move \*z bytes; first pop destination addr, then source addr
+  BLS \*i : Block move, size is in \*i-byte integer on top of stack
+  CSA \*i : Case jump; address of jump table at top of stack
+  CSB \*i : Table lookup jump; address of jump table at top of stack
+  DUP \*s : Duplicate top \*s bytes
+  DUS \*i : Duplicate top \*i bytes
+  FIL \*g : File name (external 4 := \*g)
+  LIM \*- : Load 16 bit ignore mask
+  LIN \*n : Line number (external 0 := \*n)
+  LNI \*- : Line number increment
+  LOR \*r : Load register (0=LB, 1=SP, 2=HP)
+  MON \*- : Monitor call
+  NOP \*- : No operation
+  RCK \*i : Range check; trap on error
+  RTT \*- : Return from trap
+  SIG \*- : Trap errors to proc nr on top of stack (-2 resets default).  Static
+          link of procedure is below procedure number. Old values returned
+  SIM \*- : Store 16 bit ignore mask
+  STR \*r : Store register (0=LB, 1=SP, 2=HP)
+  TRP \*- : Cause trap to occur (Error number on stack)
+.fi

+ 488 - 0
doc/em/app.nr

@@ -0,0 +1,488 @@
+.BP
+.AP "EM INTERPRETER"
+.nf
+.ta 8 16 24 32 40 48 56 64 72 80
+.so em.i
+.fi
+.BP
+.AP "EM CODE TABLES"
+The following table is used by the assembler for EM machine
+language.
+It specifies the opcodes used for each instruction and
+how arguments are mapped to machine language arguments.
+The table is presented in three columns,
+each line in each column contains three or four fields.
+Each line describes a range of interpreter opcodes by
+specifying for which instruction the range is used, the type of the
+opcodes (mini, shortie, etc..) and range for the instruction
+argument.
+.A
+The first field on each line gives the EM instruction mnemonic,
+the second field gives some flags.
+If the opcodes are minis or shorties the third field specifies
+how many minis/shorties are used.
+The last field gives the number of the (first) interpreter
+opcode.
+.N 1
+Flags :
+.IS 3
+.N 1
+Opcode type, only one of the following may be specified.
+.PS - 5 "  "
+.PT -
+opcode without argument
+.PT m
+mini
+.PT s
+shortie
+.PT 2
+opcode with 2-byte signed argument
+.PT 4
+opcode with 4-byte signed argument
+.PT 8
+opcode with 8-byte signed argument
+.PE
+Secondary (escaped) opcodes.
+.PS - 5 "  "
+.PT e
+The opcode thus marked is in the secondary opcode group instead
+of the primary
+.PE
+restrictions on arguments
+.PS - 5 "  "
+.PT N
+Negative arguments only
+.PT P
+Positive and zero arguments only
+.PE
+mapping of arguments
+.PS - 5 "  "
+.PT w
+argument must be divisible by the wordsize and is divided by the
+wordsize before use as opcode argument.
+.PT o
+argument ( possibly after division ) must be >= 1 and is
+decremented before use as opcode argument
+.PE
+.IE
+If the opcode type is 2,4 or 8 the resulting argument is used as
+opcode argument (least significant byte first).
+.N
+If the opcode type is mini, the argument is added
+to the first opcode - if in range - .
+If the argument is negative, the absolute value minus one is
+used in the algorithm above.
+.N
+For shorties with positive arguments the first opcode is used
+for arguments in the range 0..255, the second for the range
+256..511, etc..
+For shorties with negative arguments the first opcode is used
+for arguments in the range -1..-256, the second for the range
+-257..-512, etc..
+The byte following the opcode contains the least significant
+byte of the argument.
+First some examples of these specifications.
+.PS - 5
+.PT "aar mwPo 1 34"
+Indicates that opcode 34 is used as a mini for Positive
+instruction arguments only.
+The w and o indicate division and decrementing of the
+instruction argument.
+Because the resulting argument must be zero ( only opcode 34 may be used
+), this mini can only be used for instruction argument 2.
+Conclusion: opcode 34 is for "AAR 2".
+.PT "adp sP 1 41"
+Opcode 41 is used as shortie for ADP with arguments in the range
+0..255.
+.PT "bra sN 2 60"
+Opcode 60 is used as shortie for BRA with arguments -1..-256,
+61 is used for arguments -257..-512.
+.PT "zer e- 145"
+Escaped opcode 145 is used for ZER.
+.PE
+The interpreter opcode table:
+.N 1
+.IS 3
+.DS B
+.so itables
+.DE 0
+.IE
+.P
+The table above results in the following dispatch tables.
+Dispatch tables are used by interpreters to jump to the
+routines implementing the EM instructions, indexed by the next opcode.
+Each line of the dispatch tables gives the routine names
+of eight consecutive opcodes, preceded by the first opcode number
+on that line.
+Routine names consist of an EM mnemonic followed by a suffix.
+The suffices show the encoding used for each opcode.
+.N
+The following suffices exist:
+.N 1
+.VS 1 0
+.IS 4
+.PS - 11
+.PT .z
+no arguments
+.PT .l
+16-bit argument
+.PT .lw
+16-bit argument divided by the wordsize
+.PT .p
+positive 16-bit argument
+.PT .pw
+positive 16-bit argument divided by the wordsize
+.PT .n
+negative 16-bit argument
+.PT .nw
+negative 16-bit argument divided by the wordsize
+.PT .s<num>
+shortie with <num> as high order argument byte
+.PT .sw<num>
+shortie with argument divided by the wordsize
+.PT .<num>
+mini with <num> as argument
+.PT .<num>W
+mini with <num>*wordsize as argument
+.PE 3
+<num> is a possibly negative integer.
+.VS 1 1
+.IE
+The dispatch table for the 256 primary opcodes:
+.DS B
+   0   loc.0    loc.1    loc.2    loc.3    loc.4    loc.5    loc.6    loc.7
+   8   loc.8    loc.9    loc.10   loc.11   loc.12   loc.13   loc.14   loc.15
+  16   loc.16   loc.17   loc.18   loc.19   loc.20   loc.21   loc.22   loc.23
+  24   loc.24   loc.25   loc.26   loc.27   loc.28   loc.29   loc.30   loc.31
+  32   loc.32   loc.33   aar.1W   adf.s0   adi.1W   adi.2W   adp.l    adp.1
+  40   adp.2    adp.s0   adp.s-1  ads.1W   and.1W   asp.1W   asp.2W   asp.3W
+  48   asp.4W   asp.5W   asp.w0   beq.l    beq.s0   bge.s0   bgt.s0   ble.s0
+  56   blm.s0   blt.s0   bne.s0   bra.l    bra.s-1  bra.s-2  bra.s0   bra.s1
+  64   cal.1    cal.2    cal.3    cal.4    cal.5    cal.6    cal.7    cal.8
+  72   cal.9    cal.10   cal.11   cal.12   cal.13   cal.14   cal.15   cal.16
+  80   cal.17   cal.18   cal.19   cal.20   cal.21   cal.22   cal.23   cal.24
+  88   cal.25   cal.26   cal.27   cal.28   cal.s0   cff.z    cif.z    cii.z
+  96   cmf.s0   cmi.1W   cmi.2W   cmp.z    cms.s0   csa.1W   csb.1W   dec.z
+ 104   dee.w0   del.w-1  dup.1W   dvf.s0   dvi.1W   fil.l    inc.z    ine.lw
+ 112   ine.w0   inl.-1W  inl.-2W  inl.-3W  inl.w-1  inn.s0   ior.1W   ior.s0
+ 120   lae.l    lae.w0   lae.w1   lae.w2   lae.w3   lae.w4   lae.w5   lae.w6
+ 128   lal.p    lal.n    lal.0    lal.-1   lal.w0   lal.w-1  lal.w-2  lar.W
+ 136   ldc.0    lde.lw   lde.w0   ldl.0    ldl.w-1  lfr.1W   lfr.2W   lfr.s0
+ 144   lil.w-1  lil.w0   lil.0    lil.1W   lin.l    lin.s0   lni.z    loc.l
+ 152   loc.-1   loc.s0   loc.s-1  loe.lw   loe.w0   loe.w1   loe.w2   loe.w3
+ 160   loe.w4   lof.l    lof.1W   lof.2W   lof.3W   lof.4W   lof.s0   loi.l
+ 168   loi.1    loi.1W   loi.2W   loi.3W   loi.4W   loi.s0   lol.pw   lol.nw
+ 176   lol.0    lol.1W   lol.2W   lol.3W   lol.-1W  lol.-2W  lol.-3W  lol.-4W
+ 184   lol.-5W  lol.-6W  lol.-7W  lol.-8W  lol.w0   lol.w-1  lxa.1    lxl.1
+ 192   lxl.2    mlf.s0   mli.1W   mli.2W   rck.1W   ret.0    ret.1W   ret.s0
+ 200   rmi.1W   sar.1W   sbf.s0   sbi.1W   sbi.2W   sdl.w-1  set.s0   sil.w-1
+ 208   sil.w0   sli.1W   ste.lw   ste.w0   ste.w1   ste.w2   stf.l    stf.W
+ 216   stf.2W   stf.s0   sti.1    sti.1W   sti.2W   sti.3W   sti.4W   sti.s0
+ 224   stl.pw   stl.nw   stl.0    stl.1W   stl.-1W  stl.-2W  stl.-3W  stl.-4W
+ 232   stl.-5W  stl.w-1  teq.z    tgt.z    tlt.z    tne.z    zeq.l    zeq.s0
+ 240   zeq.s1   zer.s0   zge.s0   zgt.s0   zle.s0   zlt.s0   zne.s0   zne.s-1
+ 248   zre.lw   zre.w0   zrl.-1W  zrl.-2W  zrl.w-1  zrl.nw   escape1  escape2
+.DE 2
+The list of secondary opcodes (escape1):
+.N  1
+.DS  B
+   0   aar.l    aar.z    adf.l    adf.z    adi.l    adi.z    ads.l    ads.z
+   8   adu.l    adu.z    and.l    and.z    asp.lw   ass.l    ass.z    bge.l
+  16   bgt.l    ble.l    blm.l    bls.l    bls.z    blt.l    bne.l    cai.z
+  24   cal.l    cfi.z    cfu.z    ciu.z    cmf.l    cmf.z    cmi.l    cmi.z
+  32   cms.l    cms.z    cmu.l    cmu.z    com.l    com.z    csa.l    csa.z
+  40   csb.l    csb.z    cuf.z    cui.z    cuu.z    dee.lw   del.pw   del.nw
+  48   dup.l    dus.l    dus.z    dvf.l    dvf.z    dvi.l    dvi.z    dvu.l
+  56   dvu.z    fef.l    fef.z    fif.l    fif.z    inl.pw   inl.nw   inn.l
+  64   inn.z    ior.l    ior.z    lar.l    lar.z    ldc.l    ldf.l    ldl.pw
+  72   ldl.nw   lfr.l    lil.pw   lil.nw   lim.z    los.l    los.z    lor.s0
+  80   lpi.l    lxa.l    lxl.l    mlf.l    mlf.z    mli.l    mli.z    mlu.l
+  88   mlu.z    mon.z    ngf.l    ngf.z    ngi.l    ngi.z    nop.z    rck.l
+  96   rck.z    ret.l    rmi.l    rmi.z    rmu.l    rmu.z    rol.l    rol.z
+ 104   ror.l    ror.z    rtt.z    sar.l    sar.z    sbf.l    sbf.z    sbi.l
+ 112   sbi.z    sbs.l    sbs.z    sbu.l    sbu.z    sde.l    sdf.l    sdl.pw
+ 120   sdl.nw   set.l    set.z    sig.z    sil.pw   sil.nw   sim.z    sli.l
+ 128   sli.z    slu.l    slu.z    sri.l    sri.z    sru.l    sru.z    sti.l
+ 136   sts.l    sts.z    str.s0   tge.z    tle.z    trp.z    xor.l    xor.z
+ 144   zer.l    zer.z    zge.l    zgt.l    zle.l    zlt.l    zne.l    zrf.l
+ 152   zrf.z    zrl.pw   dch.z    exg.s0   exg.l    exg.z    lpb.z    gto.l
+.DE 2
+Finally, the list of opcodes with four byte arguments (escape2).
+.DS
+
+   0  loc
+.DE 0
+.BP
+.AP "AN EXAMPLE PROGRAM"
+.DS B
+ 1      program example(output);
+ 2      {This program just demonstrates typical EM code.}
+ 3      type rec = record r1: integer; r2:real; r3: boolean end;
+ 4      var mi: integer;  mx:real;  r:rec;
+ 5
+ 6      function sum(a,b:integer):integer;
+ 7      begin
+ 8        sum := a + b
+ 9      end;
+10
+11      procedure test(var r: rec);
+12      label 1;
+13      var i,j: integer;
+14          x,y: real;
+15          b: boolean;
+16          c: char;
+17          a: array[1..100] of integer;
+18
+19      begin
+20              j := 1;
+21              i := 3 * j + 6;
+22              x := 4.8;
+23              y := x/0.5;
+24              b := true;
+25              c := 'z';
+26              for i:= 1 to 100 do a[i] := i * i;
+27              r.r1 := j+27;
+28              r.r3 := b;
+29              r.r2 := x+y;
+30              i := sum(r.r1, a[j]);
+31              while i > 0 do begin j := j + r.r1; i := i - 1 end;
+32              with r do begin r3 := b;  r2 := x+y;  r1 := 0 end;
+33              goto 1;
+34      1:      writeln(j, i:6, x:9:3, b)
+35      end; {test}
+36      begin {main program}
+37        mx := 15.96;
+38        mi := 99;
+39        test(r)
+40      end.
+.DE 0
+.BP
+The EM code as produced by the Pascal-VU compiler is given below. Comments
+have been added manually.  Note that this code has already been  optimized.
+.DS B
+  mes 2,2,2              ; wordsize 2, pointersize 2
+ .1
+  rom 't.p\e000'         ; the name of the source file
+  hol 552,-32768,0       ; externals and buf occupy 552 bytes
+  exp $sum               ; sum can be called from other modules
+  pro $sum,2             ; procedure sum; 2 bytes local storage
+  lin 8                  ; code from source line 8
+  ldl 0                  ; load two locals ( a and b )
+  adi 2                  ; add them
+  ret 2                  ; return the result
+  end 2                  ; end of procedure ( still two bytes local storage )
+ .2
+  rom 1,99,2             ; descriptor of array a[]
+  exp $test              ; the compiler exports all level 0 procedures
+  pro $test,226          ; procedure test, 226 bytes local storage
+ .3
+  rom 4.8F8              ; assemble Floating point 4.8 (8 bytes) in
+ .4                              ; global storage
+  rom 0.5F8              ; same for 0.5
+  mes 3,-226,2,2         ; compiler temporary not referenced by address
+  mes 3,-24,2,0          ; the same is true for i, j, b and c in test
+  mes 3,-22,2,0
+  mes 3,-4,2,0
+  mes 3,-2,2,0
+  mes 3,-20,8,0          ; and for x and y
+  mes 3,-12,8,0
+  lin 20                 ; maintain source line number
+  loc 1
+  stl -4                 ; j := 1
+  lni                    ; lin 21 prior to optimization
+  lol -4
+  loc 3
+  mli 2
+  loc 6
+  adi 2
+  stl -2                 ; i := 3 * j + 6
+  lni                    ; lin 22 prior to optimization
+  lae .3
+  loi 8
+  lal -12
+  sti 8                  ; x := 4.8
+  lni                    ; lin 23 prior to optimization
+  lal -12
+  loi 8
+  lae .4
+  loi 8
+  dvf 8
+  lal -20
+  sti 8                  ; y := x / 0.5
+  lni                    ; lin 24 prior to optimization
+  loc 1
+  stl -22                ; b := true
+  lni                    ; lin 25 prior to optimization
+  loc 122
+  stl -24                ; c := 'z'
+  lni                    ; lin 26 prior to optimization
+  loc 1
+  stl -2                 ; for i:= 1
+ 2
+  lol -2
+  dup 2
+  mli 2                  ; i*i
+  lal -224
+  lol -2
+  lae .2
+  sar 2                  ; a[i] :=
+  lol -2
+  loc 100
+  beq *3                 ; to 100 do
+  inl -2                 ; increment i and loop
+  bra *2
+ 3
+  lin 27
+  lol -4
+  loc 27
+  adi 2                  ; j + 27
+  sil 0                  ; r.r1 :=
+  lni                    ; lin 28 prior to optimization
+  lol -22                ; b
+  lol 0
+  stf 10                 ; r.r3 :=
+  lni                    ; lin 29 prior to optimization
+  lal -20
+  loi 16
+  adf 8                  ; x + y
+  lol 0
+  adp 2
+  sti 8                  ; r.r2 :=
+  lni                    ; lin 23 prior to optimization
+  lal -224
+  lol -4
+  lae .2
+  lar 2                  ; a[j]
+  lil 0                  ; r.r1
+  cal $sum               ; call now
+  asp 4                  ; remove parameters from stack
+  lfr 2                  ; get function result
+  stl -2                 ; i :=
+ 4
+  lin 31
+  lol -2
+  zle *5                 ; while i > 0 do
+  lol -4
+  lil 0
+  adi 2
+  stl -4                 ; j := j + r.r1
+  del -2                 ; i := i - 1
+  bra *4                 ; loop
+ 5
+  lin 32
+  lol 0
+  stl -226               ; make copy of address of r
+  lol -22
+  lol -226
+  stf 10                 ; r3 := b
+  lal -20
+  loi 16
+  adf 8
+  lol -226
+  adp 2
+  sti 8                  ; r2 := x + y
+  loc 0
+  sil -226               ; r1 := 0
+  lin 34                 ; note the abscence of the unnecesary jump
+  lae 22                 ; address of output structure
+  lol -4
+  cal $_wri              ; write integer with default width
+  asp 4                  ; pop parameters
+  lae 22
+  lol -2
+  loc 6
+  cal $_wsi              ; write integer width 6
+  asp 6
+  lae 22
+  lal -12
+  loi 8
+  loc 9
+  loc 3
+  cal $_wrf              ; write fixed format real, width 9, precision 3
+  asp 14
+  lae 22
+  lol -22
+  cal $_wrb              ; write boolean, default width
+  asp 4
+  lae 22
+  cal $_wln              ; writeln
+  asp 2
+  ret 0                  ; return, no result
+  end 226
+  exp $_main
+  pro $_main,0           ; main program
+ .6
+  con 2,-1,22            ; description of external files
+ .5
+  rom 15.96F8
+  fil .1                 ; maintain source file name
+  lae .6                 ; description of external files
+  lae 0                  ; base of hol area to relocate buffer addresses
+  cal $_ini              ; initialize files, etc...
+  asp 4
+  lin 37
+  lae .5
+  loi 8
+  lae 2
+  sti 8                  ; mx := 15.96
+  lni                    ; lin 38 prior to optimization
+  loc 99
+  ste 0                  ; mi := 99
+  lni                    ; lin 39 prior to optimization
+  lae 10                 ; address of r
+  cal $test
+  asp 2
+  loc 0                  ; normal exit
+  cal $_hlt              ; cleanup and finish
+  asp 2
+  end 0
+  mes 5                  ; reals were used
+.DE 0
+The compact code corresponding to the above program is listed below.
+Read it horizontally, line by line, not column by column.
+Each number represents a byte of compact code, printed in decimal.
+The first two bytes form the magic word.
+.N 1
+.IS 3
+.DS B
+173   0 159 122 122 122 255 242   1 161 250 124 116  46 112   0
+255 156 245  40   2 245   0 128 120 155 249 123 115 117 109 160
+249 123 115 117 109 122  67 128  63 120   3 122  88 122 152 122
+242   2 161 121 219 122 255 155 249 124 116 101 115 116 160 249
+124 116 101 115 116 245 226   0 242   3 161 253 128 123  52  46
+ 56 255 242   4 161 253 128 123  48  46  53 255 159 123 245  30
+255 122 122 255 159 123  96 122 120 255 159 123  98 122 120 255
+159 123 116 122 120 255 159 123 118 122 120 255 159 123 100 128
+120 255 159 123 108 128 120 255  67 140  69 121 113 116  68  73
+116  69 123  81 122  69 126   3 122 113 118  68  57 242   3  72
+128  58 108 112 128  68  58 108  72 128  57 242   4  72 128  44
+128  58 100 112 128  68  69 121 113  98  68  69 245 122   0 113
+ 96  68  69 121 113 118 182  73 118  42 122  81 122  58 245  32
+255  73 118  57 242   2  94 122  73 118  69 220  10 123  54 118
+ 18 122 183  67 147  73 116  69 147   3 122 104 120  68  73  98
+ 73 120 111 130  68  58 100  72 136   2 128  73 120   4 122 112
+128  68  58 245  32 255  73 116  57 242   2  59 122  65 120  20
+249 123 115 117 109   8 124  64 122 113 118 184  67 151  73 118
+128 125  73 116  65 120   3 122 113 116  41 118  18 124 185  67
+152  73 120 113 245  30 255  73  98  73 245  30 255 111 130  58
+100  72 136   2 128  73 245  30 255   4 122 112 128  69 120 104
+245  30 255  67 154  57 142  73 116  20 249 124  95 119 114 105
+  8 124  57 142  73 118  69 126  20 249 124  95 119 115 105   8
+126  57 142  58 108  72 128  69 129  69 123  20 249 124  95 119
+114 102   8 134  57 142  73  98  20 249 124  95 119 114  98   8
+124  57 142  20 249 124  95 119 108 110   8 122  88 120 152 245
+226   0 155 249 125  95 109  97 105 110 160 249 125  95 109  97
+105 110 120 242   6 151 122 119 142 255 242   5 161 253 128 125
+ 49  53  46  57  54 255  50 242   1  57 242   6  57 120  20 249
+124  95 105 110 105   8 124  67 157  57 242   5  72 128  57 122
+112 128  68  69 219 110 120  68  57 130  20 249 124 116 101 115
+116   8 122  69 120  20 249 124  95 104 108 116   8 122 152 120
+159 124 160 255 159 125 255
+.DE 0
+.IE
+.MS T A 0
+.ME
+.BP
+.MS B A 0
+.ME
+.CT

+ 756 - 0
doc/em/assem.nr

@@ -0,0 +1,756 @@
+.BP
+.SN 11
+.S1 "EM ASSEMBLY LANGUAGE"
+We use two representations for assembly language programs,
+one is in ASCII and the other is the compact assembly language.
+The latter needs less space than the first for the same program
+and therefore allows faster processing.
+Our only program accepting ASCII assembly
+language converts it to the compact form.
+All other programs expect compact assembly input.
+The first part of the chapter describes the ASCII assembly
+language and its semantics.
+The second part describes the syntax of the compact assembly
+language.
+The last part lists the EM instructions with the type of
+arguments allowed and an indication of the function.
+Appendix A gives a detailed description of the effect of all
+instructions in the form of a Pascal program.
+.S2 "ASCII assembly language"
+An assembly language program consists of a series of lines, each
+line may be blank, contain one (pseudo)instruction or contain one
+label.
+Input to the assembler is in lower case.
+Upper case is used in this
+document merely to distinguish keywords from the surrounding prose.
+Comment is allowed at the end of each line and starts with a semicolon ";".
+This kind of comment does not exist in the compact form.
+.A
+Labels must be placed all by themselves on a line and start in
+column 1.
+There are two kinds of labels, instruction and data labels.
+Instruction labels are unsigned positive integers.
+The scope of an instruction label is its procedure.
+.A
+The pseudoinstructions CON, ROM and BSS may be preceded by a
+line containing a
+1-8 character data label, the first character of which is a
+letter, period or underscore.
+The period may only be followed by
+digits, the others may be followed by letters, digits and underscores.
+The use of the character "." followed by a constant,
+which must be in the range 1 to 32767 (e.g. ".40") is recommended
+for compiler
+generated programs.
+These labels are considered as a special case and handled
+more efficiently in compact assembly language (see below).
+Note that a data label on its own or two consecutive labels are not
+allowed.
+.P
+Each statement may contain an instruction mnemonic or pseudoinstruction.
+These must begin in column 2 or later (not column 1) and must be followed
+by a space, tab, semicolon or LF.
+Everything on the line following a semicolon is
+taken as a comment.
+.P
+Each input file contains one module.
+A module may contain many procedures,
+which may be nested.
+A procedure consists of
+a PRO statement, a (possibly empty)
+collection of instructions and pseudoinstructions and finally an END
+statement.
+Pseudoinstructions are also allowed between procedures.
+They do not belong to a specific procedure.
+.P
+All constants in EM are interpreted in the decimal base.
+The ASCII assembly language accepts constant expressions
+wherever constants are allowed.
+The operators recognized are: +, -, *, % and / with the usual
+precedence order.
+Use of the parentheses ( and ) to alter the precedence order is allowed.
+.S3 "Instruction arguments"
+Unlike many other assembly languages, the EM assembly
+language requires all arguments of normal and pseudoinstructions
+to be either a constant or an identifier, but not a combination
+of these two.
+There is one exception to this rule: when a data label is used
+for initialization or as an instruction argument,
+expressions of the form 'label+constant' and 'label-constant'
+are allowed.
+This makes it possible to address, for example, the
+third word of a ten word BSS block
+directly.
+Thus LOE LABEL+4 is permitted and so is CON LABEL+3.
+The resulting address is must be in the same fragment as the label.
+It is not allowed to add or subtract from instruction labels or procedure
+identifiers,
+which certainly is not a severe restriction and greatly aids
+optimization.
+.P
+Instruction arguments can be constants,
+data labels, data labels offsetted by a constant, instruction
+labels and procedure identifiers.
+The range of integers allowed depends on the instruction.
+Most instructions allow only integers
+(signed or unsigned)
+that fit in a word.
+Arguments used as offsets to pointers should fit in a
+pointer-sized integer.
+Finally, arguments to LDC should fit in a double-word integer.
+.P
+Several instructions have two possible forms:
+with an explicit argument and with an implicit argument on top of the stack.
+The size of the implicit argument is the wordsize.
+The implicit argument is always popped before all other operands.
+For example: 'CMI 4' specifies that two four-byte signed
+integers on top of the stack are to be compared.
+\&'CMI' without an argument expects a wordsized integer
+on top of the stack that specifies the size of the integers to
+be compared.
+Thus the following two sequences are equivalent:
+.N 2
+.TS
+center, tab(:) ;
+l r 30 l r.
+LDL:-10:LDL:-10
+LDL:-14:LDL:-14
+::LOC:4
+CMI:4:CMI:
+ZEQ:*1:ZEQ:*1
+.TE 2
+Section 11.1.6 shows the arguments allowed for each instruction.
+.S3 "Pseudoinstruction arguments"
+Pseudoinstruction arguments can be divided in two classes:
+Initializers and others.
+The following initializers are allowed: signed integer constants,
+unsigned integer constants, floating-point constants, strings,
+data labels, data labels offsetted by a constant, instruction
+labels and procedure identifiers.
+.P
+Constant initializers in BSS, HOL, CON and ROM pseudoinstructions
+can be followed by a letter I, U or F.
+This indicator
+specifies the type of the initializer: Integer, Unsigned or Float.
+If no indicator is present I is assumed.
+The size of the object is the wordsize unless
+the indicator is followed by an integer specifying the
+object's size.
+This integer is governed by the same restrictions as for
+transfer of objects to/from memory.
+As in instruction arguments, initializers include expressions of the form:
+\&"LABEL+offset" and "LABEL-offset".
+The offset must be an unsigned decimal constant.
+The 'IUF' indicators cannot be used in the offsets.
+.P
+Data labels are referred to by their name.
+.P
+Strings are surrounded by double quotes (").
+Semecolon's in string do not indicate the start of comment.
+In the ASCII representation the escape character \e (backslash)
+alters the meaning of subsequent character(s).
+This feature allows inclusion of zeroes, graphic characters and
+the double quote in the string.
+The following escape sequences exist:
+.DS
+.TS
+center, tab(:);
+l l l.
+newline:NL\|(LF):\en
+horizontal tab:HT:\et
+backspace:BS:\eb
+carriage return:CR:\er
+form feed:FF:\ef
+backslash:\e:\e\e
+double quote:":\e"
+bit pattern:\fBddd\fP:\e\fBddd\fP
+.TE
+.DE
+The escape \fBddd\fP consists of the backslash followed by 1,
+2, or 3 octal digits specifing the value of
+the desired character.
+If the character following a backslash is not one of those
+specified,
+the backslash is ignored.
+Example: CON "hello\e012\e0".
+Each string element initializes a single byte.
+The ASCII character set is used to map characters onto values.
+Strings are padded with zeroes up to a multiple of the wordsize.
+.P
+Instruction labels are referred to as *1, *2, etc.  in both branch
+instructions and as initializers.
+.P
+The notation $procname means the identifier for the procedure
+with the specified name.
+This identifier has the size of a pointer.
+.S3 Notation
+First, the notation used for the arguments, classes of
+instructions and pseudoinstructions.
+.IS 2
+.TS
+tab(:);
+l l l.
+<cst>:\&=:integer constant (current range -2**31..2**31-1)
+<dlb>:\&=:data label
+<arg>:\&=:<cst> or <dlb> or <dlb>+<cst> or <dlb>-<cst>
+<con>:\&=:integer constant, unsigned constant, floating-point constant
+<str>:\&=:string constant (surrounded by double quotes),
+<ilb>:\&=:instruction label
+::'*' followed by an integer in the range 0..32767.
+<pro>:\&=:procedure number ('$' followed by a procedure name)
+<val>:\&=:<arg>, <con>, <pro> or <ilb>.
+<par>:\&=:<val> or <str>
+<...>*:\&=:zero or more of <...>
+<...>+:\&=:one or more of <...>
+[...]:\&=:optional ...
+.TE
+.IE
+.S3 "Pseudoinstructions"
+.S4 Storage declaration
+Initialized global data is allocated by the pseudoinstruction CON,
+which needs at least one argument.
+For each argument, an integral number of words,
+determined by the argument type, is allocated and initialized.
+.P
+The pseudoinstruction ROM is the same as CON,
+except that it guarantees that the initialized words
+will not change during the execution of the program.
+This information allows optimizers to do
+certain calculations such as array indexing and
+subrange checking at compile time instead
+of at run time.
+.P
+The pseudoinstruction BSS allocates
+uninitialized global data or large blocks of data initialized
+by the same value.
+The first argument to this pseudo is the number
+of bytes required, which must be a multiple of the wordsize.
+The other arguments specify the value used for initialization and
+whether the initialization is only for convenience or a strict necessity.
+The pseudoinstruction HOL is similar to BSS in that it requests an
+(un)initialized global data block.
+Addressing of a HOL block, however, is quasi absolute.
+The first byte is addressed by 0,
+the second byte by 1 etc. in assembly language.
+The assembler/loader adds the base address of
+the HOL block to these numbers to obtain the
+absolute address in the machine language.
+.P
+The scope of a HOL block starts at the HOL pseudo and
+ends at the next HOL pseudo or at the end of a module
+whatever comes first.
+Each instruction falls in the scope of at most one
+HOL block, the current HOL block.
+It is not allowed to have more than one HOL block per procedure.
+.P
+The alignment restrictions are enforced by the
+pseudoinstructions.
+All objects are aligned on a multiple of their size or the wordsize
+whichever is smaller.
+Switching to another type of fragment or placing a label forces
+word-alignment.
+There are three types of fragments in global data space: CON, ROM and
+BSS/HOL.
+.N 2
+.IS 2
+.PS - 4
+.PT "BSS <cst1>,<val>,<cst2>"
+Reserve <cst1> bytes.
+<val> is the value used to initialize the area.
+<cst1> must be a multiple of the size of <val>.
+<cst2> is 0 if the initialization is not strictly necessary,
+1 if it is.
+.PT "HOL <cst1>,<val>,<cst2>"
+Idem, but all following absolute global data references will
+refer to this block.
+Only one HOL is allowed per procedure,
+it has to be placed before the first instruction.
+.PT "CON <val>+"
+Assemble global data words initialized with the <val> constants.
+.PT "ROM <val>+"
+Idem, but the initialized data will never be changed by the program.
+.PE
+.IE
+.S4 Partitioning
+Two pseudoinstructions partition the input into procedures:
+.IS 2
+.PS - 4
+.PT "PRO <pro>[,<cst>]"
+Start of procedure.
+<pro> is the procedure name.
+<cst> is the number of bytes for locals.
+The number of bytes for locals must be specified in the PRO or
+END pseudoinstruction.
+When specified in both, they must be identical.
+.PT "END  [<cst>]"
+End of Procedure.
+<cst> is the number of bytes for locals.
+The number of bytes for locals must be specified in either the PRO or
+END pseudoinstruction or both.
+.PE
+.IE
+.S4 Visibility
+Names of data and procedures in an EM module can either be
+internal or external.
+External names are known outside the module and are used to link
+several pieces of a program.
+Internal names are not known outside the modules they are used in.
+Other modules will not 'see' an internal name.
+.A
+To reduce the number of passes needed,
+it must be known at the first occurrence whether
+a name is internal or external.
+If the first occurrence of a name is in a definition,
+the name is considered to be internal.
+If the first occurrence of a name is a reference,
+the name is considered to be external.
+If the first occurrence is in one of the following pseudoinstructions,
+the effect of the pseudo has precedence.
+.IS 2
+.PS - 4
+.PT "EXA <dlb>"
+External name.
+<dlb> is known, possibly defined, outside this module.
+Note that <dlb> may be defined in the same module.
+.PT "EXP <pro>"
+External procedure identifier.
+Note that <pro> may be defined in the same module.
+.PT "INA <dlb>"
+Internal name.
+<dlb> is internal to this module and must be defined in this module.
+.PT "INP <pro>"
+Internal procedure.
+<pro> is internal to this module and must be defined in this module.
+.PE
+.IE
+.S4 Miscellaneous
+Two other pseudoinstructions provide miscellaneous features:
+.IS 2
+.PS - 4
+.PT "EXC <cst1>,<cst2>"
+Two blocks of instructions preceding this one are
+interchanged before being processed.
+<cst1> gives the number of lines of the first block.
+<cst2> gives the number of lines of the second one.
+Blank and pure comment lines do not count.
+.PT "MES <cst>[,<par>]*"
+A special type of comment.
+Used by compilers to communicate with the
+optimizer, assembler, etc. as follows:
+.VS 1 0
+.PS - 4
+.PT "MES 0"
+An error has occurred, stop further processing.
+.PT "MES 1"
+Suppress optimization.
+.PT "MES 2,<cst1>,<cst2>"
+Use wordsize <cst1> and pointer size <cst2>.
+.PT "MES 3,<cst1>,<cst2>,<cst3>,<cst4>"
+Indicates that a local variable is never referenced indirectly.
+Used to indicate that a register may be used for a specific
+variable.
+<cst1> is offset in bytes from AB if positive
+and offset from LB if negative.
+<cst2> gives the size of the variable.
+<cst3> indicates the class of the variable.
+The following values are currently recognized:
+.PS
+.PT 0
+The variable can be used for anything.
+.PT 1
+The variable is used as a loopindex.
+.PT 2
+The variable is used as a pointer.
+.PT 3
+The variable is used as a floating point number.
+.PE 0
+<cst4> gives the priority of the variable,
+higher numbers indicate better candidates.
+.PT "MES 4,<cst>,<str>"
+Number of source lines in file <str> (for profiler).
+.PT "MES 5"
+Floating point used.
+.PT "MES 6,<val>*"
+Comment.  Used to provide comments in compact assembly language.
+.PT "MES 7,....."
+Reserved.
+.PT "MES 8,<pro>[,<dlb>]..."
+Library module. Indicates that the module may only be loaded
+if it is useful, that is, if it can satisfy any unresolved
+references during the loading process.
+May not be preceded by any other pseudo, except MES's.
+.PT "MES 9,<cst>"
+Guarantees that no more than <cst> bytes of parameters are
+accessed, either directly or indirectly.
+.PE 1
+.VS 1 1
+Each backend is free to skip irrelevant MES pseudos.
+.PE
+.IE
+.S2 "The Compact Assembly Language"
+The assembler accepts input in a highly encoded form.
+This
+form is intended to reduce the amount of file transport between the
+front ends, optimizers
+and back ends, and also reduces the amount of storage required for storing
+libraries.
+Libraries are stored as archived compact assembly language, not machine
+language.
+.P
+When beginning to read the input, the assembler is in neutral state, and
+expects either a label or an instruction (including the pseudoinstructions).
+The meaning of the next byte(s) when in neutral state is as follows, where
+b1, b2
+etc. represent the succeeding bytes.
+.N 1
+.DS
+.TS
+tab(:) ;
+rw17 4 l.
+0:Reserved for future use
+1-129:Machine instructions, see Appendix A, alphabetical list
+130-149:Reserved for future use
+150-161:BSS,CON,END,EXA,EXC,EXP,HOL,INA,INP,MES,PRO,ROM
+162-179:Reserved for future pseudoinstructions
+180-239:Instruction labels 0 - 59  (180 is local label 0 etc.)
+240-244:See the Common Table below
+245-255:Not used
+.TE 1
+.DE 0
+After a label, the assembler is back in neutral state; it can immediately
+accept another label or an instruction in the next byte.
+No linefeeds are used to separate lines.
+.P
+If an opcode expects no arguments,
+the assembler is back in neutral state after
+reading the one byte containing the instruction number.
+If it has one or
+more arguments (only pseudos have more than 1), the arguments follow directly,
+encoded as follows:
+.N 1
+.IS 2
+.TS
+tab(:);
+r l.
+0-239:Offsets from -120 to 119
+
+240-255:See the Common Table below
+.TE 1
+Absence of an optional argument is indicated by a special
+byte.
+.IE 2
+.CS
+Common Table for Neutral State and Arguments
+.CE
+.TS
+tab(:);
+c c s c
+l8 l l8 l.
+class:bytes:description
+
+<ilb>:240:b1:Instruction label b1  (Not used for branches)
+<ilb>:241:b1 b2:16 bit instruction label  (256*b2 + b1)
+<dlb>:242:b1:Global label .0-.255, with b1 being the label
+<dlb>:243:b1 b2:Global label .0-.32767
+:::with 256*b2+b1 being the label
+<dlb>:244:<string>:Global symbol not of the form .nnn
+<cst>:245:b1 b2:16 bit constant
+<cst>:246:b1 b2 b3 b4:32 bit constant
+<cst>:247:b1 .. b8:64 bit constant
+<arg>:248:<dlb><cst>:Global label + (possibly negative) constant
+<pro>:249:<string>:Procedure name  (not including $)
+<str>:250:<string>:String used in CON or ROM (no quotes-no escapes)
+<con>:251:<cst><string>:Integer constant, size <cst> bytes
+<con>:252:<cst><string>:Unsigned constant, size <cst> bytes
+<con>:253:<cst><string>:Floating constant, size <cst> bytes
+:254::unused
+<end>:255::Delimiter for argument lists or
+:::indicates absence of optional argument
+.TE 1
+.P
+The bytes specifying the value of a 16, 32 or 64 bit constant
+are presented in two's complement notation, with the least
+significant byte first. For example: the value of a 32 bit
+constant is ((s4*256+b3)*256+b2)*256+b1, where s4 is b4-256 if
+b4 is greater than 128 else s4 takes the value of b4.
+A <string> consists of a <cst> inmediatly followed by
+a sequence of bytes with length <cst>.
+.P
+.ne 8
+The pseudoinstructions fall into several categories, depending on their
+arguments:
+.N 1
+.DS
+ Group 1 -- EXC, BSS, HOL have a known number of arguments
+ Group 2 -- EXA, EXP, INA, INP have a string as argument
+ Group 3 -- CON, MES, ROM have a variable number of various things
+ Group 4 -- END, PRO have a trailing optional argument.
+.DE 1
+Groups 1 and 2
+use the encoding described above.
+Group 3 also uses the encoding listed above, with an <end> byte after the
+last argument to indicate the end of the list.
+Group 4 uses
+an <end> byte if the trailing argument is not present.
+.N 2
+.IS 2
+.TS
+tab(|);
+l s l
+l s s
+l 2 lw(46) l.
+Example  ASCII|Example compact
+(LOC = 69, BRA = 18 here):
+
+2||182
+1||181
+ LOC|10|69 130
+ LOC|-10|69 110
+ LOC|300|69 245 44 1
+ BRA|*19|18 139
+300||241 44 1
+.3||242 3
+ CON|4,9,*2,$foo|151 124 129 240 2 249 123 102 111 111 255
+ CON|.35|151 242 35 255
+.TE 0
+.IE 0
+.BP
+.S2 "Assembly language instruction list"
+.P
+For each instruction in the list the range of argument values
+in the assembly language is given.
+The column headed \fIassem\fP contains the mnemonics defined
+in 11.1.3.
+The following column specifies restrictions of the argument
+value.
+Addresses have to obey the restrictions mentioned in chapter 2.
+The classes of arguments
+are indicated by letters:
+.ds b \fBb\fP
+.ds c \fBc\fP
+.ds d \fBd\fP
+.ds g \fBg\fP
+.ds f \fBf\fP
+.ds l \fBl\fP
+.ds n \fBn\fP
+.ds w \fBw\fP
+.ds p \fBp\fP
+.ds r \fBr\fP
+.ds s \fBs\fP
+.ds z \fBz\fP
+.ds o \fBo\fP
+.ds - \fB-\fP
+.N 1
+.TS
+tab(:);
+c s l l
+l l 15 l l.
+\fIassem\fP:constraints:rationale
+
+\&\*c:cst:fits word:constant
+\&\*d:cst:fits double word:constant
+\&\*l:cst::local offset
+\&\*g:arg:>= 0:global offset
+\&\*f:cst::fragment offset
+\&\*n:cst:>= 0:counter
+\&\*s:cst:>0 , word multiple:object size
+\&\*z:cst:>= 0 , zero or word multiple:object size
+\&\*o:cst:>= 0 , word multiple or fraction:object size
+\&\*w:cst:> 0 , word multiple:object size *
+\&\*p:pro::pro identifier
+\&\*b:ilb:>= 0:label number
+\&\*r:cst:0,1,2:register number
+\&\*-:::no argument
+.TE 1
+.P
+The * at the rationale for \*w indicates that the argument
+can either be given as argument or on top of the stack.
+If the argument is omitted, the argument is fetched from the
+stack;
+it is assumed to be a wordsized unsigned integer.
+Instructions that check for undefined integer or floating-point
+values and underflow or overflow
+are indicated below by (*).
+.N 1
+.DS B
+GROUP 1 - LOAD
+
+  LOC \*c : Load constant (i.e. push one word onto the stack)
+  LDC \*d : Load double constant ( push two words )
+  LOL \*l : Load word at \*l-th local (\*l<0) or parameter (\*l>=0)
+  LOE \*g : Load external word \*g
+  LIL \*l : Load word pointed to by \*l-th local or parameter
+  LOF \*f : Load offsetted (top of stack + \*f yield address)
+  LAL \*l : Load address of local or parameter
+  LAE \*g : Load address of external
+  LXL \*n : Load lexical (address of LB \*n static levels back)
+  LXA \*n : Load lexical (address of AB \*n static levels back)
+  LOI \*o : Load indirect \*o bytes (address is popped from the stack)
+  LOS \*w : Load indirect, \*w-byte integer on top of stack gives object size
+  LDL \*l : Load double local or parameter (two consecutive words are stacked)
+  LDE \*g : Load double external (two consecutive externals are stacked)
+  LDF \*f : Load double offsetted (top of stack + \*f yield address)
+  LPI \*p : Load procedure identifier
+
+GROUP 2 - STORE
+
+  STL \*l : Store local or parameter
+  STE \*g : Store external
+  SIL \*l : Store into word pointed to by \*l-th local or parameter
+  STF \*f : Store offsetted
+  STI \*o : Store indirect \*o bytes (pop address, then data)
+  STS \*w : Store indirect, \*w-byte integer on top of stack gives object size
+  SDL \*l : Store double local or parameter
+  SDE \*g : Store double external
+  SDF \*f : Store double offsetted
+
+GROUP 3 - INTEGER ARITHMETIC
+
+  ADI \*w : Addition (*)
+  SBI \*w : Subtraction (*)
+  MLI \*w : Multiplication (*)
+  DVI \*w : Division (*)
+  RMI \*w : Remainder (*)
+  NGI \*w : Negate (two's complement) (*)
+  SLI \*w : Shift left (*)
+  SRI \*w : Shift right (*)
+
+GROUP 4 - UNSIGNED ARITHMETIC
+
+  ADU \*w : Addition
+  SBU \*w : Subtraction
+  MLU \*w : Multiplication
+  DVU \*w : Division
+  RMU \*w : Remainder
+  SLU \*w : Shift left
+  SRU \*w : Shift right
+
+GROUP 5 - FLOATING POINT ARITHMETIC
+
+  ADF \*w : Floating add (*)
+  SBF \*w : Floating subtract (*)
+  MLF \*w : Floating multiply (*)
+  DVF \*w : Floating divide (*)
+  NGF \*w : Floating negate (*)
+  FIF \*w : Floating multiply and split integer and fraction part (*)
+  FEF \*w : Split floating number in exponent and fraction part (*)
+
+GROUP 6 - POINTER ARITHMETIC
+
+  ADP \*f : Add \*f to pointer on top of stack
+  ADS \*w : Add \*w-byte value and pointer
+  SBS \*w : Subtract pointers in same fragment and push diff as size \*w integer
+
+GROUP 7 - INCREMENT/DECREMENT/ZERO
+
+  INC \*- : Increment word on top of stack by 1 (*)
+  INL \*l : Increment local or parameter (*)
+  INE \*g : Increment external (*)
+  DEC \*- : Decrement word on top of stack by 1 (*)
+  DEL \*l : Decrement local or parameter (*)
+  DEE \*g : Decrement external (*)
+  ZRL \*l : Zero local or parameter
+  ZRE \*g : Zero external
+  ZRF \*w : Load a floating zero of size \*w
+  ZER \*w : Load \*w zero bytes
+
+GROUP 8 - CONVERT    (stack: source, source size, dest. size (top))
+
+  CII \*- : Convert integer to integer (*)
+  CUI \*- : Convert unsigned to integer (*)
+  CFI \*- : Convert floating to integer (*)
+  CIF \*- : Convert integer to floating (*)
+  CUF \*- : Convert unsigned to floating (*)
+  CFF \*- : Convert floating to floating (*)
+  CIU \*- : Convert integer to unsigned
+  CUU \*- : Convert unsigned to unsigned
+  CFU \*- : Convert floating to unsigned
+
+GROUP 9 - LOGICAL
+
+  AND \*w : Boolean and on two groups of \*w bytes
+  IOR \*w : Boolean inclusive or on two groups of \*w bytes
+  XOR \*w : Boolean exclusive or on two groups of \*w bytes
+  COM \*w : Complement (one's complement of top \*w bytes)
+  ROL \*w : Rotate left a group of \*w bytes
+  ROR \*w : Rotate right a group of \*w bytes
+
+GROUP 10 - SETS
+
+  INN \*w : Bit test on \*w byte set (bit number on top of stack)
+  SET \*w : Create singleton \*w byte set with bit n on (n is top of stack)
+
+GROUP 11 - ARRAY
+
+  LAR \*w : Load array element, descriptor contains integers of size \*w
+  SAR \*w : Store array element
+  AAR \*w : Load address of array element
+
+GROUP 12 - COMPARE
+
+  CMI \*w : Compare \*w byte integers, Push negative, zero, positive for <, = or >
+  CMF \*w : Compare \*w byte reals
+  CMU \*w : Compare \*w byte unsigneds
+  CMS \*w : Compare \*w byte values, can only be used for bit for bit equality test
+  CMP \*- : Compare pointers
+
+  TLT \*- : True if less, i.e. iff top of stack < 0
+  TLE \*- : True if less or equal, i.e. iff top of stack <= 0
+  TEQ \*- : True if equal, i.e. iff top of stack = 0
+  TNE \*- : True if not equal, i.e. iff top of stack non zero
+  TGE \*- : True if greater or equal, i.e. iff top of stack >= 0
+  TGT \*- : True if greater, i.e. iff top of stack > 0
+
+GROUP 13 - BRANCH
+
+  BRA \*b : Branch unconditionally to label \*b
+
+  BLT \*b : Branch less (pop 2 words, branch if top > second)
+  BLE \*b : Branch less or equal
+  BEQ \*b : Branch equal
+  BNE \*b : Branch not equal
+  BGE \*b : Branch greater or equal
+  BGT \*b : Branch greater
+
+  ZLT \*b : Branch less than zero (pop 1 word, branch negative)
+  ZLE \*b : Branch less or equal to zero
+  ZEQ \*b : Branch equal zero
+  ZNE \*b : Branch not zero
+  ZGE \*b : Branch greater or equal zero
+  ZGT \*b : Branch greater than zero
+
+GROUP 14 - PROCEDURE CALL
+
+  CAI \*- : Call procedure (procedure identifier on stack)
+  CAL \*p : Call procedure (with identifier \*p)
+  LFR \*s : Load function result
+  RET \*z : Return (function result consists of top \*z bytes)
+
+GROUP 15 - MISCELLANEOUS
+
+  ASP \*f : Adjust the stack pointer by \*f
+  ASS \*w : Adjust the stack pointer by \*w-byte integer
+  BLM \*z : Block move \*z bytes; first pop destination addr, then source addr
+  BLS \*w : Block move, size is in \*w-byte integer on top of stack
+  CSA \*w : Case jump; address of jump table at top of stack
+  CSB \*w : Table lookup jump; address of jump table at top of stack
+  DCH \*- : Follow dynamic chain, convert LB to LB of caller
+  DUP \*s : Duplicate top \*s bytes
+  DUS \*w : Duplicate top \*w bytes
+  EXG \*w : Exchange top \*w bytes
+  FIL \*g : File name (external 4 := \*g)
+  GTO \*g : Non-local goto, descriptor at \*g
+  LIM \*- : Load 16 bit ignore mask
+  LIN \*n : Line number (external 0 := \*n)
+  LNI \*- : Line number increment
+  LOR \*r : Load register (0=LB, 1=SP, 2=HP)
+  LPB \*- : Convert local base to argument base
+  MON \*- : Monitor call
+  NOP \*- : No operation
+  RCK \*w : Range check; trap on error
+  RTT \*- : Return from trap
+  SIG \*- : Trap errors to proc identifier on top of stack, -2 resets default
+  SIM \*- : Store 16 bit ignore mask
+  STR \*r : Store register (0=LB, 1=SP, 2=HP)
+  TRP \*- : Cause trap to occur (Error number on stack)
+.DE 0

+ 164 - 0
doc/em/descr.nr

@@ -0,0 +1,164 @@
+.SN 7
+.BP
+.S1 "DESCRIPTORS"
+Several instructions use descriptors, notably the range check instruction,
+the array instructions, the goto instruction and the case jump instructions.
+Descriptors reside in data space.
+They may be constructed at run time, but
+more often they are fixed and allocated in ROM data.
+.P
+All instructions using descriptors, except GTO, have as argument
+the size of the integers in the descriptor.
+All implementations have to allow integers of the size of a
+word in descriptors.
+All integers popped from the stack and used for indexing or comparing
+must have the same size as the integers in the descriptor.
+.S2 "Range check descriptors"
+Range check descriptors consist of two integers:
+.IS 2
+.PS 1 4 "" .
+.PT
+lower bound~~~~~~~signed
+.PT
+upper bound~~~~~~~signed
+.PE
+.IE
+The range check instruction checks an integer on the stack against
+these bounds and causes a trap if the value is outside the interval.
+The value itself is neither changed nor removed from the stack.
+.S2 "Array descriptors"
+Each array descriptor describes a single dimension.
+For multi-dimensional arrays, several array instructions are
+needed to access a single element.
+Array descriptors contain the following three integers:
+.IS 2
+.PS 1 4 "" .
+.PT
+lower bound~~~~~~~~~~~~~~~~~~~~~signed
+.PT
+upper bound - lower bound~~~~~~~unsigned
+.PT
+number of bytes per element~~~~~unsigned
+.PE
+.IE
+The array instructions LAR, SAR and AAR have the pointer to the start
+of the descriptor as operand on the stack.
+.sp
+The element A[I] is fetched as follows:
+.IS 2
+.PS 1 4 "" .
+.PT
+Stack the address of A  (e.g., using LAE or LAL)
+.PT
+Stack the value of I (n-byte integer)
+.PT
+Stack the pointer to the descriptor (e.g., using LAE)
+.PT
+LAR n (n is the size of the integers in the descriptor and I)
+.PE
+.IE
+All array instructions first pop the address of the descriptor
+and the index.
+If the index is not within the bounds specified, a trap occurs.
+If ok, (I~-~lower bound) is multiplied
+by the number of bytes per element (the third word).  The result is added
+to the address of A and replaces A on the stack.
+.A
+At this point LAR, SAR and AAR diverge.
+AAR is finished.  LAR pops the address and fetches the data
+item,
+the size being specified by the descriptor.
+The usual restrictions for memory access must be obeyed.
+SAR pops the address and stores the
+data item now exposed.
+.S2 "Non-local goto descriptors"
+The GTO instruction provides a way of returning directly to any
+active procedure invocation.
+The argument of the instruction is the address of a descriptor
+containing three pointers:
+.IS 2
+.PS 1 4 "" .
+.PT
+value of PC after the jump
+.PT
+value of SP after the jump
+.PT
+value of LB after the jump
+.PE
+.IE
+GTO replaces the loads PC, SP and LB from the descriptor,
+thereby jumping to a procedure
+and removing zeor or more frames from the stack.
+The LB, SP and PC in the descriptor must belong to a
+dynamically enclosing procedure,
+because some EM implementations will need to backtrack through
+the dynamic chain and use the implementation dependent data
+in frames to restore registers etc.
+.S2 "Case descriptors"
+The case jump instructions CSA and CSB both
+provide multiway branches selected by a case index.
+Both fetch two operands from the stack:
+first a pointer to the low address of the case descriptor
+and then the case index.
+CSA uses the case index as index in the descriptor table, but CSB searches
+the table for an occurrence of the case index.
+Therefore, the descriptors for CSA and CSB,
+as shown in figure 4, are different.
+All pointers in the table must be addresses of instructions in the
+procedure executing the case instruction.
+.P
+CSA selects the new PC by indexing.
+If the index, a signed integer, is greater than or equal to
+the lower bound and less than or equal to the upper bound,
+then fetch the new PC from the list of instruction pointers by indexing with
+index-lower.
+The table does not contain the value of the upper bound,
+but the value of upper-lower as an unsigned integer.
+If the index is out of bounds or if the fetched pointer is 0,
+then fetch the default instruction pointer.
+If the resulting PC is 0, then trap.
+.P
+CSB selects the new PC by searching.
+The table is searched for an entry with index value equal to the case index.
+That entry or, if none is found, the default entry contains the
+new PC.
+When the resulting PC is 0, a trap is performed.
+.P
+The choice of which case instruction to use for
+each source language case statement
+is up to the front end.
+If the range of the index value is dense, i.e
+.DS
+(highest value - lowest value) / number of cases
+.DE 1
+is less than some threshold, then CSA is the obvious choice.
+If the range is sparse, CSB is better.
+.N 2
+.DS
+   |--------------------|        |--------------------|  high address
+   | pointer for upb    |        |    pointer n-1     |
+   |--------------------|        |-  -  -  -  -  -  - |
+   |         .          |        |     index  n-1     |
+   |         .          |        |--------------------|
+   |         .          |        |          .         |
+   |         .          |        |          .         |
+   |         .          |        |          .         |
+   |         .          |        |--------------------|
+   |         .          |        |    pointer  1      |
+   |--------------------|        |-  -  -  -  -  -  - |
+   | pointer for lwb+1  |        |     index   1      |
+   |--------------------|        |--------------------|
+   | pointer for lwb    |        |    pointer  0      |
+   |--------------------|        |-  -  -  -  -  -  - |
+   |   upper - lower    |        |     index   0      |
+   |--------------------|        |--------------------|
+   |    lower bound     |        | number of entries  |
+   |--------------------|        |--------------------|
+   |  default pointer   |        |  default pointer   |  low address
+   |--------------------|        |--------------------|
+
+       CSA descriptor                CSB descriptor
+
+
+      Figure 4. Descriptor layout for CSA and CSB
+.DE

+ 377 - 0
doc/em/dspace.nr

@@ -0,0 +1,377 @@
+.BP
+.SN 4
+.S1 "DATA ADDRESS SPACE"
+The data address space is divided into three parts, called 'areas',
+each with its own addressing method:
+global data area,
+local data area (including the stack),
+and heap data area.
+These data areas must be part of the same
+address space because all data is accessed by
+the same type of pointers.
+.P
+Space for global data is reserved using several pseudoinstructions in the
+assembly language, as described in
+the next paragraph and chapter 11.
+The size of the global data area is fixed per program.
+.A
+Global data is addressed absolutely in the machine language.
+Many instructions are available to address global data.
+They all have an absolute address as argument.
+Examples are LOE, LAE and STE.
+.P
+Part of the global data area is initialized by the
+compiler, the
+rest is not initialized at all or is initialized
+with a value, typically -32768 or 0.
+Part of the initialized global data may be made read-only
+if the implementation supports protection.
+.P
+The local data area is used as a stack,
+which grows from high to low addresses
+and contains some data for each active procedure
+invocation, called a 'frame'.
+The size of the local data area varies dynamically during
+execution.
+Below the current procedure frame resides the operand stack.
+The stack pointer SP always points to the bottom of
+the local data area.
+Local data is addressed by offsetting from the local base pointer LB.
+LB always points to the frame of the current procedure.
+Only the words of the current frame and the parameters
+can be addressed directly.
+Variables in other active procedures are addressed by following
+the chain of statically enclosing procedures using the LXL or LXA instruction.
+The variables in dynamically enclosing procedures can be
+addressed with the use of the DCH instruction.
+.A
+Many instructions have offsets to LB as argument,
+for instance LOL, LAL and STL.
+The arguments of these instructions range from -1 to some
+(negative) minimum
+for the access of local storage and from 0 to some (positive)
+maximum for parameter access.
+.P
+The procedure call instructions CAL and CAI each create a new frame
+on the stack.
+Each procedure has an assembly-time parameter specifying
+the number of bytes needed for local storage.
+This storage is allocated each time the procedure is called and
+must be a multiple of the wordsize.
+Each procedure, therefore, starts with a stack with the local variables
+already allocated.
+The return instructions RET and RTT remove a frame.
+The actual parameters must be removed by the calling procedure.
+.P
+RET may copy some words from the stack of
+the returning procedure to an unnamed 'function return area'.
+This area is available for 'READ-ONCE' access using the LFR instruction.
+The result of a LFR is only defined if the size used to fetch
+is identical to the size used in the last return.
+The instruction ASP, used to remove the parameters from the
+stack, the branch instruction BRA and the non-local goto
+instrucion GTO are the only ones that leave the contents of
+the 'function return area' intact.
+All other instructions are allowed to destroy the function
+return area.
+Thus parameters can be popped before fetching the function result.
+The maximum size of all function return areas is
+implementation dependent,
+but should allow procedure instance identifiers and all
+implemented objects of type integer, unsigned, float
+and pointer to be returned.
+In most implementations
+the maximum size of the function return
+area is twice the pointer size,
+because we want to be able to handle 'procedure instance
+identifiers' which consist of a procedure identifier and the LB
+of a frame belonging to that procedure.
+.P
+The heap data area grows upwards, to higher numbered
+addresses.
+It is initially empty.
+The initial value of the heap pointer HP
+marks the low end.
+The heap pointer may be manipulated
+by the LOR and STR instructions.
+The heap can only be addressed indirectly,
+by pointers derived from previous values of HP.
+.S2 "Global data area"
+The initial size of the global data area is determined at assembly time.
+Global data is allocated by several
+pseudoinstructions in the EM assembly
+language.
+Each pseudoinstruction allocates one or more bytes.
+The bytes allocated for a single pseudo form
+a 'block'.
+A block differs from a fragment, because,
+under certain conditions, several blocks are allocated
+in a single fragment.
+This guarantees that the bytes of these blocks
+are consecutive.
+.P
+Global data is addressed absolutely in binary
+machine language.
+Most compilers, however,
+cannot assign absolute addresses to their global variables,
+especially not if the language
+allows programs to be composed of several separately compiled modules.
+The assembly language therefore allows the compiler to name
+the first address of a global data block with an alphanumeric label.
+Moreover, the only way to address such a named global data block
+in the assembly language is by using its name.
+It is the task of the assembler/loader to
+translate these labels into absolute addresses.
+These labels may also be used
+in CON and ROM pseudoinstructions to initialize pointers.
+.P
+The pseudoinstruction CON allocates initialized data.
+ROM acts like CON but indicates that the initialized data will
+not change during execution of the program.
+The pseudoinstruction BSS allocates a block of uninitialized
+or identically initialized
+data.
+The pseudoinstruction HOL is similar to BSS,
+but it alters the meaning of subsequent absolute addressing in
+the assembly language.
+.P
+Another type of global data is a small block,
+called the ABS block, with an implementation defined size.
+Storage in this type of block can only be addressed
+absolutely in assembly language.
+The first word has address 0 and is used to maintain the
+source line number.
+Special instructions LIN and LNI are provided to
+update this counter.
+A pointer at location 4 points to a string containing the
+current source file name.
+The instruction FIL can be used to update the pointer.
+.P
+All numeric arguments of the instructions that address
+the global data area refer to locations in the
+ABS block unless
+they are preceded by at least one HOL pseudo in the same
+module,
+in which case they refer to the storage area allocated by the
+last HOL pseudoinstruction.
+Thus LOE 0 loads the zeroth word of the most recent HOL, unless no HOL has
+appeared in the current file so
+far, in which case it loads the zeroth word of the
+ABS fragment.
+.P
+The global data area is highly fragmented.
+The ABS block and each HOL and BSS block are separate fragments.
+The way fragments are formed from CON and ROM blocks is more complex.
+The assemblers group several blocks into a single fragment.
+A fragment only contains blocks of the same type: CON or ROM.
+It is guaranteed that the bytes allocated for two consecutive CON pseudos are
+allocated consecutively in a single fragment, unless
+these CON pseudos are separated in the assembly language program
+by a data label definition or one or more of the following pseudos:
+.DS
+
+     ROM, BSS, HOL and END
+
+.DE
+An analogous rule holds for ROM pseudos.
+.S2 "Local data area"
+The local data area consists of a sequence of frames, one for
+each active procedure.
+Below the frame of the current procedure resides the
+expression stack.
+Frames are generated by procedure calls and are
+removed by procedure returns.
+A procedure frame consists of six 'zones':
+.DS
+
+  1.  The return status block
+  2.  The local variables and compiler temporaries
+  3.  The register save block
+  4.  The dynamic local generators
+  5.  The operand stack.
+  6.  The parameters of a procedure one level deeper
+
+.DE
+A sample frame is shown in Figure 1.
+.P
+Before a procedure call is performed the actual
+parameters are pushed onto the stack of the calling procedure.
+The exact details are compiler dependent.
+EM allows procedures to be called with a variable number of
+parameters.
+The implementation of the C-language almost forces its runtime
+system to push the parameters in reverse order, that is,
+the first positional parameter last.
+Most compilers use the C calling convention to be compatible.
+The parameters of a procedure belong to the frame of the
+calling procedure.
+Note that the evaluation of the actual parameters may imply
+the calling of procedures.
+The parameters can be accessed with certain instructions using
+offsets of 0 and greater.
+The first byte of the last parameter pushed has offset 0.
+Note that the parameter at offset 0 has a special use in the
+instructions following the static chain (LXL and LXA).
+These instructions assume that this parameter contains the LB of
+the statically enclosing procedure.
+Procedures that do not have a dynamically enclosing procedure
+do not need a static link at offset 0.
+.P
+Two instructions are available to perform procedure calls, CAL
+and CAI.
+Several tasks are performed by these call instructions.
+.A
+First, a part of the status of the calling procedure is
+saved on the stack in the return status block.
+This block should contain the return address of the calling
+procedure, its LB and other implementation dependent data.
+The size of this block is fixed for any given implementation
+because the lexical instructions LPB, LXL and LXA must be able to
+obtain the base addresses of the procedure parameters \fBand\fP local
+variables.
+An alternative solution can be used on machines with a highly
+segmented address space.
+The stack frames need not be contiguous then and the first
+status save area can contain the parameter base AB,
+which has the value of SP just after the last parameter has
+been pushed.
+.A
+Second, the LB is changed to point to the
+first word above the local variables.
+The new LB is a copy of the SP after the return status
+block has been pushed.
+.A
+Third, the amount of local storage needed by the procedure is
+reserved.
+The parameters and local storage are accessed by the same instructions.
+Negative offsets are used for access to local variables.
+The highest byte, that is the byte nearest
+to LB, has to be accessed with offset -1.
+The pseudoinstruction specifying the entry point of a
+procedure, has an argument that specifies the amount of local
+storage needed.
+The local variables allocated by the CAI or CAL instructions
+are the only ones that can be accessed with a fixed negative offset.
+The initial value of the allocated words is
+not defined, but implementations that check for undefined
+values will probably initialize them with a
+special 'undefined' pattern, typically -32768.
+.A
+Fourth, any EM implementation is allowed to reserve a variable size
+block beneath the local variables.
+This block could, for example, be used to save a variable number
+of registers.
+.A
+Finally, the address of the entry point of the called procedure
+is loaded into the Program Counter.
+.P
+The ASP instruction can be used to allocate further (dynamic)
+local storage.
+The base address of such storage must be obtained with a LOR~SP
+instruction.
+This same instruction ASP may also be used
+to remove some words from the stack.
+.P
+There is a version of ASP, called ASS, which fetches the number
+of bytes to allocate from the stack.
+It can be used to allocate space for local
+objects whose size is unknown at compile time,
+so called 'dynamic local generators'.
+.P
+Control is returned to the calling procedure with a RET instruction.
+Any return value is then copied to the 'function return area'.
+The frame created by the call is deallocated and the status of
+the calling procedure is restored.
+The value of SP just after the return value has been popped must
+be the same as the
+value of SP just before executing the first instruction of this
+invocation.
+This means that when a RET is executed the operand stack can
+only contain the return value and all dynamically generated locals must be
+deallocated.
+Violating this restriction might result in hard to detect
+errors.
+The calling procedure has to remove the parameters from the stack.
+This can be done with the aforementioned ASP instruction.
+.P
+Each procedure frame is a separate fragment.
+Because any fragment may be placed anywhere in memory,
+procedure frames need not be contiguous.
+.DS
+                |===============================|
+                |     actual parameter  n-1     |
+                |-------------------------------|
+                |              .                |
+                |              .                |
+                |              .                |
+                |-------------------------------|
+                |     actual parameter  0       | ( <- AB )
+                |===============================|
+
+
+                |===============================|
+                |///////////////////////////////|
+                |///// return status block /////|
+                |///////////////////////////////|   <- LB
+                |===============================|
+                |                               |
+                |       local variables         |
+                |                               |
+                |-------------------------------|
+                |                               |
+                |      compiler temporaries     |
+                |                               |
+                |===============================|
+                |///////////////////////////////|
+                |///// register save block /////|
+                |///////////////////////////////|
+                |===============================|
+                |                               |
+                |   dynamic local generators    |
+                |                               |
+                |===============================|
+                |           operand             |
+                |-------------------------------|
+                |           operand             |
+                |===============================|
+                |         parameter  m-1        |
+                |-------------------------------|
+                |              .                |
+                |              .                |
+                |              .                |
+                |-------------------------------|
+                |         parameter  0          | <- SP
+                |===============================|
+
+          Figure 1. A sample procedure frame and parameters.
+.DE
+.S2 "Heap data area"
+The heap area starts empty, with HP
+pointing to the low end of it.
+HP always contains a word address.
+A copy of HP can always be obtained with the LOR instruction.
+A new value may be stored in the heap pointer using the STR instruction.
+If the new value is greater than the old one,
+then the heap grows.
+If it is smaller, then the heap shrinks.
+HP may never point below its original value.
+All words between the current HP and the original HP
+are allocated to the heap.
+The heap may not grow into a part of memory that is already allocated
+for the stack.
+When this is attempted, the STR instruction will cause a trap to occur.
+.P
+The only way to address the heap is indirectly.
+Whenever an object is allocated by increasing HP,
+then the old HP value must be saved and can be used later to address
+the allocated object.
+If, in the meantime, HP is decreased so that the object
+is no longer part of the heap, then an attempt to access
+the object is not allowed.
+Furthermore, if the heap pointer is increased again to above
+the object address, then access to the old object gives undefined results.
+.P
+The heap is a single fragment.
+All bytes have consecutive addresses.
+No limits are imposed on the size of the heap as long as it fits
+in the available data address space.

+ 9 - 0
doc/em/even.c

@@ -0,0 +1,9 @@
+main() {
+	register int l,j ;
+
+	for ( j=0 ; (l=getchar()) != -1 ; j++ ) {
+		if ( j%16 == 15 ) printf("%3d\n",l&0377 ) ;
+		else              printf("%3d ",l&0377 ) ;
+	}
+	printf("\n") ;
+}

+ 178 - 0
doc/em/exam.e

@@ -0,0 +1,178 @@
+  mes 2,2,2              ; wordsize 2, pointersize 2
+ .1
+  rom 't.p\000'          ; the name of the source file
+  hol 552,-32768,0       ; externals and buf occupy 552 bytes
+  exp $sum               ; sum can be called from other modules
+  pro $sum,2             ; procedure sum; 2 bytes local storage
+  lin 8                  ; code from source line 8
+  ldl 0                  ; load two locals ( a and b )
+  adi 2                  ; add them
+  ret 2                  ; return the result
+  end 2                  ; end of procedure ( still two bytes local storage )
+ .2
+  rom 1,99,2             ; descriptor of array a[]
+  exp $test              ; the compiler exports all level 0 procedures
+  pro $test,226          ; procedure test, 226 bytes local storage
+ .3
+  rom 4.8F8              ; assemble Floating point 4.8 (8 bytes) in
+ .4                              ; global storage
+  rom 0.5F8              ; same for 0.5
+  mes 3,-226,2,2         ; compiler temporary not referenced indirect
+  mes 3,-24,2,0          ; the same is true for i, j, b and c in test
+  mes 3,-22,2,0
+  mes 3,-4,2,0
+  mes 3,-2,2,0
+  mes 3,-20,8,0          ; and for x and y
+  mes 3,-12,8,0
+  lin 20                 ; maintain source line number
+  loc 1
+  stl -4                 ; j := 1
+  lni                    ; was lin 21 prior to optimization
+  lol -4
+  loc 3
+  mli 2
+  loc 6
+  adi 2
+  stl -2                 ; i := 3 * j + 6
+  lni                    ; was lin 22 prior to optimization
+  lae .3
+  loi 8
+  lal -12
+  sti 8                  ; x := 4.8
+  lni                    ; was lin 23 prior to optimization
+  lal -12
+  loi 8
+  lae .4
+  loi 8
+  dvf 8
+  lal -20
+  sti 8                  ; y := x / 0.5
+  lni                    ; was lin 24 prior to optimization
+  loc 1
+  stl -22                ; b := true
+  lni                    ; was lin 25 prior to optimization
+  loc 122
+  stl -24                ; c := 'z'
+  lni                    ; was lin 26 prior to optimization
+  loc 1
+  stl -2                 ; for i:= 1
+ 2
+  lol -2
+  dup 2
+  mli 2                  ; i*i
+  lal -224
+  lol -2
+  lae .2
+  sar 2                  ; a[i] :=
+  lol -2
+  loc 100
+  beq *3                 ; to 100 do
+  inl -2                 ; increment i and loop
+  bra *2
+ 3
+  lin 27
+  lol -4
+  loc 27
+  adi 2                  ; j + 27
+  sil 0                  ; r.r1 :=
+  lni                    ; was lin 28 prior to optimization
+  lol -22                ; b
+  lol 0
+  stf 10                 ; r.r3 :=
+  lni                    ; was lin 29 prior to optimization
+  lal -20
+  loi 16
+  adf 8                  ; x + y
+  lol 0
+  adp 2
+  sti 8                  ; r.r2 :=
+  lni                    ; was lin 23 prior to optimization
+  lal -224
+  lol -4
+  lae .2
+  lar 2                  ; a[j]
+  lil 0                  ; r.r1
+  cal $sum               ; call now
+  asp 4                  ; remove parameters from stack
+  lfr 2                  ; get function result
+  stl -2                 ; i :=
+ 4
+  lin 31
+  lol -2
+  zle *5                 ; while i > 0 do
+  lol -4
+  lil 0
+  adi 2
+  stl -4                 ; j := j + r.r1
+  del -2                 ; i := i - 1
+  bra *4                 ; loop
+ 5
+  lin 32
+  lol 0
+  stl -226               ; make copy of address of r
+  lol -22
+  lol -226
+  stf 10                 ; r3 := b
+  lal -20
+  loi 16
+  adf 8
+  lol -226
+  adp 2
+  sti 8                  ; r2 := x + y
+  loc 0
+  sil -226               ; r1 := 0
+  lin 34                 ; note the abscence of the unnecesary jump
+  lae 22                 ; address of output structure
+  lol -4
+  cal $_wri              ; write integer with default width
+  asp 4                  ; pop parameters
+  lae 22
+  lol -2
+  loc 6
+  cal $_wsi              ; write integer width 6
+  asp 6
+  lae 22
+  lal -12
+  loi 8
+  loc 9
+  loc 3
+  cal $_wrf              ; write fixed format real, width 9, precision 3
+  asp 14
+  lae 22
+  lol -22
+  cal $_wrb              ; write boolean, default width
+  asp 4
+  lae 22
+  cal $_wln              ; writeln
+  asp 2
+  ret 0                  ; return, no result
+  end 226
+  exp $_main
+  pro $_main,0           ; main program
+ .6
+  con 2,-1,22            ; description of external files
+ .5
+  rom 15.96F8
+  fil .1                 ; maintain source file name
+  lae .6                 ; description of external files
+  lae 0                  ; base of hol area to relocate buffer addresses
+  cal $_ini              ; initialize files, etc...
+  asp 4
+  lin 37
+  lae .5
+  loi 8
+  lae 2
+  sti 8                  ; x := 15.9
+  lni                    ; was lin 38 prior to optimization
+  loc 99
+  ste 0                  ; mi := 99
+  lni                    ; was lin 39 prior to optimization
+  lae 10                 ; address of r
+  cal $test
+  asp 2
+  loc 0                  ; normal exit
+  cal $_hlt              ; cleanup and finish
+  asp 2
+  end 0
+  mes 4,40               ; length of source file is 40 lines
+  mes 5                  ; reals were used

+ 40 - 0
doc/em/exam.p

@@ -0,0 +1,40 @@
+  program example(output);
+  {This program just demonstrates typical EM code.}
+  type rec = record r1: integer; r2:real; r3: boolean end;
+  var mi: integer;  mx:real;  r:rec;
+
+  function sum(a,b:integer):integer;
+  begin
+    sum := a + b
+  end;
+
+  procedure test(var r: rec);
+  label 1;
+  var   i,j: integer;
+	x,y: real;
+	b: boolean;
+	c: char;
+	a: array[1..100] of integer;
+
+  begin
+	j := 1;
+	i := 3 * j + 6;
+	x := 4.8;
+	y := x/0.5;
+	b := true;
+	c := 'z';
+	for i:= 1 to 100 do a[i] := i * i;
+	r.r1 := j+27;
+	r.r3 := b;
+	r.r2 := x+y;
+	i := sum(r.r1, a[j]);
+	while i > 0 do begin j := j + r.r1; i := i - 1 end;
+	with r do begin r3 := b;  r2 := x+y;  r1 := 0 end;
+	goto 1;
+  1:    writeln(j, i:6, x:9:3, b)
+  end; {test}
+  begin {main program}
+    mx := 15.96;
+    mi := 99;
+    test(r)
+  end.

+ 180 - 0
doc/em/intro.nr

@@ -0,0 +1,180 @@
+.BP
+.S1 "INTRODUCTION"
+EM is a family of intermediate languages designed for producing
+portable compilers.
+The general strategy is for a program called
+.B front end
+to translate the source program to EM.
+Another program,
+.B back
+.BW end
+translates EM to target assembly language.
+Alternatively, the EM code can be assembled to a binary form
+and interpreted.
+These considerations led to the following goals:
+.IS 2 10
+.PS 1 4
+.PT
+The design should allow translation to,
+or interpretation on, a wide range of existing machines.
+Design decisions should be delayed as far as possible
+and the implications of these decisions should
+be localized as much as possible.
+.N
+The current microcomputer technology offers 8, 16 and 32 bit machines
+with various sizes of address space.
+EM should be flexible enough to be useful on most of these
+machines.
+The differences between the members of the EM family should only
+concern the wordsize and address space size.
+.PT
+The architecture should ease the task of code generation for
+high level languages such as Pascal, C, Ada, Algol 68, BCPL.
+.PT
+The instruction set used by the interpreter should be compact,
+to reduce the amount of memory needed
+for program storage, and to reduce the time needed to transmit
+programs over communication lines.
+.PT
+It should be designed with microprogrammed implementations in
+mind; in particular, the use of many short fields within
+instruction opcodes should be avoided, because their extraction by the
+microprogram or conversion to other instruction formats is inefficient.
+.PE
+.IE
+.A
+The basic architecture is based on the concept of a stack. The stack
+is used for procedure return addresses, actual parameters, local variables,
+and arithmetic operations.
+There are several built-in object types,
+for example, signed and unsigned integers,
+floating point numbers, pointers and sets of bits.
+There are instructions to push and pop objects
+to and from the stack.
+The push and pop instructions are not typed.
+They only care about the size of the objects.
+For each built-in type there are
+reverse Polish type instructions that pop one or more
+objects from the top of
+the stack, perform an operation, and push the result back onto the
+stack.
+For all types except pointers,
+these instructions have the object size
+as argument.
+.P
+There are no visible general registers used for arithmetic operands
+etc. This is in contrast to most third generation computers, which usually
+have 8 or 16 general registers. The decision not to have a group of
+general registers was fully intentional, and follows W.L. Van der
+Poel's dictum that a machine should have 0, 1, or an infinite
+number of any feature. General registers have two primary uses: to hold
+intermediate results of complicated expressions, e.g.
+.IS 5 0 1
+((a*b + c*d)/e + f*g/h) * i
+.IE 1
+and to hold local variables.
+.P
+Various studies
+have shown that the average expression has fewer than two operands,
+making the former use of registers of doubtful value. The present trend
+toward structured programs consisting of many small
+procedures greatly reduces the value of registers to hold local variables
+because the large number of procedure calls implies a large overhead in
+saving and restoring the registers at every call.
+.BP
+.P
+Although there are no general purpose registers, there are a
+few internal registers with specific functions as follows:
+.IS 2
+.N 1
+.TS
+tab(:);
+l 1 l l.
+PC:-:Program Counter:Pointer to next instruction
+LB:-:Local Base:Points to base of the local variables \
+in the current procedure.
+SP:-:Stack Pointer:Points to the highest occupied word on the stack.
+HP:-:Heap Pointer:Points to the top of the heap area.
+.TE 1
+.IE
+.A
+Furthermore, reverse Polish code is much easier to generate than
+multi-register machine code, especially if highly efficient code is
+desired.
+When translating to assembly language the back end can make
+good use of the target machine's registers.
+An EM machine can
+achieve high performance by keeping part of the stack
+in high speed storage (a cache or microprogram scratchpad memory) rather
+than in primary memory.
+.P
+Again according to van der Poel's dictum,
+all EM instructions have zero or one argument.
+We believe that instructions needing two arguments
+can be split into two simpler ones.
+The simpler ones can probably be used in other
+circumstances as well.
+Moreover, these two instructions together often
+have a shorter encoding than the single
+instruction before.
+.P
+This document describes EM at three different levels:
+the abstract level, the assembly language level and
+the machine language level.
+.A
+The most important level is that of the abstract EM architecture.
+This level deals with the basic design issues.
+Only the functional capabilities of instructions are relevant, not their
+format or encoding.
+Most chapters of this document refer to the abstract level
+and it is explicitly stated whenever
+another level is described.
+.A
+The assembly language is intended for the compiler writer.
+It presents a more or less orthogonal instruction
+set and provides symbolic names for data.
+Moreover, it facilitates the linking of
+separately compiled 'modules' into a single program
+by providing several pseudoinstructions.
+.A
+The machine language is designed for interpretation with a compact
+program text and easy decoding.
+The binary representation of the machine language instruction set is
+far from orthogonal.
+Frequent instructions have a short opcode.
+The encoding is fully byte oriented.
+These bytes do not contain small bit fields, because
+bit fields would slow down decoding considerably.
+.P
+A common use for EM is for producing portable (cross) compilers.
+When used this way, the compilers produce
+EM assembly language as their output.
+To run the compiled program on the target machine,
+the back end, translates the EM assembly language to
+the target machine's assembly language.
+When this approach is used, the format of the EM
+machine language instructions is irrelevant.
+On the other hand, when writing an interpreter for EM machine language
+programs, the interpreter must deal with the machine language
+and not with the symbolic assembly language.
+.P
+As mentioned above, the
+current microcomputer technology offers 8, 16 and 32 bit
+machines with address spaces ranging from 2\v'-0.5m'16\v'0.5m'
+to 2\v'-0.5m'32\v'0.5m' bytes.
+Having one size of pointers and integers restricts
+the usefulness of the language.
+We decided to have a different language for each combination of
+word and pointer size.
+All languages offer the same instruction set and differ only in
+memory alignment restrictions and the implicit size assumed in
+several instructions.
+The languages
+differ slightly for the
+different size combinations.
+For example: the
+size of any object on the stack and alignment restrictions.
+The wordsize is restricted to powers of 2 and
+the pointer size must be a multiple of the wordsize.
+Almost all programs handling EM will be parametrized with word
+and pointer size.

+ 376 - 0
doc/em/iotrap.nr

@@ -0,0 +1,376 @@
+.SN 8
+.VS 1 0
+.BP
+.S1 "ENVIRONMENT INTERACTIONS"
+EM programs can interact with their environment in three ways.
+Two, starting/stopping and monitor calls, are dealt with in this chapter.
+The remaining way to interact, interrupts, will be treated
+together with traps in chapter 9.
+.S2 "Program starting and stopping"
+EM user programs start with a call to a procedure called
+m_a_i_n.
+The assembler and backends look for the definition of a procedure
+with this name in their input.
+The call passes three parameters to the procedure.
+The parameters are similar to the parameters supplied by the
+UNIX
+.FS
+UNIX is a Trademark of Bell Laboratories.
+.FE
+operating system to C programs.
+These parameters are often called
+.BW argc ,
+.B argv
+and
+.BW envp .
+Argc is the parameter nearest to LB and is a wordsized integer.
+The other two are pointers to the first element of an array of
+string pointers.
+.N
+The
+.B argv
+array contains
+.B argc
+strings, the first of which contains the program call name.
+The other strings in the
+.B argv
+array are the program parameters.
+.P
+The
+.B envp
+array contains strings in the form "name=string", where 'name'
+is the name of an environment variable and string its value.
+The
+.B envp
+is terminated by a zero pointer.
+.P
+An EM user program stops if the program returns from the first
+invocation of m_a_i_n.
+The contents of the function return area are used to procure a
+wordsized program return code.
+EM programs also stop when traps and interrupts occur that are
+not caught and when the exit monitor call is executed.
+.S2 "Input/Output and other monitor calls"
+EM differs from most conventional machines in that it has high level i/o
+instructions.
+Typical instructions are OPEN FILE and READ FROM FILE instead
+of low level instructions such as setting and clearing
+bits in device registers.
+By providing such high level i/o primitives, the task of implementing
+EM on various non EM machines is made considerably easier.
+.P
+I/O is initiated by the MON instruction, which expects an iocode on top
+of the stack.
+Often there are also parameters which are pushed on the
+stack in reverse order, that is: last
+parameter first.
+Some i/o functions also provide results, which are returned on the stack.
+In the list of monitor calls we use several types of parameters and results,
+these types consist of integers and unsigneds of varying sizes, but never
+smaller than the wordsize, and the two pointer types.
+.N 1
+The names of the types used are:
+.IS 4
+.PS - 10
+.PT int
+an integer of wordsize
+.PT int2
+an integer whose size is the maximum of the wordsize and 2
+bytes
+.PT int4
+an integer whose size is the maximum of the wordsize and 4
+bytes
+.PT intp
+an integer with the size of a pointer
+.PT uns2
+an unsigned integer whose size is the maximum of the wordsize and 2
+.PT unsp
+an unsigned integer with the size of a pointer
+.PT ptr
+a pointer into data space
+.PE 1
+.IE 0
+The table below lists the i/o codes with their results and
+parameters.
+This list is similar to the system calls of the UNIX Version 7
+operating system.
+.BP
+.A
+To execute a monitor call, proceed as follows:
+.IS 2
+.N 1
+.PS a 4 "" )
+.PT
+Stack the parameters, in reverse order, last parameter first.
+.PT
+Push the monitor call number (iocode) onto the stack.
+.PT
+Execute the MON instruction.
+.PE 1
+.IE
+An error code is present on the top of the stack after
+execution of most monitor calls.
+If this error code is zero, the call performed the action
+requested and the results are available on top of the stack.
+Non-zero error codes indicate a failure, in this case no
+results are available and the error code has been pushed twice.
+This construction enables programs to test for failure with a
+single instruction (~TEQ or TNE~) and still find out the cause of
+the failure.
+The result name 'e' is reserved for the error code.
+.N 1
+List of monitor calls.
+.DS B
+number name    parameters      results           function
+
+   1   Exit    status:int                        Terminate this process
+   2   Fork                    e,flag,pid:int    Spawn new process
+   3   Read    fildes:int;buf:ptr;nbytes:unsp
+                               e:int;rbytes:unsp Read from file
+   4   Write   fildes:int;buf:ptr;nbytes:unsp
+                               e:int;wbytes:unsp Write on a file
+   5   Open    string:ptr;flag:int
+                               e,fildes:int      Open file for read and/or write
+   6   Close   fildes:int      e:int             Close a file
+   7   Wait                    e:int;status,pid:int2
+                                                 Wait for child
+   8   Creat   string:ptr;mode:int
+                               e,fildes:int      Create a new file
+   9   Link    string1,string2:ptr
+                               e:int             Link to a file
+  10   Unlink  string:ptr      e:int             Remove directory entry
+  12   Chdir   string:ptr      e:int             Change default directory
+  14   Mknod   string:ptr;mode,addr:int2
+                               e:int             Make a special file
+  15   Chmod   string:ptr;mode:int2
+                               e:int             Change mode of file
+  16   Chown   string:ptr;owner,group:int2
+                               e:int             Change owner/group of a file
+  18   Stat    string,statbuf:ptr
+                               e:int             Get file status
+  19   Lseek   fildes:int;off:int4;whence:int
+                               e:int;oldoff:int4 Move read/write pointer
+  20   Getpid                  pid:int2          Get process identification
+  21   Mount   special,string:ptr;rwflag:int
+                               e:int             Mount file system
+  22   Umount  special:ptr     e:int             Unmount file system
+  23   Setuid  userid:int2     e:int             Set user ID
+  24   Getuid                  e_uid,r_uid:int2  Get user ID
+  25   Stime   time:int4       e:int             Set time and date
+  26   Ptrace  request:int;pid:int2;addr:ptr;data:int
+                               e,value:int       Process trace
+  27   Alarm   seconds:uns2    previous:uns2     Schedule signal
+  28   Fstat   fildes:int;statbuf:ptr
+                               e:int             Get file status
+  29   Pause                                     Stop until signal
+  30   Utime   string,timep:ptr
+                               e:int             Set file times
+  33   Access  string,mode:int e:int             Determine file accessibility
+  34   Nice    incr:int                          Set program priority
+  35   Ftime   bufp:ptr        e:int             Get date and time
+  36   Sync                                      Update filesystem
+  37   Kill    pid:int2;sig:int
+                               e:int             Send signal to a process
+  41   Dup     fildes,newfildes:int
+                               e,fildes:int      Duplicate a file descriptor
+  42   Pipe                    e,w_des,r_des:int Create a pipe
+  43   Times   buffer:ptr                        Get process times
+  44   Profil  buff:ptr;bufsiz,offset,scale:intp Execution time profile
+  46   Setgid  gid:int2        e:int             Set group ID
+  47   Getgid                  e_gid,r_gid:int   Get group ID
+  48   Sigtrp  trapno,signo:int
+                               e,prevtrap:int    See below
+  51   Acct    file:ptr        e:int             Turn accounting on or off
+  53   Lock    flag:int        e:int             Lock a process
+  54   Ioctl   fildes,request:int;argp:ptr
+                               e:int             Control device
+  56   Mpxcall cmd:int;vec:ptr e:int             Multiplexed file handling
+  59   Exece   name,argv,envp:ptr
+                               e:int             Execute a file
+  60   Umask   complmode:int2  oldmask:int2      Set file creation mode mask
+  61   Chroot  string:ptr      e:int             Change root directory
+.DE 1
+Codes 0, 11, 13, 17, 31, 32, 38, 39, 40, 45, 49, 50, 52,
+55, 57, 58, 62, and 63 are
+not used.
+.P
+All monitor calls, except fork and sigtrp
+are the same as the UNIX version 7 system calls.
+.P
+The sigtrp entry maps UNIX signals onto EM interrupts.
+Normally, trapno is in the range 0 to 252.
+In that case it requests that signal signo
+will cause trap trapno to occur.
+When given trap number -2, default signal handling is reset, and when given
+trap number -3, the signal is ignored.
+.P
+The flag returned by fork is 1 in the child process and 0 in
+the parent.
+The pid returned is the process-id of the other process.
+.BP
+.S1 "TRAPS AND INTERRUPTS"
+EM provides a means for the user program to catch all traps
+generated by the program itself, the hardware, or external conditions.
+This mechanism uses five instructions: LIM, SIM, SIG, TRP and RTT.
+This section of the manual may be omitted on the first reading since it
+presupposes knowledge of the EM instruction set.
+.P
+The action taken when a trap occures is determined by the value
+of an internal EM trap register.
+This register contains a pointer to a procedure.
+Initially the pointer used is zero and all traps halt the
+program with, hopefully, a useful message to the outside world.
+The SIG instruction can be used to alter the trap register,
+it pops a procedure pointer from the
+stack into the trap register.
+When a trap occurs after storing a nonzero value in the trap
+register, the procedure pointed to by the trap register
+is called with the trap number
+as the only parameter (see below).
+SIG returns the previous value of the trap register on the
+stack.
+Two consecutive SIGs are a no-op.
+When a trap occurs, the trap register is reset to its initial
+condition, to prevent recursive traps from hanging the machine up,
+e.g. stack overflow in the stack overflow handling procedure.
+.P
+The runtime systems for some languages need to ignore some EM
+traps.
+EM offers a feature called the ignore mask.
+It contains one bit for each of the lowest 16 trap numbers.
+The bits are numbered 0 to 15, with the least significant bit
+having number 0.
+If a certain bit is 1 the corresponding trap never
+occurs and processing simply continues.
+The actions performed by the offending instruction are
+described by the Pascal program in appendix A.
+.N
+If the bit is 0, traps are not ignored.
+The instructions LIM and SIM allow copying and replacement of
+the ignore mask.~
+.P
+The TRP instruction generates a trap, the trap number being found on the
+stack.
+This is, among other things,
+useful for library procedures and runtime systems.
+It can also be used by a low level trap procedure to pass the trap to a
+higher level one (see example below).
+.P
+The RTT instruction returns from the trap procedure and continues after the
+trap.
+In the list below all traps marked with an asterisk ('*') are
+considered to be fatal and it is explicitly undefined what happens if
+you try to restart after the trap.
+.P
+The way a trap procedure is called is completely compatible
+with normal calling conventions. The only way a trap procedure
+differs from normal procedures is the return. It has to use RTT instead
+of RET. This is necessary because the complete runtime status is saved on the
+stack before calling the procedure and all this status has to be reloaded.
+Error numbers are in the range 0 to 252.
+The trap numbers are divided into three categories:
+.IS 4
+.N 1
+.PS - 10
+.PT ~~0-~63
+EM machine errors, e.g. illegal instruction.
+.PS - 8
+.PT ~0-15
+maskable
+.PT 16-63
+not maskable
+.PE
+.PT ~64-127
+Reserved for use by compilers, run time systems, etc.
+.PT 128-252
+Available for user programs.
+.PE 1
+.IE
+EM machine errors are numbered as follows:
+.DS I 5
+.TS
+tab(@);
+n l l.
+0@EARRAY@Array bound error
+1@ERANGE@Range bound error
+2@ESET@Set bound error
+3@EIOVFL@Integer overflow
+4@EFOVFL@Floating overflow
+5@EFUNFL@Floating underflow
+6@EIDIVZ@Divide by 0
+7@EFDIVZ@Divide by 0.0
+8@EIUND@Undefined integer
+9@EFUND@Undefined float
+10@ECONV@Conversion error
+16*@ESTACK@Stack overflow
+17*@EHEAP@Heap overflow
+18*@EILLINS@Illegal instruction
+19*@EODDZ@Illegal size argument
+20*@ECASE@Case error
+21*@EMEMFLT@Addressing non existent memory
+22*@EBADPTR@Bad pointer used
+23*@EBADPC@Program counter out of range
+24@EBADLAE@Bad argument of LAE
+25@EBADMON@Bad monitor call
+26@EBADLIN@Argument of LIN too high
+27@EBADGTO@GTO descriptor error
+.TE
+.DE 0
+.P
+As an example,
+suppose a subprocedure has to be written to do a numeric
+calculation.
+When an overflow occurs the computation has to be stopped and
+the higher level procedure must be resumed.
+This can be programmed as follows using the mechanism described above:
+.DS B
+ mes 2,2,2              ; set sizes
+ersave
+ bss 2,0,0              ; Room to save previous value of trap procedure
+msave
+ bss 2,0,0              ; Room to save previous value of trap mask
+
+ pro calcule,0          ; entry point
+ lxl 0                  ; fill in non-local goto descriptor with LB
+ ste jmpbuf+4
+ lor 1                  ; and SP
+ ste jmpbuf+2
+ lim                    ; get current ignore mask
+ ste msave              ; save it
+ lim
+ loc 4                  ; bit for EFOVFL
+ ior 2                  ; set in mask
+ sim                    ; ignore EFOVFL from now on
+ lpi $catch             ; load procedure identifier
+ sig                    ; catch wil get all traps now
+ ste ersave             ; save previous trap procedure identifier
+; perform calculation now, possibly generating overflow
+1                       ; label jumped to by catch procedure
+ loe ersave             ; get old trap procedure
+ sig                    ; refer all following trap to old procedure
+ asp 2                  ; remove result of sig
+ loe msave              ; restore previous mask
+ sim                    ; done now
+; load result of calculation
+ ret 2                  ; return result
+jmpbuf
+ con *1,0,0
+ end
+.DE 0
+.VS 1 1
+.DS
+Example of catch procedure
+ pro catch,0            ; Local procedure that must catch the overflow trap
+ lol 2                  ; Load trap number
+ loc 4                  ; check for overflow
+ bne *1                 ; if other trap, call higher trap procedure
+ gto jmpbuf             ; return to procedure calcule
+1                       ; other trap has occurred
+ loe ersave             ; previous trap procedure
+ sig                    ; other procedure will get the traps now
+ asp 2                  ; remove the result of sig
+ lol 2                  ; stack trap number
+ trp                    ; call other trap procedure
+ rtt                    ; if other procedure returns, do the same
+ end
+.DE

+ 6 - 0
doc/em/ip.awk

@@ -0,0 +1,6 @@
+BEGIN { printf ".TS\nlw(6) lw(8) rw(3) rw(6) 14 lw(6) lw(8) rw(3) rw(6) 14 lw(6) lw(8) rw(3) rw(6).\n" }
+NF == 4 { printf "%s\t%s\t%d\t%d",$1,$2,$3,$4 }
+NF == 3 { printf "%s\t%s\t\t%d",$1,$2,$3 }
+ { if ( NR%3 == 0 ) printf("\n") ; else printf("\t"); }
+END { if ( NR%3 != 0 ) printf("\n")
+      printf ".TE\n" }

+ 61 - 0
doc/em/ispace.nr

@@ -0,0 +1,61 @@
+.SN 3
+.BP
+.S1 "INSTRUCTION ADDRESS SPACE"
+The instruction space of the EM machine contains
+the code for procedures.
+Tables necessary for the execution of this code, for example, procedure
+descriptor tables, may also be present.
+The instruction space does not change during
+the execution of a program, so that it may be
+protected.
+No further restrictions to the instruction address space are
+necessary for the abstract and assembly language level.
+.P
+Each procedure has a single entry point: the first instruction.
+A special type of pointer identifies a procedure.
+Pointers into the instruction
+address space have the same size as pointers into data space and
+can, for example, contain the address of the first instruction
+or an index in a procedure descriptor table.
+.A
+There is a single EM program counter, PC, pointing
+to the next instruction to be executed.
+The procedure pointed to by PC is
+called the 'current' procedure.
+A procedure may call another procedure using the CAL or CAI
+instruction.
+The calling procedure remains 'active' and is resumed whenever the called
+procedure returns.
+Note that a procedure has several 'active' invocations when
+called recursively.
+.P
+Each procedure must return properly.
+It is not allowed to fall through to the
+code of the next procedure.
+There are several ways to exit from a procedure:
+.IS 3
+.PS
+.PT
+the RET instruction, which returns to the
+calling procedure.
+.PT
+the RTT instruction, which exits a trap handling routine and resumes
+the trapping instruction (see next chapter).
+.PT
+the GTO instruction, which is used for non-local goto's.
+It can remove several frames from the stack and transfer
+control to an active procedure.
+.PE
+.IE
+.P
+All branch instructions can transfer control
+to any label within the same procedure.
+Branch instructions can never jump out of a procedure.
+.P
+Several language implementations use a so called procedure
+instance identifier, a combination of a procedure identifier and
+the LB of a stack frame, also called static link.
+.P
+The program text for each procedure, as well as any tables,
+are fragments and can be allocated anywhere
+in the instruction address space.

+ 2525 - 0
doc/em/itables

@@ -0,0 +1,2525 @@
+.TS
+.if \n+(b.=1 .nr d. \n(.c-\n(c.-1
+.de 35
+.ps \n(.s
+.vs \n(.vu
+.in \n(.iu
+.if \n(.u .fi
+.if \n(.j .ad
+.if \n(.j=0 .na
+..
+.nf
+.nr #~ 0
+.if n .nr #~ 0.6n
+.ds #d .d
+.if \(ts\n(.z\(ts\(ts .ds #d nl
+.fc
+.nr 33 \n(.s
+.rm 80 81 82 83 84 85 86 87 88 89 90 91
+.nr 80 0
+.nr 38 \waar
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wadp
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wadp
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wasp
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbeq
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wble
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbne
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbra
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcff
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcmf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcms
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdec
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdup
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wfil
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wine
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \winn
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlae
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlal
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlal
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wldc
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wldl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlfr
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlil
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlni
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wloc
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wloe
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlof
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wloi
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlol
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlol
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlxa
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wmli
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wret
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsbf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wset
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsli
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wstf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsti
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wstl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wstl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wtgt
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzeq
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzge
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzlt
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzre
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzrl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \waar
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wadi
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wads
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wand
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wass
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbgt
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbls
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wbne
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcfi
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcmf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcmi
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcmu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcom
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcsb
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wcui
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdel
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdus
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdvf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdvu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wfef
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \winl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \winn
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlar
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wldf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlfr
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlim
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlor
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wlxl
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wmli
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wmlu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wngf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wnop
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wret
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wrmu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wrol
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wrtt
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsbf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsbi
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsbu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsdf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wset
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsil
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsli
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wslu
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsru
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wsts
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wtge
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wxor
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzer
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzle
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wzrf
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wdch
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wexg
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 38 \wldc
+.if \n(80<\n(38 .nr 80 \n(38
+.80
+.rm 80
+.nr 38 6n
+.if \n(80<\n(38 .nr 80 \n(38
+.nr 81 0
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsN
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsw
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wN2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wswP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmN
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \ww2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wwP2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwN
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmPo
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wwP2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wmwN
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wsP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \ww2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wswN
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wewP2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wewP2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wesP
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \wewP2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we2
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \we-
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 38 \w4
+.if \n(81<\n(38 .nr 81 \n(38
+.81
+.rm 81
+.nr 38 8n
+.if \n(81<\n(38 .nr 81 \n(38
+.nr 82 0
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w5
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w2
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w2
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w4
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w8
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w2
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w5
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 38 \w1
+.if \n(82<\n(38 .nr 82 \n(38
+.82
+.rm 82
+.nr 38 3n
+.if \n(82<\n(38 .nr 82 \n(38
+.nr 83 0
+.nr 38 \w34
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w38
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w42
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w45
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w52
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w55
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w58
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w62
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w93
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w96
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w100
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w103
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w106
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w109
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w112
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w117
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w120
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w129
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w132
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w136
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w139
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w143
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w146
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w150
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w152
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w155
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w162
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w168
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w174
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w180
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w190
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w194
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w199
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w202
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w206
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w209
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w214
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w218
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w224
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w228
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w235
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w238
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w242
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w245
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w248
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w252
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w1
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w4
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w7
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w10
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w13
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w16
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w19
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w22
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w25
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w28
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w31
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w34
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w37
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w40
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w43
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w46
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w49
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w52
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w55
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w58
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w61
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w64
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w67
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w70
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w73
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w76
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w79
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w82
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w85
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w88
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w91
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w94
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w97
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w100
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w103
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w106
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w109
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w112
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w115
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w118
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w121
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w124
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w127
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w130
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w133
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w136
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w139
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w142
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w145
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w148
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w151
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w154
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w157
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 38 \w0
+.if \n(83<\n(38 .nr 83 \n(38
+.83
+.rm 83
+.nr 38 6n
+.if \n(83<\n(38 .nr 83 \n(38
+.nr 84 0
+.nr 38 \wadf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wadp
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wads
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wasp
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wbge
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wblm
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wbra
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcal
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcif
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcmi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcsa
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdee
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdvf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \winc
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \winl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wior
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlae
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlal
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlal
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlde
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wldl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlil
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlin
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wloc
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wloc
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wloe
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlof
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wloi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlol
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlol
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlxl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wrck
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wrmi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsbi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsil
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wste
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wstf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsti
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wstl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wstl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wtlt
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzeq
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzgt
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzne
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzre
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzrl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wadf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wadi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wadu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wand
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wass
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wble
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wbls
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcai
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcfu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcmf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcms
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcmu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcsa
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcsb
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wcuu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdel
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdus
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdvi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wdvu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wfif
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \winl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wior
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlar
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wldl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlil
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlos
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlpi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wmlf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wmli
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wmon
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wngi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wrck
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wrmi
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wrmu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wror
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsar
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsbf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsbs
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsbu
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsdl
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wset
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsil
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsli
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsri
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsru
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wsts
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wtle
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wxor
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzge
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzlt
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wzrf
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wexg
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 38 \wlpb
+.if \n(84<\n(38 .nr 84 \n(38
+.84
+.rm 84
+.nr 38 6n
+.if \n(84<\n(38 .nr 84 \n(38
+.nr 85 0
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsw
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsw
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wm
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \ww2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsw
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wwN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \ww2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wmwPo
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wwN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wswN
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \w-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wsw
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wwN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewP2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewP2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewP2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wewN2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we2
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \wesP
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 38 \we-
+.if \n(85<\n(38 .nr 85 \n(38
+.85
+.rm 85
+.nr 38 8n
+.if \n(85<\n(38 .nr 85 \n(38
+.nr 86 0
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w28
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w3
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w7
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w5
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w4
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w4
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w2
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 38 \w1
+.if \n(86<\n(38 .nr 86 \n(38
+.86
+.rm 86
+.nr 38 3n
+.if \n(86<\n(38 .nr 86 \n(38
+.nr 87 0
+.nr 38 \w35
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w39
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w43
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w50
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w53
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w56
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w59
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w64
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w94
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w97
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w101
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w104
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w107
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w110
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w113
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w118
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w121
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w130
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w133
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w137
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w140
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w144
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w148
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w151
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w153
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w156
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w166
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w169
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w175
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w188
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w191
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w196
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w200
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w203
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w207
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w210
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w215
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w219
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w225
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w233
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w236
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w239
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w243
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w246
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w249
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w253
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w2
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w5
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w8
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w11
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w14
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w17
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w20
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w23
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w26
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w29
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w32
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w35
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w38
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w41
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w44
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w47
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w50
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w53
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w56
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w59
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w62
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w65
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w68
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w71
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w74
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w77
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w80
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w83
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w86
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w89
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w92
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w95
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w98
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w101
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w104
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w107
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w110
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w113
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w116
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w119
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w122
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w125
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w128
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w131
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w134
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w137
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w140
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w143
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w146
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w149
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w152
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w155
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 38 \w158
+.if \n(87<\n(38 .nr 87 \n(38
+.87
+.rm 87
+.nr 38 6n
+.if \n(87<\n(38 .nr 87 \n(38
+.nr 88 0
+.nr 38 \wadi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wadp
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wand
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wbeq
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wbgt
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wblt
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wbra
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcal
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcii
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcmp
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcsb
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdel
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdvi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wine
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \winl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wior
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlal
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlal
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlar
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlde
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlfr
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlil
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlin
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wloc
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wloc
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlof
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wloi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wloi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlol
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlol
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wmlf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wret
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsar
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsdl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsil
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wste
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wstf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsti
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wstl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wteq
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wtne
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzer
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzle
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzne
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzrl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \waar
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wadf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wads
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wadu
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wasp
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wbge
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wblm
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wblt
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcal
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wciu
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcmi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcms
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcom
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcsa
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wcuf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdee
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdup
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdvf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wdvi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wfef
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wfif
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \winn
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wior
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wldc
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wldl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlil
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlos
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wlxa
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wmlf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wmlu
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wngf
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wngi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wrck
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wrmi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wrol
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wror
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsar
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsbi
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsbs
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsde
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsdl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsig
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsim
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wslu
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsri
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wsti
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wstr
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wtrp
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzer
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzgt
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzne
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wzrl
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wexg
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 38 \wgto
+.if \n(88<\n(38 .nr 88 \n(38
+.88
+.rm 88
+.nr 38 6n
+.if \n(88<\n(38 .nr 88 \n(38
+.nr 89 0
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \ww2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wP2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsw
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwPo
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wswP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsw
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \w-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wsN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wmwN
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wew2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wew2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wewN2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wewN2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wewN2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wesP
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we-
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \wewP2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 38 \we2
+.if \n(89<\n(38 .nr 89 \n(38
+.89
+.rm 89
+.nr 38 8n
+.if \n(89<\n(38 .nr 89 \n(38
+.nr 90 0
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w34
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w4
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w3
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w2
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 38 \w1
+.if \n(90<\n(38 .nr 90 \n(38
+.90
+.rm 90
+.nr 38 3n
+.if \n(90<\n(38 .nr 90 \n(38
+.nr 91 0
+.nr 38 \w36
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w41
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w44
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w51
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w54
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w57
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w60
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w92
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w95
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w99
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w102
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w105
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w108
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w111
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w116
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w119
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w128
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w131
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w135
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w138
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w141
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w145
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w149
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w0
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w154
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w161
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w167
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w173
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w176
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w189
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w193
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w197
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w201
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w205
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w208
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w211
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w217
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w223
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w226
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w234
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w237
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w241
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w244
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w247
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w250
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w0
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w3
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w6
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w9
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w12
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w15
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w18
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w21
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w24
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w27
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w30
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w33
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w36
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w39
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w42
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w45
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w48
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w51
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w54
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w57
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w60
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w63
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w66
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w69
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w72
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w75
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w78
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w81
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w84
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w87
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w90
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w93
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w96
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w99
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w102
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w105
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w108
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w111
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w114
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w117
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w120
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w123
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w126
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w129
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w132
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w135
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w138
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w141
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w144
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w147
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w150
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w153
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w156
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 \w159
+.if \n(91<\n(38 .nr 91 \n(38
+.91
+.rm 91
+.nr 38 6n
+.if \n(91<\n(38 .nr 91 \n(38
+.nr 38 1n
+.nr 79 0
+.nr 40 \n(79+(0*\n(38)
+.nr 80 +\n(40
+.nr 41 \n(80+(3*\n(38)
+.nr 81 +\n(41
+.nr 42 \n(81+(3*\n(38)
+.nr 82 +\n(42
+.nr 43 \n(82+(3*\n(38)
+.nr 83 +\n(43
+.nr 44 \n(83+(14*\n(38)
+.nr 84 +\n(44
+.nr 45 \n(84+(3*\n(38)
+.nr 85 +\n(45
+.nr 46 \n(85+(3*\n(38)
+.nr 86 +\n(46
+.nr 47 \n(86+(3*\n(38)
+.nr 87 +\n(47
+.nr 48 \n(87+(14*\n(38)
+.nr 88 +\n(48
+.nr 49 \n(88+(3*\n(38)
+.nr 89 +\n(49
+.nr 50 \n(89+(3*\n(38)
+.nr 90 +\n(50
+.nr 51 \n(90+(3*\n(38)
+.nr 91 +\n(51
+.nr TW \n(91
+.if t .if (\n(TW+\n(.o)>7.65i .tm Table at line 103 file Input is too wide - \n(TW units
+.fc  
+.nr #T 0-1
+.nr #a 0-1
+.eo
+.de T#
+.ds #d .d
+.if \(ts\n(.z\(ts\(ts .ds #d nl
+.mk ##
+.nr ## -1v
+.ls 1
+.ls
+..
+.ec
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'aar\h'|\n(41u'mwPo\h'|\n(42u'1\h'|\n(43u'34\h'|\n(44u'adf\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'35\h'|\n(48u'adi\h'|\n(49u'mwPo\h'|\n(50u'2\h'|\n(51u'36
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'adp\h'|\n(41u'2\h'|\n(42u'\h'|\n(43u'38\h'|\n(44u'adp\h'|\n(45u'mPo\h'|\n(46u'2\h'|\n(47u'39\h'|\n(48u'adp\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'41
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'adp\h'|\n(41u'sN\h'|\n(42u'1\h'|\n(43u'42\h'|\n(44u'ads\h'|\n(45u'mwPo\h'|\n(46u'1\h'|\n(47u'43\h'|\n(48u'and\h'|\n(49u'mwPo\h'|\n(50u'1\h'|\n(51u'44
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'asp\h'|\n(41u'mwPo\h'|\n(42u'5\h'|\n(43u'45\h'|\n(44u'asp\h'|\n(45u'swP\h'|\n(46u'1\h'|\n(47u'50\h'|\n(48u'beq\h'|\n(49u'2\h'|\n(50u'\h'|\n(51u'51
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'beq\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'52\h'|\n(44u'bge\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'53\h'|\n(48u'bgt\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'54
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ble\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'55\h'|\n(44u'blm\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'56\h'|\n(48u'blt\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'57
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'bne\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'58\h'|\n(44u'bra\h'|\n(45u'2\h'|\n(46u'\h'|\n(47u'59\h'|\n(48u'bra\h'|\n(49u'sN\h'|\n(50u'2\h'|\n(51u'60
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'bra\h'|\n(41u'sP\h'|\n(42u'2\h'|\n(43u'62\h'|\n(44u'cal\h'|\n(45u'mPo\h'|\n(46u'28\h'|\n(47u'64\h'|\n(48u'cal\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'92
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cff\h'|\n(41u'-\h'|\n(42u'\h'|\n(43u'93\h'|\n(44u'cif\h'|\n(45u'-\h'|\n(46u'\h'|\n(47u'94\h'|\n(48u'cii\h'|\n(49u'-\h'|\n(50u'\h'|\n(51u'95
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cmf\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'96\h'|\n(44u'cmi\h'|\n(45u'mwPo\h'|\n(46u'2\h'|\n(47u'97\h'|\n(48u'cmp\h'|\n(49u'-\h'|\n(50u'\h'|\n(51u'99
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cms\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'100\h'|\n(44u'csa\h'|\n(45u'mwPo\h'|\n(46u'1\h'|\n(47u'101\h'|\n(48u'csb\h'|\n(49u'mwPo\h'|\n(50u'1\h'|\n(51u'102
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dec\h'|\n(41u'-\h'|\n(42u'\h'|\n(43u'103\h'|\n(44u'dee\h'|\n(45u'sw\h'|\n(46u'1\h'|\n(47u'104\h'|\n(48u'del\h'|\n(49u'swN\h'|\n(50u'1\h'|\n(51u'105
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dup\h'|\n(41u'mwPo\h'|\n(42u'1\h'|\n(43u'106\h'|\n(44u'dvf\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'107\h'|\n(48u'dvi\h'|\n(49u'mwPo\h'|\n(50u'1\h'|\n(51u'108
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'fil\h'|\n(41u'2\h'|\n(42u'\h'|\n(43u'109\h'|\n(44u'inc\h'|\n(45u'-\h'|\n(46u'\h'|\n(47u'110\h'|\n(48u'ine\h'|\n(49u'w2\h'|\n(50u'\h'|\n(51u'111
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ine\h'|\n(41u'sw\h'|\n(42u'1\h'|\n(43u'112\h'|\n(44u'inl\h'|\n(45u'mwN\h'|\n(46u'3\h'|\n(47u'113\h'|\n(48u'inl\h'|\n(49u'swN\h'|\n(50u'1\h'|\n(51u'116
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'inn\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'117\h'|\n(44u'ior\h'|\n(45u'mwPo\h'|\n(46u'1\h'|\n(47u'118\h'|\n(48u'ior\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'119
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lae\h'|\n(41u'2\h'|\n(42u'\h'|\n(43u'120\h'|\n(44u'lae\h'|\n(45u'sw\h'|\n(46u'7\h'|\n(47u'121\h'|\n(48u'lal\h'|\n(49u'P2\h'|\n(50u'\h'|\n(51u'128
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lal\h'|\n(41u'N2\h'|\n(42u'\h'|\n(43u'129\h'|\n(44u'lal\h'|\n(45u'm\h'|\n(46u'1\h'|\n(47u'130\h'|\n(48u'lal\h'|\n(49u'mN\h'|\n(50u'1\h'|\n(51u'131
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lal\h'|\n(41u'swP\h'|\n(42u'1\h'|\n(43u'132\h'|\n(44u'lal\h'|\n(45u'swN\h'|\n(46u'2\h'|\n(47u'133\h'|\n(48u'lar\h'|\n(49u'mwPo\h'|\n(50u'1\h'|\n(51u'135
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ldc\h'|\n(41u'mP\h'|\n(42u'1\h'|\n(43u'136\h'|\n(44u'lde\h'|\n(45u'w2\h'|\n(46u'\h'|\n(47u'137\h'|\n(48u'lde\h'|\n(49u'sw\h'|\n(50u'1\h'|\n(51u'138
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ldl\h'|\n(41u'mP\h'|\n(42u'1\h'|\n(43u'139\h'|\n(44u'ldl\h'|\n(45u'swN\h'|\n(46u'1\h'|\n(47u'140\h'|\n(48u'lfr\h'|\n(49u'mwPo\h'|\n(50u'2\h'|\n(51u'141
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lfr\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'143\h'|\n(44u'lil\h'|\n(45u'swN\h'|\n(46u'1\h'|\n(47u'144\h'|\n(48u'lil\h'|\n(49u'swP\h'|\n(50u'1\h'|\n(51u'145
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lil\h'|\n(41u'mwP\h'|\n(42u'2\h'|\n(43u'146\h'|\n(44u'lin\h'|\n(45u'2\h'|\n(46u'\h'|\n(47u'148\h'|\n(48u'lin\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'149
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lni\h'|\n(41u'-\h'|\n(42u'\h'|\n(43u'150\h'|\n(44u'loc\h'|\n(45u'2\h'|\n(46u'\h'|\n(47u'151\h'|\n(48u'loc\h'|\n(49u'mP\h'|\n(50u'34\h'|\n(51u'0
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'loc\h'|\n(41u'mN\h'|\n(42u'1\h'|\n(43u'152\h'|\n(44u'loc\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'153\h'|\n(48u'loc\h'|\n(49u'sN\h'|\n(50u'1\h'|\n(51u'154
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'loe\h'|\n(41u'w2\h'|\n(42u'\h'|\n(43u'155\h'|\n(44u'loe\h'|\n(45u'sw\h'|\n(46u'5\h'|\n(47u'156\h'|\n(48u'lof\h'|\n(49u'2\h'|\n(50u'\h'|\n(51u'161
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lof\h'|\n(41u'mwPo\h'|\n(42u'4\h'|\n(43u'162\h'|\n(44u'lof\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'166\h'|\n(48u'loi\h'|\n(49u'2\h'|\n(50u'\h'|\n(51u'167
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'loi\h'|\n(41u'mPo\h'|\n(42u'1\h'|\n(43u'168\h'|\n(44u'loi\h'|\n(45u'mwPo\h'|\n(46u'4\h'|\n(47u'169\h'|\n(48u'loi\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'173
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lol\h'|\n(41u'wP2\h'|\n(42u'\h'|\n(43u'174\h'|\n(44u'lol\h'|\n(45u'wN2\h'|\n(46u'\h'|\n(47u'175\h'|\n(48u'lol\h'|\n(49u'mwP\h'|\n(50u'4\h'|\n(51u'176
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lol\h'|\n(41u'mwN\h'|\n(42u'8\h'|\n(43u'180\h'|\n(44u'lol\h'|\n(45u'swP\h'|\n(46u'1\h'|\n(47u'188\h'|\n(48u'lol\h'|\n(49u'swN\h'|\n(50u'1\h'|\n(51u'189
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lxa\h'|\n(41u'mPo\h'|\n(42u'1\h'|\n(43u'190\h'|\n(44u'lxl\h'|\n(45u'mPo\h'|\n(46u'2\h'|\n(47u'191\h'|\n(48u'mlf\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'193
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'mli\h'|\n(41u'mwPo\h'|\n(42u'2\h'|\n(43u'194\h'|\n(44u'rck\h'|\n(45u'mwPo\h'|\n(46u'1\h'|\n(47u'196\h'|\n(48u'ret\h'|\n(49u'mwP\h'|\n(50u'2\h'|\n(51u'197
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ret\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'199\h'|\n(44u'rmi\h'|\n(45u'mwPo\h'|\n(46u'1\h'|\n(47u'200\h'|\n(48u'sar\h'|\n(49u'mwPo\h'|\n(50u'1\h'|\n(51u'201
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sbf\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'202\h'|\n(44u'sbi\h'|\n(45u'mwPo\h'|\n(46u'2\h'|\n(47u'203\h'|\n(48u'sdl\h'|\n(49u'swN\h'|\n(50u'1\h'|\n(51u'205
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'set\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'206\h'|\n(44u'sil\h'|\n(45u'swN\h'|\n(46u'1\h'|\n(47u'207\h'|\n(48u'sil\h'|\n(49u'swP\h'|\n(50u'1\h'|\n(51u'208
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sli\h'|\n(41u'mwPo\h'|\n(42u'1\h'|\n(43u'209\h'|\n(44u'ste\h'|\n(45u'w2\h'|\n(46u'\h'|\n(47u'210\h'|\n(48u'ste\h'|\n(49u'sw\h'|\n(50u'3\h'|\n(51u'211
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'stf\h'|\n(41u'2\h'|\n(42u'\h'|\n(43u'214\h'|\n(44u'stf\h'|\n(45u'mwPo\h'|\n(46u'2\h'|\n(47u'215\h'|\n(48u'stf\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'217
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sti\h'|\n(41u'mPo\h'|\n(42u'1\h'|\n(43u'218\h'|\n(44u'sti\h'|\n(45u'mwPo\h'|\n(46u'4\h'|\n(47u'219\h'|\n(48u'sti\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'223
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'stl\h'|\n(41u'wP2\h'|\n(42u'\h'|\n(43u'224\h'|\n(44u'stl\h'|\n(45u'wN2\h'|\n(46u'\h'|\n(47u'225\h'|\n(48u'stl\h'|\n(49u'mwP\h'|\n(50u'2\h'|\n(51u'226
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'stl\h'|\n(41u'mwN\h'|\n(42u'5\h'|\n(43u'228\h'|\n(44u'stl\h'|\n(45u'swN\h'|\n(46u'1\h'|\n(47u'233\h'|\n(48u'teq\h'|\n(49u'-\h'|\n(50u'\h'|\n(51u'234
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'tgt\h'|\n(41u'-\h'|\n(42u'\h'|\n(43u'235\h'|\n(44u'tlt\h'|\n(45u'-\h'|\n(46u'\h'|\n(47u'236\h'|\n(48u'tne\h'|\n(49u'-\h'|\n(50u'\h'|\n(51u'237
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zeq\h'|\n(41u'2\h'|\n(42u'\h'|\n(43u'238\h'|\n(44u'zeq\h'|\n(45u'sP\h'|\n(46u'2\h'|\n(47u'239\h'|\n(48u'zer\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'241
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zge\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'242\h'|\n(44u'zgt\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'243\h'|\n(48u'zle\h'|\n(49u'sP\h'|\n(50u'1\h'|\n(51u'244
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zlt\h'|\n(41u'sP\h'|\n(42u'1\h'|\n(43u'245\h'|\n(44u'zne\h'|\n(45u'sP\h'|\n(46u'1\h'|\n(47u'246\h'|\n(48u'zne\h'|\n(49u'sN\h'|\n(50u'1\h'|\n(51u'247
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zre\h'|\n(41u'w2\h'|\n(42u'\h'|\n(43u'248\h'|\n(44u'zre\h'|\n(45u'sw\h'|\n(46u'1\h'|\n(47u'249\h'|\n(48u'zrl\h'|\n(49u'mwN\h'|\n(50u'2\h'|\n(51u'250
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zrl\h'|\n(41u'swN\h'|\n(42u'1\h'|\n(43u'252\h'|\n(44u'zrl\h'|\n(45u'wN2\h'|\n(46u'\h'|\n(47u'253\h'|\n(48u'aar\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'0
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'aar\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'1\h'|\n(44u'adf\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'2\h'|\n(48u'adf\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'3
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'adi\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'4\h'|\n(44u'adi\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'5\h'|\n(48u'ads\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'6
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ads\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'7\h'|\n(44u'adu\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'8\h'|\n(48u'adu\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'9
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'and\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'10\h'|\n(44u'and\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'11\h'|\n(48u'asp\h'|\n(49u'ew2\h'|\n(50u'\h'|\n(51u'12
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ass\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'13\h'|\n(44u'ass\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'14\h'|\n(48u'bge\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'15
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'bgt\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'16\h'|\n(44u'ble\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'17\h'|\n(48u'blm\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'18
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'bls\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'19\h'|\n(44u'bls\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'20\h'|\n(48u'blt\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'21
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'bne\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'22\h'|\n(44u'cai\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'23\h'|\n(48u'cal\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'24
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cfi\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'25\h'|\n(44u'cfu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'26\h'|\n(48u'ciu\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'27
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cmf\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'28\h'|\n(44u'cmf\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'29\h'|\n(48u'cmi\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'30
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cmi\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'31\h'|\n(44u'cms\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'32\h'|\n(48u'cms\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'33
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cmu\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'34\h'|\n(44u'cmu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'35\h'|\n(48u'com\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'36
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'com\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'37\h'|\n(44u'csa\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'38\h'|\n(48u'csa\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'39
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'csb\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'40\h'|\n(44u'csb\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'41\h'|\n(48u'cuf\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'42
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'cui\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'43\h'|\n(44u'cuu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'44\h'|\n(48u'dee\h'|\n(49u'ew2\h'|\n(50u'\h'|\n(51u'45
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'del\h'|\n(41u'ewP2\h'|\n(42u'\h'|\n(43u'46\h'|\n(44u'del\h'|\n(45u'ewN2\h'|\n(46u'\h'|\n(47u'47\h'|\n(48u'dup\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'48
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dus\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'49\h'|\n(44u'dus\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'50\h'|\n(48u'dvf\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'51
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dvf\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'52\h'|\n(44u'dvi\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'53\h'|\n(48u'dvi\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'54
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dvu\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'55\h'|\n(44u'dvu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'56\h'|\n(48u'fef\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'57
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'fef\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'58\h'|\n(44u'fif\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'59\h'|\n(48u'fif\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'60
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'inl\h'|\n(41u'ewP2\h'|\n(42u'\h'|\n(43u'61\h'|\n(44u'inl\h'|\n(45u'ewN2\h'|\n(46u'\h'|\n(47u'62\h'|\n(48u'inn\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'63
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'inn\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'64\h'|\n(44u'ior\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'65\h'|\n(48u'ior\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'66
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lar\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'67\h'|\n(44u'lar\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'68\h'|\n(48u'ldc\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'69
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ldf\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'70\h'|\n(44u'ldl\h'|\n(45u'ewP2\h'|\n(46u'\h'|\n(47u'71\h'|\n(48u'ldl\h'|\n(49u'ewN2\h'|\n(50u'\h'|\n(51u'72
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lfr\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'73\h'|\n(44u'lil\h'|\n(45u'ewP2\h'|\n(46u'\h'|\n(47u'74\h'|\n(48u'lil\h'|\n(49u'ewN2\h'|\n(50u'\h'|\n(51u'75
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lim\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'76\h'|\n(44u'los\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'77\h'|\n(48u'los\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'78
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lor\h'|\n(41u'esP\h'|\n(42u'1\h'|\n(43u'79\h'|\n(44u'lpi\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'80\h'|\n(48u'lxa\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'81
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'lxl\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'82\h'|\n(44u'mlf\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'83\h'|\n(48u'mlf\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'84
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'mli\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'85\h'|\n(44u'mli\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'86\h'|\n(48u'mlu\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'87
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'mlu\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'88\h'|\n(44u'mon\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'89\h'|\n(48u'ngf\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'90
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ngf\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'91\h'|\n(44u'ngi\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'92\h'|\n(48u'ngi\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'93
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'nop\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'94\h'|\n(44u'rck\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'95\h'|\n(48u'rck\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'96
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ret\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'97\h'|\n(44u'rmi\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'98\h'|\n(48u'rmi\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'99
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'rmu\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'100\h'|\n(44u'rmu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'101\h'|\n(48u'rol\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'102
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'rol\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'103\h'|\n(44u'ror\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'104\h'|\n(48u'ror\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'105
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'rtt\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'106\h'|\n(44u'sar\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'107\h'|\n(48u'sar\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'108
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sbf\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'109\h'|\n(44u'sbf\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'110\h'|\n(48u'sbi\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'111
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sbi\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'112\h'|\n(44u'sbs\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'113\h'|\n(48u'sbs\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'114
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sbu\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'115\h'|\n(44u'sbu\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'116\h'|\n(48u'sde\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'117
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sdf\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'118\h'|\n(44u'sdl\h'|\n(45u'ewP2\h'|\n(46u'\h'|\n(47u'119\h'|\n(48u'sdl\h'|\n(49u'ewN2\h'|\n(50u'\h'|\n(51u'120
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'set\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'121\h'|\n(44u'set\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'122\h'|\n(48u'sig\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'123
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sil\h'|\n(41u'ewP2\h'|\n(42u'\h'|\n(43u'124\h'|\n(44u'sil\h'|\n(45u'ewN2\h'|\n(46u'\h'|\n(47u'125\h'|\n(48u'sim\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'126
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sli\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'127\h'|\n(44u'sli\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'128\h'|\n(48u'slu\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'129
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'slu\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'130\h'|\n(44u'sri\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'131\h'|\n(48u'sri\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'132
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sru\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'133\h'|\n(44u'sru\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'134\h'|\n(48u'sti\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'135
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'sts\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'136\h'|\n(44u'sts\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'137\h'|\n(48u'str\h'|\n(49u'esP\h'|\n(50u'1\h'|\n(51u'138
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'tge\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'139\h'|\n(44u'tle\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'140\h'|\n(48u'trp\h'|\n(49u'e-\h'|\n(50u'\h'|\n(51u'141
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'xor\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'142\h'|\n(44u'xor\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'143\h'|\n(48u'zer\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'144
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zer\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'145\h'|\n(44u'zge\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'146\h'|\n(48u'zgt\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'147
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zle\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'148\h'|\n(44u'zlt\h'|\n(45u'e2\h'|\n(46u'\h'|\n(47u'149\h'|\n(48u'zne\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'150
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'zrf\h'|\n(41u'e2\h'|\n(42u'\h'|\n(43u'151\h'|\n(44u'zrf\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'152\h'|\n(48u'zrl\h'|\n(49u'ewP2\h'|\n(50u'\h'|\n(51u'153
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'dch\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'154\h'|\n(44u'exg\h'|\n(45u'esP\h'|\n(46u'1\h'|\n(47u'155\h'|\n(48u'exg\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'156
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'exg\h'|\n(41u'e-\h'|\n(42u'\h'|\n(43u'157\h'|\n(44u'lpb\h'|\n(45u'e-\h'|\n(46u'\h'|\n(47u'158\h'|\n(48u'gto\h'|\n(49u'e2\h'|\n(50u'\h'|\n(51u'159
+.ta \n(80u \n(81u \n(82u \n(83u \n(84u \n(85u \n(86u \n(87u \n(88u \n(89u \n(90u \n(91u 
+.nr 31 \n(.f
+.nr 35 1m
+\&\h'|\n(40u'ldc\h'|\n(41u'4\h'|\n(42u'\h'|\n(43u'0\h'|\n(44u'\h'|\n(45u'\h'|\n(46u'\h'|\n(47u'\h'|\n(48u'\h'|\n(49u'\h'|\n(50u'\h'|\n(51u'
+.fc
+.nr T. 1
+.T# 1
+.35
+.TE
+.if \n-(b.=0 .nr c. \n(.c-\n(d.-102

+ 390 - 0
doc/em/mach.nr

@@ -0,0 +1,390 @@
+.BP
+.SN 10
+.S1 "EM MACHINE LANGUAGE"
+The EM machine language is designed to make program text compact
+and to make decoding easy.
+Compact program text has many advantages: programs execute faster,
+programs occupy less primary and secondary storage and loading
+programs into satellite processors is faster.
+The decoding of EM machine language is so simple,
+that it is feasible to use interpreters as long as EM hardware
+machines are not available.
+This chapter is irrelevant when back ends are used to
+produce executable target machine code.
+.S2 "Instruction encoding"
+A design goal of EM is to make the
+program text as compact as possible.
+Decoding must be easy, however.
+The encoding is fully byte oriented, without any small bit fields.
+There are 256 primary opcodes, two of which are an escape to
+two groups of 256 secondary opcodes each.
+.A
+EM instructions without arguments have a single opcode assigned,
+possibly escaped:
+.DS
+
+         |--------------|
+         |    opcode    |
+         |--------------|
+
+                or
+
+         |--------------|--------------|
+         |    escape    |     opcode   |
+         |--------------|--------------|
+
+.DE
+The encoding for instructions with an argument is more complex.
+Several instructions have an address from the global data area
+as argument.
+Other instructions have different opcodes for positive
+and negative arguments.
+.N 1
+There is always an opcode that takes the next two bytes as argument,
+high byte first:
+.DS
+
+         |--------------|--------------|--------------|
+         |    opcode    |    hibyte    |    lobyte    |
+         |--------------|--------------|--------------|
+
+                or
+
+         |--------------|--------------|--------------|--------------|
+         |    escape    |    opcode    |    hibyte    |    lobyte    |
+         |--------------|--------------|--------------|--------------|
+
+.DE
+.DS
+An extra escape is provided for instructions with four or eight byte arguments.
+
+  |--------------|--------------|--------------|   |--------------|
+  |    ESCAPE    |    opcode    |    hibyte    |...|    lobyte    |
+  |--------------|--------------|--------------|   |--------------|
+
+.DE
+For most instructions some argument values predominate.
+The most frequent combinations of instruction and argument
+will be encoded in a single byte, called a mini:
+.DS
+
+         |---------------|
+         |opcode+argument|  (mini)
+         |---------------|
+
+.DE
+The number of minis is restricted, because only
+254 primary opcodes are available.
+Many instructions have the bulk of their arguments
+fall in the range 0 to 255.
+Instructions that address global data have their arguments
+distributed over a wider range,
+but small values of the high byte are common.
+For all these cases there is another encoding
+that combines the instruction and the high byte of the argument
+into a single opcode.
+These opcodes are called shorties.
+Shorties may be escaped.
+.DS
+
+         |--------------|--------------|
+         | opcode+high  |    lobyte    |  (shortie)
+         |--------------|--------------|
+
+                or
+
+         |--------------|--------------|--------------|
+         |    escape    | opcode+high  |    lobyte    |
+         |--------------|--------------|--------------|
+
+.DE
+Escaped shorties are useless if the normal encoding has a primary opcode.
+Note that for some instruction-argument combinations
+several different encodings are available.
+It is the task of the assembler to select the shortest of these.
+The savings by these mini and shortie
+opcodes are considerable, about 55%.
+.P
+Further improvements are possible:
+the arguments of
+many instructions are a multiple of the wordsize.
+Some do also not allow zero as an argument.
+If these arguments are divided by the wordsize and,
+when zero is not allowed, then decremented by 1, more of them can
+be encoded as shortie or mini.
+The arguments of some other instructions
+rarely or never assume the value 0, but start at 1.
+The value 1 is then encoded as 0,
+2 as 1 and so on.
+.P
+Assigning opcodes to instructions by the assembler is completely
+table driven.
+For details see appendix B.
+.S2 "Procedure descriptors"
+The procedure identifiers used in the interpreter are indices
+into a table of procedure descriptors.
+Each descriptor contains:
+.IS 6
+.PS - 4
+.PT 1.
+the number of bytes to be reserved for locals at each
+invocation.
+.N
+This is a pointer-szied integer.
+.PT 2.
+the start address of the procedure
+.PE
+.IE
+.S2 "Load format"
+The EM machine language load format defines the interface between
+the EM assembler/loader and the EM machine itself.
+A load file consists of a header, the program text to be executed,
+a description of the global data area and the procedure descriptor table,
+in this order.
+All integers in the load file are presented with the
+least significant byte first.
+.P
+The header has two parts: the first half (eight 16-bit integers)
+aids in selecting
+the correct EM machine or interpreter.
+Some EM machines, for instance, may have hardware floating point
+instructions.
+.N
+The header entries are as follows (bit 0 is rightmost):
+.IS 2
+.VS 1 0
+.PS 1 4 "" :
+.PT
+magic number (07255)
+.PT
+flag bits with the following meaning:
+.PS - 7 "" :
+.PT bit 0
+TEST; test for integer overflow etc.
+.PT bit 1
+PROFILE; for each source line: count the number of memory
+cycles executed.
+.PT bit 2
+FLOW; for each source line: set a bit in a bit map table if
+instructions on that line are executed.
+.PT bit 3
+COUNT; for each source line: increment a counter if that line
+is entered.
+.PT bit 4
+REALS; set if a program uses floating point instructions.
+.PT bit 5
+EXTRA; more tests during compiler debugging.
+.PE
+.PT
+number of unresolved references.
+.PT
+version number; used to detect obsolete EM load files.
+.PT
+wordsize ; the number of bytes in each machine word.
+.PT
+pointer size ; the number of bytes available for addressing.
+.PT
+unused
+.PT
+unused
+.PE
+.IE
+The second part of the header (eight entries, of pointer size bytes each)
+describes the load file itself:
+.IS 2
+.PS 1 4 "" :
+.PT
+NTEXT; the program text size in bytes.
+.PT
+NDATA; the number of load-file descriptors (see below).
+.PT
+NPROC; the number of entries in the procedure descriptor table.
+.PT
+ENTRY; procedure number of the procedure to start with.
+.PT
+NLINE; the maximum source line number.
+.PT
+SZDATA; the address of the lowest uninitialized data byte.
+.PT
+unused
+.PT
+unused
+.PE
+.IE
+.P
+The program text consists of NTEXT bytes.
+NTEXT is always a multiple of the wordsize.
+The first byte of the program text is the
+first byte of the instruction address
+space, i.e. it has address 0.
+Pointers into the program text are found in the procedure descriptor
+table where relocation is simple and in the global data area.
+The initialization of the global data area allows easy
+relocation of pointers into both address spaces.
+.P
+The global data area is described by the NDATA descriptors.
+Each descriptor describes a number of consecutive words (of~wordsize)
+and consists of a sequence of bytes.
+While reading the descriptors from the load file, one can
+initialize the global data area from low to high addresses.
+The size of the initialized data area is given by SZDATA,
+this number can be used to check the initialization.
+.N
+The header of each descriptor consists of a byte, describing the type,
+and a count.
+The number of bytes used for this (unsigned) count depends on the
+type of the descriptor and
+is either a pointer-sized integer
+or one byte.
+The meaning of the count depends on the descriptor type.
+At load time an interpreter can
+perform any conversion deemed necessary, such as
+reordering bytes in integers
+and pointers and adding base addresses to pointers.
+.BP
+.A
+In the following pictures we show a graphical notation of the
+initializers.
+The leftmost rectangle represents the leading byte.
+.N 1
+.DS
+.PS - 4 " "
+Fields marked with
+.N 1
+.PT n
+contain a pointer-sized integer used as a count
+.PT m
+contain a one-byte integer used as a count
+.PT b
+contain a one-byte integer
+.PT w
+contain a wordsized integer
+.PT p
+contain a data or instruction pointer
+.PT s
+contain a null terminated ASCII string
+.PE 1
+.DE 0
+.VS 1 1
+.DS
+
+    -------------------
+    | 0 |      n      |           repeat last initialization n times
+    -------------------
+.DE
+.DS
+    ---------
+    | 1 | m |                     m uninitialized words
+    ---------
+.DE
+.DS
+               ____________
+              /    bytes   \e
+    -----------------   -----
+    | 2 | m | b | b |...| b |     m initialized bytes
+    -----------------   -----
+.DE
+.DS
+               _________
+              /  word   \e
+    -----------------------
+    | 3 | m |      w      |...    m initialized wordsized integers
+    -----------------------
+.DE
+.DS
+               _________
+              / pointer \e
+    -----------------------
+    | 4 | m |      p      |...    m initialized data pointers
+    -----------------------
+.DE
+.DS
+               _________
+              / pointer \e
+    -----------------------
+    | 5 | m |      p      |...    m initialized instruction pointers
+    -----------------------
+.DE
+.DS
+               ____________
+              /    bytes   \e
+    -------------------------
+    | 6 | m | b | b |...| b |     initialized integer of size m
+    -------------------------
+.DE
+.DS
+               ____________
+              /    bytes   \e
+    -------------------------
+    | 7 | m | b | b |...| b |     initialized unsigned of size m
+    -------------------------
+.DE
+.DS
+               ____________
+              /   string   \e
+    -------------------------
+    | 8 | m |        s      |     initialized float of size m
+    -------------------------
+.DE 3
+.PS - 8
+.PT type~0:
+If the last initialization initialized k bytes starting
+at address \fIa\fP, do the same initialization again n times,
+starting at \fIa\fP+k, \fIa\fP+2*k, .... \fIa\fP+n*k.
+This is the only descriptor whose starting byte
+is followed by an integer with the
+size of a
+pointer,
+in all other descriptors the first byte is followed by a one-byte count.
+This descriptor must be preceded by a descriptor of
+another type.
+.PT type~1:
+Reserve m words, not explicitly initialized (BSS and HOL).
+.PT type~2:
+The m bytes following the descriptor header are
+initializers for the next m bytes of the
+global data area.
+m is divisible by the wordsize.
+.PT type~3:
+The m words following the header are initializers for the next m words of the
+global data area.
+.PT type~4:
+The m data address space pointers following the header are
+initializers for the next
+m data pointers in the global data area.
+Interpreters that represent EM pointers by
+target machine addresses must relocate all data pointers.
+.PT type~5:
+The m instruction address space pointers following the header are
+initializers for the next
+m instruction pointers in the global data area.
+Interpreters that represent EM instruction pointers by
+target machine addresses must relocate these pointers.
+.PT type~6:
+The m bytes following the header form
+a signed integer number with a size of m bytes,
+which is an initializer for the next m bytes
+of the global data area.
+m is governed by the same restrictions as for
+transfer of objects to/from memory.
+.PT type~7:
+The m bytes following the header form
+an unsigned integer number with a size of m bytes,
+which is an initializer for the next m bytes
+of the global data area.
+m is governed by the same restrictions as for
+transfer of objects to/from memory.
+.PT type~8:
+The header is followed by an ASCII string, null terminated, to
+initialize, in global data,
+a floating point number with a size of m bytes.
+m is governed by the same restrictions as for
+transfer of objects to/from memory.
+The ASCII string contains the notation of a real as used in the
+Pascal language.
+.PE
+.P
+The NPROC procedure descriptors on the load file consist of
+an instruction space address (of~pointer~size) and
+an integer (of~pointer~size) specifying the number of bytes for
+locals.

+ 16 - 0
doc/em/macr.nr

@@ -0,0 +1,16 @@
+.so /usr/lib/tmac/tmac.kun
+.SS 6
+.RP
+.PL 12i 11i
+.LL 89
+.MS T E
+\!.TL '%'''
+.ME
+.MS T O
+\!.TL '''%'
+.ME
+.MS B
+.sp 1
+.ME
+.SM S1 B
+.SM S2 B

+ 245 - 0
doc/em/mapping.nr

@@ -0,0 +1,245 @@
+.SN 5
+.BP
+.S1 "MAPPING OF EM DATA MEMORY ONTO TARGET MACHINE MEMORY"
+The EM architecture is designed to be implemented
+on many existing and future machines.
+EM memory is highly fragmented to make
+adaptation to various memory architectures possible.
+Format and encoding of pointers is explicitly undefined.
+.P
+This chapter gives solutions to some of the
+anticipated problems.
+First, we describe a possible memory layout for machines
+with 64K bytes of address space.
+Here we use a member of the EM family with 2-byte word and pointer
+size.
+The most straightforward layout is shown in figure 2.
+.N 1
+.DS
+       65534 -> |-------------------------------|
+                |///////////////////////////////|
+                |//// unimplemented memory /////|
+                |///////////////////////////////|
+          ML -> |-------------------------------|
+                |                               |
+                |                               | <- LB
+                |     stack and local area      |
+                |                               |
+                |-------------------------------| <- SP
+                |///////////////////////////////|
+                |//////// inaccessible /////////|
+                |///////////////////////////////|
+                |-------------------------------| <- HP
+                |                               |
+                |           heap area           |
+                |                               |
+                |                               |
+          HB -> |-------------------------------|
+                |                               |
+                |       global data area        |
+                |                               |
+          EB -> |-------------------------------|
+                |                               |
+                |         program text          | <- PC
+                |                               |
+                |        ( and tables )         |
+                |                               |
+                |                               |
+          PB -> |-------------------------------|
+                |///////////////////////////////|
+                |////////// undefined //////////|
+                |///////////////////////////////|
+           0 -> |-------------------------------|
+
+           Figure 2.  Memory layout showing typical register
+           positions during execution of an EM program.
+.DE 2
+The base registers for the various memory pieces can be stored
+in target machine registers or memory.
+.IS
+.N 1
+.TS
+tab(;);
+l 1 l l l.
+PB;:;program base;points to the base of the instruction address space.
+EB;:;external base;points to the base of the data address space.
+HB;:;heap base;points to the base of the heap area.
+ML;:;memory limit;marks the high end of the addressable data space.
+.TE 1
+.IE
+The stack grows from high
+EM addresses to low EM addresses, and the heap the
+other way.
+The memory between SP and HP is not accessible,
+but may be allocated later to the stack or the heap if needed.
+The local data area is allocated starting at the high end of
+memory.
+.P
+Because EM address 0 is not mapped onto target
+address 0, a problem arises when pointers are used.
+If a program pushed a constant, say 6, onto the stack,
+and then tried to indirect through it,
+the wrong word would be fetched,
+because EM address 6 is mapped onto target address EB+6
+and not target address 6 itself.
+This particular problem is solved by explicitly declaring
+the format of a pointer to be undefined,
+so that using a constant as a pointer is completely illegal.
+However, the general problem of mapping pointers still exists.
+.P
+There are two possible solutions.
+In the first solution, EM pointers are represented
+in the target machine as true EM addresses,
+for example, a pointer to EM address 6 really is
+stored as a 6 in the target machine.
+This solution implies that every time a pointer is fetched
+EB must be added before referencing
+the target machine's memory.
+If the target machine has powerful indexing
+facilities, EB can be kept in a target machine register,
+and the relocation can indeed be done on
+every reference to the data address space
+at a modest cost in speed.
+.P
+The other solution consists of having EM pointers
+refer to the true target machine address.
+Thus the instruction LAE 6 (Load Address of External 6)
+would push the value of EB+6 onto the stack.
+When this approach is chosen, back ends must know
+how to offset from EB, to translate all
+instructions that manipulate EM addresses.
+However, the problem is not completely solved,
+because a front end may have to initialize a pointer
+in CON or ROM data to point to a global address.
+This pointer must also be relocated by the back end or the interpreter.
+.P
+Although the EM stack grows from high to low EM addresses,
+some machines have hardware PUSH and POP
+instructions that require the stack to grow upwards.
+If reasons of efficiency urge you to use these
+instructions, then EM
+can be implemented with the memory layout
+upside down, as shown in figure 3.
+This is possible because the pointer format is explicitly undefined.
+The first element of a word array will have a
+lower physical address than the second element.
+.N 2
+.DS
+          |                 |                    |                 |
+          |      EB=60      |                    |        ^        |
+          |                 |                    |        |        |
+          |-----------------|                    |-----------------|
+      105 |   45   |   44   | 104            214 |   41   |   40   | 215
+          |-----------------|                    |-----------------|
+      103 |   43   |   42   | 102            212 |   43   |   42   | 213
+          |-----------------|                    |-----------------|
+      101 |   41   |   40   | 100            210 |   45   |   44   | 211
+          |-----------------|                    |-----------------|
+          |        |        |                    |                 |
+          |        v        |                    |      EB=255     |
+          |                 |                    |                 |
+
+                Type A                                 Type B
+.sp 2
+              Figure 3. Two possible memory implementations.
+                 Numbers within the boxes are EM addresses.
+                 The other numbers are physical addresses.
+.DE 2
+.A 0 0
+So, we have two different EM memory implementations:
+.IS
+.PS - 4
+.PT A~-
+stack downwards
+.PT B~-
+stack upwards
+.PE
+.IE
+.P
+For each of these two possibilities we give the translation of
+the EM instructions to push the third byte of a global data
+block starting at EM address 40 onto the stack and to load the
+word at address 40.
+All translations assume a word and pointer size of two bytes.
+The target machine used is a PDP-11 augmented with push and pop instructions.
+Registers 'r0' and 'r1' are used and suffer from sign extension for byte
+transfers.
+Push $40 means push the constant 40, not word 40.
+.P
+The translation of the EM instructions depends on the pointer representation
+used.
+For each of the two solutions explained above the translation is given.
+.P
+First, the translation for the two implementations using EM addresses as
+pointer representation:
+.DS
+.TS
+tab(:), center;
+l s l s l s
+_ s _ s _ s
+l 2 l 6 l 2 l 6 l 2 l.
+EM:type A:type B
+
+
+LAE:40:push:$40:push:$40
+
+ADP:3:pop:r0:pop:r0
+::add:$3,r0:add:$3,r0
+::push:r0:push:r0
+
+LOI:1:pop:r0:pop:r0
+::-::neg:r0
+::clr:r1:clr:r1
+::bisb:eb(r0),r1:bisb:eb(r0),r1
+::push:r1:push:r1
+
+LOE:40:push:eb+40:push:eb-41
+.TE
+.DE
+.BP
+.P
+The translation for the two implementations, if the target machine address is
+used as pointer representation, is:
+.N 1
+.DS
+.TS
+tab(:), center;
+l s l s l s
+_ s _ s _ s
+l 2 l 6 l 2 l 6 l 2 l.
+EM:type A:type B
+
+
+LAE:40:push:$eb+40:push:$eb-40
+
+ADP:3:pop:r0:pop:r0
+::add:$3,r0:sub:$3,r0
+::push:r0:push:r0
+
+LOI:1:pop:r0:pop:r0
+::clr:r1:clr:r1
+::bisb:(r0),r1:bisb:(r0),r1
+::push:r1:push:r1
+
+LOE:40:push:eb+40:push:eb-41
+.TE
+.DE
+.P
+The translation presented above is not intended to be optimal.
+Most machines can handle these simple cases in one or two instructions.
+It demonstrates, however, the flexibility of the EM design.
+.P
+There are several possibilities to implement EM on machines with
+address spaces larger than 64k bytes.
+For EM with two byte pointers one could allocate instruction and
+data space each in a separate 64k piece of memory.
+EM pointers still have to fit in two bytes,
+but the base registers PB and EB may be loaded in hardware registers
+wider than 16 bits, if available.
+EM implementations can also make efficient use of a machine
+with separate instruction and data space.
+.P
+EM with 32 bit pointers allows one to make use of machines
+with large address spaces.
+In a virtual, segmented memory system one could use a separate
+segment for each fragment.

+ 80 - 0
doc/em/mem.nr

@@ -0,0 +1,80 @@
+.BP
+.SN 2
+.S1 MEMORY
+The EM machine has two distinct address spaces,
+one for instructions and one for data.
+The data space is divided up into 8-bit bytes.
+The smallest addressable unit is a byte.
+Bytes are numbered consecutively from 0 to some maximum.
+All sizes in EM are expressed in bytes.
+.P
+Some EM instructions can transfer objects containing several bytes
+to and/or from memory.
+The size of all objects larger than a word must be a multiple of
+the wordsize.
+The size of all objects smaller than a word must be a divisor
+of the wordsize.
+For example: if the wordsize is 2 bytes, objects of the sizes 1,
+2, 4, 6,... are allowed.
+The address of such an object is the lowest address of all bytes it contains.
+For objects smaller than the wordsize, the
+address must be a multiple of the object size.
+For all other objects the address must be a multiple of the
+wordsize.
+For example, if an instruction transfers a 4-byte object to memory at
+location \fIm\fP and the wordsize is 2,
+\fIm\fP must be a multiple of 2 and the bytes at
+locations \fIm\fP, \fIm\fP\|+\|1,\fIm\fP\|+\|2 and
+\fIm\fP\|+\|3 are overwritten.
+.P
+The size of almost all objects in EM
+is an integral number of words.
+Only two operations are allowed on
+objects whose size is a divisor of the wordsize:
+push it onto the stack and pop it from the stack.
+The addressing of these objects in memory is always indirect.
+If such a small object is pushed onto the stack
+it is assumed to be a small integer and stored
+in the least significant part of a word.
+The rest of the word is cleared to zero,
+although
+EM provides a way to sign-extend a small integer.
+Popping a small object from the stack removes a word
+from the stack, stores the least significant byte(s)
+of this word in memory and discards the rest of the word.
+.P
+The format of pointers into both address spaces is explicitly undefined.
+The size of a pointer, however, is fixed for a member of EM, so that
+the compiler writer knows how much storage to allocate for a pointer.
+.P
+A minor problem is raised by the undefined pointer format.
+Some languages, notably Pascal, require a special,
+otherwise illegal, pointer value to represent the nil pointer.
+The current Pascal-VU compiler uses the
+integer value 0 as nil pointer.
+This value is also used by many C programs as a normally impossible address.
+A better solution would be to have a special
+instruction loading an illegal pointer value,
+but it is hard to imagine an implementation
+for which the current solution is inadequate,
+especially because the first word in the EM data space
+is special and probably not the target of any pointer.
+.P
+The next two chapters describe the EM memory
+in more detail.
+One describes the instruction address space,
+the other the data address space.
+.P
+A design goal of EM has been to allow
+its implementation on a wide range of existing machines,
+as well as allowing a new one to be built in hardware.
+To this extent we have tried to minimize the demands
+of EM on the memory structure of the target machine.
+Therefore, apart from the logical partitioning,
+EM memory is divided into 'fragments'.
+A fragment consists of consecutive machine
+words and has a base address and a size.
+Pointer arithmetic is only defined within a fragment.
+The only exception to this rule is comparison with the null
+pointer.
+All fragments must be word aligned.

+ 5 - 0
doc/em/print

@@ -0,0 +1,5 @@
+
+case $# in
+1)      make "$1".t ; ntlp "$1".t^lpr ;;
+*)      echo $0 heeft een argument nodig ;;
+esac

+ 4 - 0
doc/em/show

@@ -0,0 +1,4 @@
+case $# in
+1)      make $1.t ; ntout $1.t ;;
+*)      echo $0 heeft een argument nodig ;;
+esac

+ 38 - 0
doc/em/title.nr

@@ -0,0 +1,38 @@
+.po 0
+.TP 1
+.ll 79
+.sp 15
+.ce 4
+DESCRIPTION OF A MACHINE
+ARCHITECTURE FOR  USE WITH
+BLOCK  STRUCTURED  LANGUAGES
+.sp 6
+.ce 4
+Andrew S. Tanenbaum
+Hans  van  Staveren
+Ed G. Keizer
+Johan  W. Stevenson\v'-0.5m'*\v'0.5m'
+.sp 2
+.ce
+August 1983
+.sp 2
+.ce
+Informatica Rapport IR-81
+.sp 13
+Abstract
+.sp 2
+.ti +5
+EM is a family of intermediate languages
+designed for producing portable compilers.
+A program called
+.B front end
+translates source programs to EM.
+Another program,
+.B back
+.BW end ,
+translates EM to the assembly language of the target machine.
+Alternatively, the EM program can be assembled to a highly
+efficient binary format for interpretation.
+This document describes the EM languages in detail.
+.sp 4
+\v'-0.5m'*\v'0.5m' Present affiliation: NV Philips, Eindhoven

+ 130 - 0
doc/em/types.nr

@@ -0,0 +1,130 @@
+.SN 6
+.BP
+.S1 "TYPE REPRESENTATIONS"
+The representations used for typed objects are not precisely
+specified by EM.
+Sometimes we only specify that a typed object occupies a
+certain amount of space and state no further restrictions.
+If one wants to have a different representation of the value of
+an object on the stack one has to use a convert instruction
+in most cases.
+We do specify some relations between the representations of
+types.
+This allows some intermixed use of operators for different types
+on the same object(s).
+For example, the instruction ZER pushes signed and
+unsigned integers with the value zero and empty sets.
+ZER has as only argument the size of the object.
+.A
+The representation of floating point numbers is a good example,
+it allows widely varying implementations.
+The only ways to create floating point numbers are via
+initialization and via conversions from integer numbers.
+Only by using conversions to integers and comparing
+two floating point numbers with each other, can these numbers
+be converted to human readable output.
+Implementations may use base 10, base 2 or any other
+base for exponents, and have freedom in choosing the range of
+exponent and mantissa.
+.A
+Other types are more precisely described.
+In the following paragraphs a description will be given of the
+restrictions imposed on the representation of the types used.
+A number \fBn\fP used in these paragraphs indicates the size of
+the object in \fIbits\fP.
+.S2 "Unsigned integers"
+The range of unsigned integers is 0..2\v'-0.5m'\fBn\fP\v'0.5m'-1.
+A binary representation is assumed.
+The order of the bits within an object is knowingly left
+unspecified.
+Discussing bit order within each 8-bit byte is academic,
+so the only real freedom of this specification lies in the byte
+order.
+We really do not care whether an implementation of a 4-byte
+integer has its bytes in a particular order of significance.
+This of course means that some sequences of instructions have
+unpredictable effects.
+For example:
+.DS
+   LOC 258 ; STL 0 ; LAL 0 ; LOI 1      ( wordsize >=2 )
+.DE
+The value on the stack after executing this sequence
+can be anything,
+but will most likely be 1 or 2.
+.A
+Conversion between unsigned integers of different sizes have to
+be done with explicit convert instructions.
+One cannot simply pad an unsigned integer with zero's at either end
+and expect a correct result.
+.A
+We assume existence of at least single word unsigned arithmetic
+in any implementation.
+.S2 "Signed Integers"
+The range of signed integers is -2\v'-0.5m'\fBn\fP-1\v'0.5m'~..~2\v'-0.5m'\fBn\fP-1\v'0.5m'-1,
+in other words the range of signed integers of \fBn\fP bits
+using two's complement arithmetic.
+The representation is the same as for unsigned integers except
+the range 2\v'-0.5m'\fBn\fP-1\v'0.5m'~..~2\v'-0.5m'\fBn\fP\v'0.5m'-1 is mapped on the
+range -2\v'-0.5m'\fBn\fP-1\v'0.5m'~..~-1.
+In other words, the most significant bit is used as sign bit.
+The convert instructions between signed and unsigned integers
+of the same size can be used to catch errors.
+.A
+The value -2\v'-0.5m'\fBn\fP-1\v'0.5m' is used for undefined
+signed integers.
+EM implementations should trap when this value is used in an
+operation on signed integers.
+The instruction mask, accessed with SIM and LIM -~see chapter 9~- ,
+can be used to disable such traps.
+.A
+We assume existence of at least single word signed arithmetic
+in any implementation.
+.BP
+.S2 "Floating point values"
+Floating point values must have a signed mantissa and a signed
+exponent.
+Although no base is specified, base 2 is the normal choice,
+because the FEF instruction pushes the exponent in base 2.
+.A
+The implementation of floating point arithmetic is optional.
+The compilers currently in use have runtime parameters for the
+size of the floating point values they should use.
+Common choices are 4 and/or 8 bytes.
+.S2 Pointers
+EM has two kinds of pointers: for instruction and for data
+space.
+Each kind can only be used for its own space, conversion between
+these two subtypes is impossible.
+We assume that pointers have a range from 0 upwards.
+Any implementation may have holes in the pointer range between
+fragments.
+One can of course not expect to be able to address two megabyte
+of memory using a 2-byte pointer.
+Normally, a 2-byte pointer allows up to 65536 bytes of
+addressable memory.
+.A
+Pointer representation has one restriction.
+The pointer with the same representation as the integer zero of
+the same size should be invalid.
+Some languages and/or runtime systems represent the nil
+pointer as zero.
+.S2 "Bit sets"
+All bit sets of size \fBn\fP are subsets of the set
+{~i~|~i>=0,~i<\fBn\fP~}.
+A bit set contains a bit for each element showing its
+presence or absence.
+Bit sets are subdivided into words.
+The word with the lowest EM address governs the subset
+{~i~|~i>=0,~i<\fBm\fP~}, where \fBm\fP is the number of bits in
+a word.
+The next higher words each govern the next higher \fBm\fP set elements.
+The relation between a set with size of
+a word and an unsigned integer word is that
+the value of the unsigned integer is the summation of the
+2\v'-0.5m'i\v'0.5m' where i is in the set.
+.A
+Example: a 2-word bit set (wordsize 2) containing the
+elements 1, 6, 8, 15, 18, 21, 27 and 28 is composed of two
+integers, e.g. at addresses 40 and 42.
+The word at 40 contains the value 33090 (or~-32446),
+the word at 42 contains the value 6180.