* Moved lcc and q3asm into code/tools

git-svn-id: svn://svn.icculus.org/quake3/trunk@134 edf5b092-35ff-0310-97b2-ce42778d08ea

36 files changed, 9123 insertions, 0 deletions

diff --git a/code/tools/lcc/tst/8q.0 b/code/tools/lcc/tst/8q.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/8q.0
diff --git a/code/tools/lcc/tst/8q.c b/code/tools/lcc/tst/8q.c
new file mode 100644
index 0000000..60a65a9
--- /dev/null
+++ b/code/tools/lcc/tst/8q.c
@@ -0,0 +1,39 @@
+int up[15], down[15], rows[8], x[8];
+int queens(), print();
+
+main()
+{
+	int i;
+
+	for (i = 0; i < 15; i++)
+		up[i] = down[i] = 1;
+	for (i = 0; i < 8; i++)
+		rows[i] = 1;
+	queens(0);
+	return 0;
+}
+
+queens(c)
+{
+	int r;
+
+	for (r = 0; r < 8; r++)
+		if (rows[r] && up[r-c+7] && down[r+c]) {
+			rows[r] = up[r-c+7] = down[r+c] = 0;
+			x[c] = r;
+			if (c == 7)
+				print();
+			else
+				queens(c + 1);
+			rows[r] = up[r-c+7] = down[r+c] = 1;
+		}
+}
+
+print()
+{
+	int k;
+
+	for (k = 0; k < 8; k++)
+		printf("%c ", x[k]+'1');
+	printf("\n");
+}
diff --git a/code/tools/lcc/tst/array.0 b/code/tools/lcc/tst/array.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/array.0
diff --git a/code/tools/lcc/tst/array.c b/code/tools/lcc/tst/array.c
new file mode 100644
index 0000000..4c967e7
--- /dev/null
+++ b/code/tools/lcc/tst/array.c
@@ -0,0 +1,48 @@
+int x[3][4], *y[3];
+
+main() {
+	int z[3][4];
+	int i, j, *p;
+
+	for (i = 0; i < 3; i++) {
+		for (j = 0; j < 4; j++)
+			x[i][j] = 1000*i + j;
+		y[i] = x[i];
+	}
+	f();
+	for (i = 0; i < 3; i++) {
+		y[i] = p = &z[i][0];
+		for (j = 0; j < 4; j++)
+			p[j] = x[i][j];
+	}
+	g(z, y);
+	return 0;
+}
+
+f() {
+	int i, j;
+
+	for (i = 0; i < 3; i++)
+		for (j = 0; j < 4; j++)
+			printf(" %d", x[i][j]);
+	printf("\n");
+	for (i = 0; i < 3; i++)
+		for (j = 0; j < 4; j++)
+			printf(" %d", y[i][j]);
+	printf("\n");
+}
+
+g(x, y)
+int x[][4], *y[];
+{
+	int i, j;
+
+	for (i = 0; i < 3; i++)
+		for (j = 0; j < 4; j++)
+			printf(" %d", x[i][j]);
+	printf("\n");
+	for (i = 0; i < 3; i++)
+		for (j = 0; j < 4; j++)
+			printf(" %d", y[i][j]);
+	printf("\n");
+}
diff --git a/code/tools/lcc/tst/cf.0 b/code/tools/lcc/tst/cf.0
new file mode 100644
index 0000000..28efab7
--- /dev/null
+++ b/code/tools/lcc/tst/cf.0
@@ -0,0 +1,32 @@
+/* cf - print character frequencies */
+float f[128];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	int i, c, nc;
+	float cutoff, atof();
+
+	if (argc <= 1)
+		cutoff = 0.0;
+	else
+		cutoff = atof(argv[1])/100;
+	for (i = 0; i <= 127; )
+		f[i++] = 0.0;
+	nc = 0;
+	while ((c = getchar()) != -1) {
+		f[c] += 1;
+		nc++;
+	}
+	printf("char\tfreq\n");
+	for (i = 0; i <= 127; ++i)
+		if (f[i] && f[i]/nc >= cutoff) {
+			if (i <= ' ')
+				printf("%03o", i);
+			else
+				printf("%c", i);
+			printf("\t%.1f\n", 100*f[i]/nc);
+		}
+	return 0;
+}
diff --git a/code/tools/lcc/tst/cf.c b/code/tools/lcc/tst/cf.c
new file mode 100644
index 0000000..28efab7
--- /dev/null
+++ b/code/tools/lcc/tst/cf.c
@@ -0,0 +1,32 @@
+/* cf - print character frequencies */
+float f[128];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	int i, c, nc;
+	float cutoff, atof();
+
+	if (argc <= 1)
+		cutoff = 0.0;
+	else
+		cutoff = atof(argv[1])/100;
+	for (i = 0; i <= 127; )
+		f[i++] = 0.0;
+	nc = 0;
+	while ((c = getchar()) != -1) {
+		f[c] += 1;
+		nc++;
+	}
+	printf("char\tfreq\n");
+	for (i = 0; i <= 127; ++i)
+		if (f[i] && f[i]/nc >= cutoff) {
+			if (i <= ' ')
+				printf("%03o", i);
+			else
+				printf("%c", i);
+			printf("\t%.1f\n", 100*f[i]/nc);
+		}
+	return 0;
+}
diff --git a/code/tools/lcc/tst/cq.0 b/code/tools/lcc/tst/cq.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/cq.0
diff --git a/code/tools/lcc/tst/cq.c b/code/tools/lcc/tst/cq.c
new file mode 100644
index 0000000..5cd0d6e
--- /dev/null
+++ b/code/tools/lcc/tst/cq.c
@@ -0,0 +1,5316 @@
+   struct defs {
+     int cbits;          /* No. of bits per char           */
+     int ibits;          /*                 int            */
+     int sbits;          /*                 short          */
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     float fprec;        /* Smallest number that can be    */
+     float dprec;        /* significantly added to 1.      */
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
+   };
+main(n,args)               /* C REFERENCE MANUAL         */
+int n;
+char **args;
+{
+
+/*   This program performs a series of tests on a C compiler,
+based on information in the
+
+             C REFERENCE MANUAL
+
+which appears as Appendix A to the book "The C Programming
+Language" by Brian W. Kernighan and Dennis M. Ritchie
+(Prentice-Hall, 1978, $10.95). This Appendix is hereafter
+referred to as "the Manual".
+
+     The rules followed in writing this program are:
+
+     1. The entire program is written in legal C, according
+     to the Manual. It should compile with no error messages,
+     although some warning messages may be produced by some
+     compilers. Failure to compile should be interpreted as
+     a compiler error.
+
+     2. The program is clean, in that it does not make use
+     of any features of the operating system on which it runs,
+     with the sole exceptions of the printf() function, and an
+     internal "options" routine, which is easily excised.
+
+     3. No global variables are used, except for the spec-
+     ific purpose of testing the global variable facility.
+
+     The program is divided into modules having names of the
+form snnn... These modules correspond to those sections of the
+Manual, as identified by boldface type headings, in which
+there is something to test. For example, s241() corresponds
+to section 2.4.1 of the Manual (Integer constants) and tests
+the facilities described therein. The module numbering
+scheme is ambiguous, especially when it names modules
+referring to more than one section; module s7813, for ex-
+ample, deals with sections 7.8 through 7.13. Nonetheless,
+it is surprisingly easy to find a section in the Manual
+corresponding to a section of code, and vice versa.
+
+     Note also that there seem to be "holes" in the program,
+at least from the point of view that there exist sections in the
+Manual for which there is no corresponding code. Such holes
+arise from three causes: (a) there is nothing in that partic-
+ular section to test, (b) everything in that section is tested
+elsewhere, and (c) it was deemed advisable not to check cer-
+tain features like preprocessor or listing control features.
+
+     Modules are called by a main program main(). The mod-
+ules that are called, and the sequence in which they are 
+called, are determined by two lists in main(), in which the
+module names appear. The first list (an extern statement)
+declares the module names to be external. The second (a stat-
+ic int statement) names the modules and defines the sequence
+in which they are called. There is no need for these lists
+to be in the same order, but it is probably a good idea to keep
+them that way in the interest of clarity. Since there are no
+cross-linkages between modules, new modules may be added,
+or old ones deleted, simply by editing the lists, with one
+exception: section s26, which pokes around at the hardware
+trying to figure out the characteristics of the machine that
+it is running on, saves information that is subsequently
+used by sections s626, s72, and s757. If this program is
+to be broken up into smallish pieces, say for running on
+a microcomputer, take care to see that s26 is called before
+calling any of the latter three sections.  The size
+of the lists, i.e., the number of modules to be called, is
+not explicitly specified as a program parameter, but is
+determined dynamically using the sizeof operator.
+
+     Communication between the main program and the modules
+takes place in two ways. In all cases, a pointer to a structure
+is passed to the called module. The structure contains flags
+that will determine the type of information to be published
+by the module, and fields that may be written in by the
+module. The former include "flgm" and "flgd", which, if set
+to a nonzero value, specify that machine dependencies are to
+be announced or that error messages are to be printed, re-
+spectively. The called module's name, and the hardware char-
+acteristics probed in s26() comprise the latter.
+
+
+     Also, in all cases, a return code is returned by the called
+module. A return code of zero indicates that all has gone well;
+nonzero indicates otherwise. Since more than one type of error
+may be detected by a module, the return code is a composite
+of error indicators, which, individually, are given as numbers
+that are powers of two. Thus, a return code of 10 indicates
+that two specific errors, 8 and 2, were detected. Whether or
+not the codes returned by the modules are printed by the main
+program is determined by setting "flgs" to 1 (resp. 0).
+
+     The entire logic of the main program is contained in the
+half-dozen or so lines at the end. The somewhat cryptic 
+statement:
+
+           d0.rrc = (*sec[j])(pd0);
+
+in the for loop calls the modules. The rest of the code is
+reasonably straightforward.
+
+     Finally, in each of the modules, there is the following
+prologue:
+
+           snnn(pd0)
+           struct defs *pd0;
+           {
+              static char snnner[] = "snnn,er%d\n";
+              static char qsnnn[8] = "snnn   ";
+              char *ps, *pt;
+              int rc;
+
+              rc = 0;
+              ps = qsnnn;
+              pt = pd0->rfs;
+              while(*pt++ = *ps++);
+
+used for housekeeping, handshaking and module initialization.
+
+                                                           */
+   extern
+     s22(),
+     s241(),
+     s243(),
+     s244(),
+     s25(),
+     s26(),
+     s4(),
+     s61(),
+     s626(),
+     s71(),
+     s72(),
+     s757(),
+     s7813(),
+     s714(),
+     s715(),
+     s81(),
+     s84(),
+     s85(),
+     s86(),
+     s88(),
+     s9()
+   ;
+
+   int j;
+   static int (*sec[])() = {
+     s22,
+     s241,
+     s243,
+     s244,
+     s25,
+     s26,
+     s4,
+     s61,
+     s626,
+     s71,
+     s72,
+     s757,
+     s7813,
+     s714,
+     s715,
+     s81,
+     s84,
+     s85,
+     s86,
+     s88,
+     s9
+   };
+
+   static struct defs d0, *pd0;
+    
+     d0.flgs = 1;          /* These flags dictate            */
+     d0.flgm = 1;          /*     the verbosity of           */
+     d0.flgd = 1;          /*         the program.           */
+     d0.flgl = 1;
+
+   pd0 = &d0;
+
+   for (j=0; j<sizeof(sec) / sizeof(sec[0]); j++) {
+     d0.rrc = (*sec[j])(pd0);
+     d0.crc = d0.crc+d0.rrc;
+     if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
+   }
+  
+   if(d0.crc == 0) printf("\nNo errors detected.\n");
+   else printf("\nFailed.\n");
+   return 0;
+}
+s22(pd0)                 /* 2.2 Identifiers (Names)      */
+struct defs *pd0;
+{
+   int a234, a;
+   int _, _234, A, rc;
+
+   static char s22er[] = "s22,er%d\n";
+   static char qs22[8] = "s22    ";
+
+   char *ps, *pt;
+                         /* Initialize                      */
+
+   rc = 0;
+   ps = qs22;
+   pt = pd0 -> rfs;
+   while (*pt++ = *ps++);
+
+     /* An identifier is a sequence of letters and digits;
+        the first character must be a letter. The under-
+        score _ counts as a letter.                        */
+
+   a=1;
+   _=2;
+   _234=3;
+   a234=4;
+   if(a+_+_234+a234 != 10) {
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s22er,1);
+   }
+
+   /* Upper and lower case letters are different.     */
+
+   A = 2;
+   if (A == a) {
+     rc = rc+4;
+     if (pd0->flgd != 0) printf(s22er,4);
+   }
+
+   return(rc);
+}
+s241(pd0)                   /* 2.4.1 Integer constants
+                               2.4.2 Explicit long constants  */
+struct defs *pd0;
+{
+   long pow2();
+   static char s241er[] = "s241,er%d\n";
+   static char qs241[8] = "s241   ";
+   char *ps, *pt;
+   int rc, j, lrc;
+   static long g[39] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+                        0,6,0,8,0,12,0,16,0,18,0,20,0,24,
+                        0,28,0,30,0,32,0,36};
+   long d[39], o[39], x[39];
+
+   rc = 0;
+   lrc = 0;
+   ps = qs241;
+   pt = pd0 -> rfs;
+   while (*pt++ = *ps++);
+
+     /* An integer constant consisting of a sequence of digits is
+        taken to be octal if it begins with 0 (digit zero), decimal
+        otherwise.                                            */
+
+   if (   8 !=  010
+     ||  16 !=  020
+     ||  24 !=  030
+     ||  32 !=  040
+     ||  40 !=  050
+     ||  48 !=  060
+     ||  56 !=  070
+     ||  64 != 0100
+     ||  72 != 0110
+     ||  80 != 0120
+     ||   9 != 0011
+     ||  17 != 0021
+     ||  25 != 0031
+     ||  33 != 0041
+     ||  41 != 0051
+     ||  49 != 0061
+     ||  57 != 0071
+     ||  65 != 0101
+     ||  73 != 0111
+     ||  81 != 0121 ){
+
+     rc = rc+1;
+     if( pd0->flgd != 0 ) printf(s241er,1);
+   }
+
+     /* A sequence of digits preceded by 0x or 0X (digit zero)
+        is taken to be a hexadecimal integer. The hexadecimal
+        digits include a or A through f or F with values 10
+        through 15.     */
+
+   if ( 0x00abcdef != 0xabcdef
+     || 0xabcdef != 0Xabcdef || 0Xabcdef != 0XAbcdef
+     || 0XAbcdef != 0XABcdef || 0XABcdef != 0XABCdef
+     || 0XABCdef != 0XABCDef || 0XABCDef != 0XABCDEf
+     || 0XABCDEf != 0XABCDEF || 0xABCDEF != 11259375 ){
+
+     rc = rc+2;
+     if( pd0->flgd != 0 ) printf(s241er,2);
+   }
+
+     /* A decimal constant whose value exceeds the largest signed
+        machine integer is taken to be long; an octal or hex con-
+        stant which exceeds the largest unsigned machine integer
+        is likewise taken to be long.     */
+
+   if ( sizeof 010000000000 != sizeof(long)      /* 2**30 */
+     || sizeof 1073741824   != sizeof(long)      /* ditto */
+     || sizeof 0x40000000   != sizeof(long) ){   /*   "   */
+
+     rc = rc+4;
+     if( pd0->flgd != 0 ) printf(s241er,4);
+   }
+
+     /* A decimal, octal, or hexadecimal constant immediately followed
+        by l (letter ell) or L is a long constant.    */
+
+   if ( sizeof   67l != sizeof(long)
+     || sizeof   67L != sizeof(long)
+     || sizeof  067l != sizeof(long)
+     || sizeof  067L != sizeof(long)
+     || sizeof 0X67l != sizeof(long)
+     || sizeof 0x67L != sizeof(long) ){
+
+     rc = rc+8;
+     if( pd0 -> flgd != 0 ) printf(s241er,8);
+   }
+
+     /* Finally, we test to see that decimal (d), octal (o),
+        and hexadecimal (x) constants representing the same values
+        agree among themselves, and with computed values, at spec-
+        ified points over an appropriate range. The points select-
+        ed here are those with the greatest potential for caus-
+        ing trouble, i.e., zero, 1-16, and values of 2**n and
+        2**n - 1 where n is some multiple of 4 or 6. Unfortunately,
+        just what happens when a value is too big to fit in a
+        long is undefined; however, it would be nice if what
+        happened were at least consistent...      */
+
+   for ( j=0; j<17; j++ ) g[j] = j;
+   for ( j=18; j<39; ) {
+     g[j] = pow2(g[j]);
+     g[j-1] = g[j] - 1;
+     j = j+2;
+   }
+
+   d[0] = 0;                o[0] = 00;               x[0] = 0x0;
+   d[1] = 1;                o[1] = 01;               x[1] = 0x1;
+   d[2] = 2;                o[2] = 02;               x[2] = 0x2;
+   d[3] = 3;                o[3] = 03;               x[3] = 0x3;
+   d[4] = 4;                o[4] = 04;               x[4] = 0x4;
+   d[5] = 5;                o[5] = 05;               x[5] = 0x5;
+   d[6] = 6;                o[6] = 06;               x[6] = 0x6;
+   d[7] = 7;                o[7] = 07;               x[7] = 0x7;
+   d[8] = 8;                o[8] = 010;              x[8] = 0x8;
+   d[9] = 9;                o[9] = 011;              x[9] = 0x9;
+   d[10] = 10;              o[10] = 012;             x[10] = 0xa;
+   d[11] = 11;              o[11] = 013;             x[11] = 0xb;
+   d[12] = 12;              o[12] = 014;             x[12] = 0xc;
+   d[13] = 13;              o[13] = 015;             x[13] = 0xd;
+   d[14] = 14;              o[14] = 016;             x[14] = 0xe;
+   d[15] = 15;              o[15] = 017;             x[15] = 0xf;
+   d[16] = 16;              o[16] = 020;             x[16] = 0x10;
+   d[17] = 63;              o[17] = 077;             x[17] = 0x3f;
+   d[18] = 64;              o[18] = 0100;            x[18] = 0x40;
+   d[19] = 255;             o[19] = 0377;            x[19] = 0xff;
+   d[20] = 256;             o[20] = 0400;            x[20] = 0x100;
+   d[21] = 4095;            o[21] = 07777;           x[21] = 0xfff;
+   d[22] = 4096;            o[22] = 010000;          x[22] = 0x1000;
+   d[23] = 65535;           o[23] = 0177777;         x[23] = 0xffff;
+   d[24] = 65536;           o[24] = 0200000;         x[24] = 0x10000;
+   d[25] = 262143;          o[25] = 0777777;         x[25] = 0x3ffff;
+   d[26] = 262144;          o[26] = 01000000;        x[26] = 0x40000;
+   d[27] = 1048575;         o[27] = 03777777;        x[27] = 0xfffff;
+   d[28] = 1048576;         o[28] = 04000000;        x[28] = 0x100000;
+   d[29] = 16777215;        o[29] = 077777777;       x[29] = 0xffffff;
+   d[30] = 16777216;        o[30] = 0100000000;      x[30] = 0x1000000;
+   d[31] = 268435455;       o[31] = 01777777777;     x[31] = 0xfffffff;
+   d[32] = 268435456;       o[32] = 02000000000;     x[32] = 0x10000000;
+   d[33] = 1073741823;      o[33] = 07777777777;     x[33] = 0x3fffffff;
+   d[34] = 1073741824;      o[34] = 010000000000;    x[34] = 0x40000000;
+   d[35] = 4294967295;      o[35] = 037777777777;    x[35] = 0xffffffff;
+   d[36] = 4294967296;      o[36] = 040000000000;    x[36] = 0x100000000;
+   d[37] = 68719476735;     o[37] = 0777777777777;   x[37] = 0xfffffffff;
+   d[38] = 68719476736;     o[38] = 01000000000000;  x[38] = 0x1000000000;
+
+   /* WHEW! */
+
+   for (j=0; j<39; j++){
+     if ( g[j] != d[j]
+       || d[j] != o[j]
+       || o[j] != x[j]) {
+
+       if( pd0 -> flgm != 0 ) {
+/*       printf(s241er,16);          save in case opinions change...     */
+         printf("Decimal and octal/hex constants sometimes give\n");
+         printf("   different results when assigned to longs.\n");
+       }
+/*     lrc = 1;   save...   */
+     }
+   }
+
+   if (lrc != 0) rc =16;
+
+   return rc;
+}
+
+long pow2(n)        /* Calculate 2**n by multiplying, not shifting  */
+long n;
+{
+   long s;
+   s = 1;
+   while(n--) s = s*2;
+   return s;
+}
+s243(pd0)                   /*  2.4.3 Character constants  */
+struct defs *pd0;
+{
+   static char s243er[] = "s243,er%d\n";
+   static char qs243[8] = "s243   ";
+   char *ps, *pt;
+   int rc;
+   char chars[256];
+
+   rc = 0;
+   ps = qs243;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+
+     /* One of the problems that arises when testing character constants
+        is that of definition: What, exactly, is the character set?
+        In order to guarantee a certain amount of machine independence,
+        the character set we will use here is the set of characters writ-
+        able as escape sequences in C, plus those characters used in writ-
+        ing C programs, i.e.,
+
+        letters:
+                   ABCDEFGHIJKLMNOPQRSTUVWXYZ      26
+                   abcdefghijklmnopqrstuvwxyz      26
+        numbers:
+                   0123456789                      10
+        special characters:
+                   ~!"#%&()_=-^|{}[]+;*:<>,.?/     27
+        extra special characters:
+                   newline           \n       
+                   horizontal tab    \t
+                   backspace         \b
+                   carriage return   \r
+                   form feed         \f
+                   backslash         \\
+                   single quote      \'             7
+        blank & NUL                                 2
+                                                  ---
+                                                   98
+
+        Any specific implementation of C may of course support additional
+        characters.                                       */
+
+        /* Since the value of a character constant is the numerical value
+           of the character in the machine's character set, there should
+           be a one-to-one correspondence between characters and values. */
+
+   zerofill(chars);
+
+   chars['a'] = 1;   chars['A'] = 1;   chars['~'] = 1;   chars['0'] = 1;
+   chars['b'] = 1;   chars['B'] = 1;   chars['!'] = 1;   chars['1'] = 1;
+   chars['c'] = 1;   chars['C'] = 1;   chars['"'] = 1;   chars['2'] = 1;
+   chars['d'] = 1;   chars['D'] = 1;   chars['#'] = 1;   chars['3'] = 1;
+   chars['e'] = 1;   chars['E'] = 1;   chars['%'] = 1;   chars['4'] = 1;
+   chars['f'] = 1;   chars['F'] = 1;   chars['&'] = 1;   chars['5'] = 1;
+   chars['g'] = 1;   chars['G'] = 1;   chars['('] = 1;   chars['6'] = 1;
+   chars['h'] = 1;   chars['H'] = 1;   chars[')'] = 1;   chars['7'] = 1;
+   chars['i'] = 1;   chars['I'] = 1;   chars['_'] = 1;   chars['8'] = 1;
+   chars['j'] = 1;   chars['J'] = 1;   chars['='] = 1;   chars['9'] = 1;
+   chars['k'] = 1;   chars['K'] = 1;   chars['-'] = 1;
+   chars['l'] = 1;   chars['L'] = 1;   chars['^'] = 1;
+   chars['m'] = 1;   chars['M'] = 1;   chars['|'] = 1;   chars['\n'] = 1;
+   chars['n'] = 1;   chars['N'] = 1;                     chars['\t'] = 1;
+   chars['o'] = 1;   chars['O'] = 1;   chars['{'] = 1;   chars['\b'] = 1;
+   chars['p'] = 1;   chars['P'] = 1;   chars['}'] = 1;   chars['\r'] = 1;
+   chars['q'] = 1;   chars['Q'] = 1;   chars['['] = 1;   chars['\f'] = 1;
+   chars['r'] = 1;   chars['R'] = 1;   chars[']'] = 1;
+   chars['s'] = 1;   chars['S'] = 1;   chars['+'] = 1;   chars['\\'] = 1;
+   chars['t'] = 1;   chars['T'] = 1;   chars[';'] = 1;   chars['\''] = 1;
+   chars['u'] = 1;   chars['U'] = 1;   chars['*'] = 1;  
+   chars['v'] = 1;   chars['V'] = 1;   chars[':'] = 1;   chars['\0'] = 1;
+   chars['w'] = 1;   chars['W'] = 1;   chars['<'] = 1;   chars[' '] = 1;
+   chars['x'] = 1;   chars['X'] = 1;   chars['>'] = 1;
+   chars['y'] = 1;   chars['Y'] = 1;   chars[','] = 1;
+   chars['z'] = 1;   chars['Z'] = 1;   chars['.'] = 1;
+                                       chars['?'] = 1;
+                                       chars['/'] = 1;
+
+   if(sumof(chars) != 98){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s243er,1);
+   }
+
+   /* Finally, the escape \ddd consists of the backslash followed
+      by 1, 2, or 3 octal digits which are taken to specify  the
+      desired character.                           */
+
+   if( '\0'    !=   0 || '\01'   !=   1 || '\02'   !=   2
+    || '\03'   !=   3 || '\04'   !=   4 || '\05'   !=   5
+    || '\06'   !=   6 || '\07'   !=   7 || '\10'   !=   8
+    || '\17'   !=  15 || '\20'   !=  16 || '\77'   !=  63
+    || '\100'  !=  64 || '\177'  != 127                 ){
+   
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s243er,8);
+   }
+
+   return rc;
+}
+zerofill(x)
+char *x;
+{
+   int j;
+
+   for (j=0; j<256; j++) *x++ = 0;
+}
+sumof(x)
+char *x;
+{
+   char *p;
+   int total, j;
+
+   p = x;
+   total = 0;
+
+   for(j=0; j<256; j++) total = total+ *p++;
+   return total;
+}
+s244(pd0)
+struct defs *pd0;
+{
+   double a[8];
+   int rc, lrc, j;
+   static char s244er[] = "s244,er%d\n";
+   static char qs244[8] = "s244   ";
+   char *ps, *pt;
+
+   ps = qs244;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+   rc = 0;
+   lrc = 0;
+
+   /* Unfortunately, there's not a lot we can do with floating constants.
+      We can check to see that the various representations can be com-
+      piled, that the conversion is such that they yield the same hard-
+      ware representations in all cases, and that all representations
+      thus checked are double precision.              */
+
+   a[0] = .1250E+04;
+   a[1] = 1.250E3;
+   a[2] = 12.50E02;
+   a[3] = 125.0e+1;
+   a[4] = 1250e00;
+   a[5] = 12500.e-01;
+   a[6] = 125000e-2;
+   a[7] = 1250.;
+
+   lrc = 0;
+   for (j=0; j<7; j++) if(a[j] != a[j+1]) lrc = 1;
+
+   if(lrc != 0) {
+     if(pd0->flgd != 0) printf(s244er,1);
+     rc = rc+1;
+   }
+
+   if ( (sizeof .1250E+04 ) != sizeof(double)
+     || (sizeof 1.250E3   ) != sizeof(double)
+     || (sizeof 12.50E02  ) != sizeof(double)
+     || (sizeof 1.250e+1  ) != sizeof(double)
+     || (sizeof 1250e00   ) != sizeof(double)
+     || (sizeof 12500.e-01) != sizeof(double)
+     || (sizeof 125000e-2 ) != sizeof(double)
+     || (sizeof 1250.     ) != sizeof(double)){
+     
+     if(pd0->flgd != 0) printf(s244er,2);
+     rc = rc+2;
+   }
+
+   return rc;
+}
+s25(pd0)
+struct defs *pd0;
+{
+   char *s, *s2;
+   int rc, lrc, j;
+   static char s25er[] = "s25,er%d\n";
+   static char qs25[8] = "s25    ";
+   char *ps, *pt;
+
+   ps = qs25;
+   pt = pd0->rfs;
+   while(*pt++ = *ps++);
+   rc = 0;
+
+   /* A string is a sequence of characters surrounded by double
+      quotes, as in "...".                         */
+
+   s = "...";
+
+   /* A string has type "array of characters" and storage class
+      static and is initialized with the given characters.  */
+
+   if ( s[0] != s[1] || s[1] != s[2]
+     || s[2] != '.' ) {
+
+    rc = rc+1;
+     if(pd0->flgd != 0) printf(s25er,1);
+   }
+
+   /* The compiler places a null byte \0 at the end of each string
+      so the program which scans the string can find its end.   */
+
+   if( s[3] != '\0' ){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s25er,4);
+   }
+
+   /* In a string, the double quote character " must be preceded
+      by a \.                                               */
+
+    if( ".\"."[1] != '"' ){
+    rc = rc+8;
+     if(pd0->flgd != 0) printf(s25er,8);
+   }
+
+   /* In addition, the same escapes described for character constants
+      may be used.                                            */
+
+   s = "\n\t\b\r\f\\\'";
+
+   if( s[0] != '\n'
+    || s[1] != '\t'
+    || s[2] != '\b'
+    || s[3] != '\r'
+    || s[4] != '\f'
+    || s[5] != '\\'
+    || s[6] != '\'' ){
+
+     rc = rc+16;
+     if( pd0->flgd != 0) printf(s25er,16);
+   }
+
+   /* Finally, a \ and an immediately following newline are ignored */
+
+   s2 = "queep!";
+   s = "queep!";
+
+   lrc = 0;
+   for (j=0; j<sizeof "queep!"; j++) if(s[j] != s2[j]) lrc = 1;
+   if (lrc != 0){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s25er,32);
+   }
+   return rc;
+}
+s26(pd0)                  /*  2.6  Hardware Characteristics     */
+struct defs *pd0;
+{
+   static char qs26[8] = "s26    ";
+   char *ps, *pt;
+   char c0, c1;
+   float temp, one, delta;
+   double tempd, oned;
+   static char s[] = "%3d bits in %ss.\n";
+   static char s2[] = "%e is the least number that can be added to 1. (%s).\n";
+
+   ps = qs26;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+          /* Here, we shake the machinery a little to see what falls
+             out.  First, we find out how many bits are in a char.  */
+
+   pd0->cbits = 0;
+   c0 = 0;
+   c1 = 1;
+
+   while(c0 != c1) {
+     c1 = c1<<1;
+     pd0->cbits = pd0->cbits+1;
+   }
+          /* That information lets us determine the size of everything else. */
+
+   pd0->ibits = pd0->cbits * sizeof(int);
+   pd0->sbits = pd0->cbits * sizeof(short);
+   pd0->lbits = pd0->cbits * sizeof(long);
+   pd0->ubits = pd0->cbits * sizeof(unsigned);
+   pd0->fbits = pd0->cbits * sizeof(float);
+   pd0->dbits = pd0->cbits * sizeof(double);
+
+          /* We have now almost reconstructed the table in section 2.6, the
+             exception being the range of the floating point hardware.
+             Now there are just so many ways to conjure up a floating point
+             representation system that it's damned near impossible to guess
+             what's going on by writing a program to interpret bit patterns.
+             Further, the information isn't all that useful, if we consider
+             the fact that machines that won't handle numbers between 10**30
+             and 10**-30 are very hard to find, and that people playing with
+             numbers outside that range have a lot more to worry about than
+             just the capacity of the characteristic.
+
+             A much more useful measure is the precision, which can be ex-
+             pressed in terms of the smallest number that can be added to
+             1. without loss of significance. We calculate that here, for
+             float and double.                       */
+
+   one = 1.;
+   delta = 1.;
+   temp = 0.;
+   while(temp != one) {
+     temp = one+delta;
+     delta = delta/2.;
+   }
+   pd0->fprec = delta * 4.;
+   oned = 1.;
+   delta = 1.;
+   tempd = 0.;
+   while(tempd != oned) {
+     tempd = oned+delta;
+     delta = delta/2.;
+   }
+   pd0->dprec = delta * 4.;
+
+          /* Now, if anyone's interested, we publish the results.       */
+
+   if(pd0->flgm != 0) {
+     printf(s,pd0->cbits,"char");
+     printf(s,pd0->ibits,"int");
+     printf(s,pd0->sbits,"short");
+     printf(s,pd0->lbits,"long");
+     printf(s,pd0->ubits,"unsigned");
+     printf(s,pd0->fbits,"float");
+     printf(s,pd0->dbits,"double");
+     printf(s2,pd0->fprec,"float");
+     printf(s2,pd0->dprec,"double");
+   }
+          /* Since we are only exploring and perhaps reporting, but not 
+             testing any features, we cannot return an error code.  */
+
+   return 0;
+}
+int extvar;
+s4(pd0)                    /* 4. What's in a name?             */
+struct defs *pd0;
+{
+   static char s4er[] = "s4,er%d\n";
+   static char qs4[8] = "s4     ";
+   char *ps, *pt;
+   int j, rc;
+
+   short sint;             /* short integer, for size test      */
+   int pint;               /* plain                             */
+   long lint;              /* long                              */
+   unsigned target;
+   unsigned int mask;
+
+   rc = 0;
+   ps = qs4;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+/*   There are four declarable storage classes: automatic,
+static, external, and register. Automatic variables have
+been dealt with extensively thus far, and will not be specif-
+ically treated in this section. Register variables are treated
+in section s81.
+
+     Static variables are local to a block, but retain their
+values upon reentry to a block, even after control has left
+the block.                                                     */
+
+   for (j=0; j<3; j++)
+     if(svtest(j) != zero()){
+       rc = 1;
+       if(pd0->flgd != 0) printf(s4er,1);
+     }
+   ;
+
+/*   External variables exist and retain their values throughout
+the execution of the entire program, and may be used for comm-
+unication between functions, even separately compiled functions.
+                                                                */
+
+   setev();
+   if(testev() != 0){
+     rc=rc+2;
+     if(pd0->flgd != 0) printf(s4er,2);
+   }
+/*   
+     Characters have been tested elsewhere (in s243).
+
+     Up to three sizes of integer, declared short int, int, and
+long int, are available. Longer integers provide no less storage
+than shorter ones, but implementation may make either short
+integers, or long integers, or both, equivalent to plain
+integers.
+                                                                */
+
+   if(sizeof lint < sizeof pint || sizeof pint < sizeof sint){
+
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s4er,4);
+   }
+
+/*   Unsigned integers, declared unsigned, obey the laws of
+arithmetic modulo 2**n, where n is the number of bits in the
+implementation                                                  */
+
+   target = ~0U;
+   mask = 1;
+ 
+   for(j=0; j<(sizeof target)*pd0->cbits; j++){
+   
+     mask = mask&target;
+     target = target>>1;
+   }
+
+   if(mask != 1 || target != 0){
+
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s4er,8);
+   }
+
+   return rc;
+}
+svtest(n)
+int n;
+{
+   static k;
+   int rc;
+   switch (n) {
+
+     case 0: k = 1978;
+             rc = 0;
+             break;
+
+     case 1: if(k != 1978) rc = 1;
+             else{
+              k = 1929;
+              rc = 0;
+             }
+             break;
+
+     case 2: if(k != 1929) rc = 1;
+             else rc = 0;
+             break;
+   }
+   return rc;
+}
+zero(){                 /* Returns a value of zero, possibly */
+   static k;            /* with side effects, as it's called */
+   int rc;              /* alternately with svtest, above,   */
+   k = 2;               /* and has the same internal storage */
+   rc = 0;              /* requirements.                     */
+   return rc;
+}
+testev(){
+   if(extvar != 1066) return 1;
+   else return 0;
+}
+s61(pd0)          /* Characters and integers */
+struct defs *pd0;
+{
+   static char s61er[] = "s61,er%d\n";
+   static char qs61[8] = "s61    ";
+   short from, shortint;
+   long int to, longint;
+   int rc, lrc;
+   int j;
+   char fromc, charint;
+   char *wd, *pc[6];
+   
+   static char upper_alpha[]             = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+   static char lower_alpha[]             = "abcdefghijklmnopqrstuvwxyz";
+   static char numbers[]               = "0123456789";
+   static char special_characters[]    = "~!\"#%&()_=-^|{}[]+;*:<>,.?/";
+   static char extra_special_characters[] = "\n\t\b\r\f\\\'";
+   static char blank_and_NUL[]            = " \0";
+
+   char *ps, *pt;
+   ps = qs61;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+/*      A character or a short integer may be used wherever
+an integer may be used. In all cases, the value is converted
+to integer. This principle is extensively used throughout this
+program, and will not be explicitly tested here.        */
+
+/*      Conversion of a shorter integer to a longer always
+involves sign extension.                                */
+
+   from = -19;
+   to = from;
+
+   if(to != -19){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s61er,1);
+   }
+
+/*      It is guaranteed that a member of the standard char-
+acter set is nonnegative.                               */
+
+   pc[0] = upper_alpha;
+   pc[1] = lower_alpha;
+   pc[2] = numbers;
+   pc[3] = special_characters;
+   pc[4] = extra_special_characters;
+   pc[5] = blank_and_NUL;
+
+   lrc = 0;
+   for (j=0; j<6; j++)
+     while(*pc[j]) if(*pc[j]++ < 0) lrc =1;
+
+   if(lrc != 0){
+     rc=rc+2;
+     if(pd0->flgd != 0) printf(s61er,2);
+   }
+
+/*      When a longer integer is converted to a shorter or
+to  a char, it is truncated on the left; excess bits are 
+simply discarded.                                       */
+
+   longint = 1048579;           /* =2**20+3 */
+   shortint = longint;
+   charint = longint;
+
+   if((shortint != longint && shortint != 3) ||
+      (charint  != longint && charint  != 3)) {
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s61er,8);
+   }
+
+   return rc;
+}
+s626(pd0)          /* 6.2 Float and double                  */
+                   /* 6.3 Floating and integral                 */
+                   /* 6.4 Pointers and integers                 */
+                   /* 6.5 Unsigned                              */
+                   /* 6.6 Arithmetic conversions                */
+struct defs *pd0;
+{
+   static char s626er[] = "s626,er%d\n";
+   static char qs626[8] = "s626   ";
+   int rc;
+   char *ps, *pt;
+   float eps, f1, f2, f3, f4, f;
+   long lint1, lint2, l, ls;
+   char c, t[28], t0;
+   short s;
+   int is, i, j;
+   unsigned u, us;
+   double d, ds;
+   ps = qs626;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* Conversions of integral values to floating type are
+        well-behaved.                                           */
+
+   f1 = 1.;
+   lint1 = 1.;
+   lint2 = 1.;
+
+   for(j=0;j<pd0->lbits-2;j++){
+     f1 = f1*2;
+     lint2 = (lint2<<1)|lint1;
+   }
+   f2 = lint2;
+   f1 = (f1-f2)/f1;
+   if(f1>2.*pd0->fprec){
+
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s626er,2);
+   }
+
+        /* Pointer-integer combinations are discussed in s74,
+        "Additive operators". The unsigned-int combination
+        appears below.                                          */
+
+   c = 125;
+   s = 125;
+   i = 125;     is = 15625;
+   u = 125;     us = 15625;
+   l = 125;     ls = 15625;
+   f = 125.;
+   d = 125.;    ds = 15625.;
+
+   for(j=0;j<28;j++) t[j] = 0;
+
+   if(c*c != is) t[ 0] = 1;
+   if(s*c != is) t[ 1] = 1;
+   if(s*s != is) t[ 2] = 1;
+   if(i*c != is) t[ 3] = 1;
+   if(i*s != is) t[ 4] = 1;
+   if(i*i != is) t[ 5] = 1;
+   if(u*c != us) t[ 6] = 1;
+   if(u*s != us) t[ 7] = 1;
+   if(u*i != us) t[ 8] = 1;
+   if(u*u != us) t[ 9] = 1;
+   if(l*c != ls) t[10] = 1;
+   if(l*s != ls) t[11] = 1;
+   if(l*i != ls) t[12] = 1;
+   if(l*u != us) t[13] = 1;
+   if(l*l != ls) t[14] = 1;
+   if(f*c != ds) t[15] = 1;
+   if(f*s != ds) t[16] = 1;
+   if(f*i != ds) t[17] = 1;
+   if(f*u != ds) t[18] = 1;
+   if(f*l != ds) t[19] = 1;
+   if(f*f != ds) t[20] = 1;
+   if(d*c != ds) t[21] = 1;
+   if(d*s != ds) t[22] = 1;
+   if(d*i != ds) t[23] = 1;
+   if(d*u != ds) t[24] = 1;
+   if(d*l != ds) t[25] = 1;
+   if(d*f != ds) t[26] = 1;
+   if(d*d != ds) t[27] = 1;
+
+   t0 = 0;
+   for(j=0; j<28; j++) t0 = t0+t[j];
+
+   if(t0 != 0){
+
+     rc = rc+4;
+     if(pd0->flgd != 0){
+
+       printf(s626er,4);
+       printf("   key=");
+       for(j=0;j<28;j++) printf("%d",t[j]);
+       printf("\n");
+     }
+   }
+
+        /* When an unsigned integer is converted to long,
+           the value of the result is the same numerically
+           as that of the unsigned integer.               */
+
+   l = (unsigned)0100000;
+   if((long)l > (unsigned)0100000){
+
+      rc = rc+8;
+      if(pd0->flgd != 0) printf(s626er,8);
+   }
+
+   return rc;
+}
+s71(pd0)          /*         7.1  Primary expressions   */
+struct defs *pd0;
+{
+   static char s71er[] = "s71,er%d\n";
+   static char qs71[8] = "s71    ";
+   int rc;
+   char *ps, *pt;
+   static char q = 'q';
+   int x[10], McCarthy(), clobber(), a, b, *p;
+   ps = qs71;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+/*   Testing of expressions and operators is quite complicated,
+     because (a) problems are apt to surface in queer combinations
+     of operators and operands, rather than in isolation,
+     and (b) the number of expressions needed to provoke a case
+     of improper behaviour may be quite large. Hence, we take the
+     following approach: for this section, and for subsequent
+     sections through 7.15, we will check the primitive operations
+     in isolation, thus verifying that the primitives work,
+     after a fashion. The job of testing combinations, we will
+     leave to a separate, machine-generated program, to be included
+     in the C test package at some later date.
+                                                                */
+
+/*   A string is a primary expression. The identifier points to
+     the first character of a string.
+                                                                  */
+
+   if(*"queep" != q){
+     rc = rc+1;
+     if(pd0->flgd  != 0) printf(s71er,1);
+   }
+/*   A parenthesized expression is a primary expression whose
+     type and value are the same as those of the unadorned
+     expression.
+                                                                */
+   if((2+3) != 2+3) {
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s71er,2);
+   }
+
+/*   A primary expression followed by an expression in square 
+     brackets is a primary expression. The intuitive meaning is
+     that of a subscript. The expression E1[E2] is identical
+     (by definition) to *((E1)+(E2)).
+                                                                */
+
+   x[5] = 1942;
+   if(x[5] != 1942 || x[5] != *((x)+(5))){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s71er,4);
+   }
+
+/*   If the various flavors of function calls didn't work, we
+     would never have gotten this far; however, we do need to 
+     show that functions can be recursive...
+                                                               */
+
+   if ( McCarthy(-5) != 91){
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s71er,8);
+   }
+
+/*   and that argument passing is strictly by value.           */
+
+   a = 2;
+   b = 3;
+   p = &b;
+
+   clobber(a,p);
+
+   if(a != 2 || b != 2){
+     rc = rc+16;
+     if(pd0->flgd != 0) printf(s71er,16);
+   }
+
+/*   Finally, structures and unions are addressed thusly:      */
+
+   if(pd0->dprec != (*pd0).dprec){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s71er,32);
+   }
+
+   return rc;
+}
+McCarthy(x)
+int x;
+{
+   if(x>100) return x-10;
+   else return McCarthy( McCarthy(x+11));
+}
+clobber(x,y)
+int x, *y;
+{
+   x = 3;
+   *y = 2;
+}
+s714(pd0)          /*  7.14  Assignment operators       */
+struct defs *pd0;
+{
+   static char f[] = "Local error %d.\n";
+   static char s714er[] = "s714,er%d\n";
+   static char qs714[8] = "s714   ";
+   register int prlc, lrc;
+   int rc;
+   char cl, cr;
+   short sl, sr;
+   int il, ir;
+   long ll, lr;
+   unsigned ul, ur;
+   float fl, fr;
+   double dl, dr;
+   char *ps, *pt;
+   ps = qs714;
+   pt = pd0->rfs;
+   rc = 0;
+   lrc = 0;
+   prlc = pd0->flgl;
+   while (*pt++ = *ps++);
+
+        /* This section tests the assignment operators.
+
+        It is an exhaustive test of all assignment statements
+        of the form:
+
+                vl op vr
+
+        where vl and vr are variables from the set
+        {char,short,int,long,unsigned,float,double} and op is
+        one of the assignment operators. There are 395 such
+        statements.
+
+        The initial values for the variables have been chosen
+        so that both the initial values and the results will
+        "fit" in just about any implementation, and that the re-
+        sults will be such that they test for the proper form-
+        ation of composite operators, rather than checking for
+        the valid operation of those operators' components.
+        For example, in checking >>=, we want to verify that
+        a right shift and a move take place, rather than
+        whether or not there may be some peculiarities about
+        the right shift. Such tests have been made previously,
+        and to repeat them here would be to throw out a red
+        herring.
+
+        The table below lists the operators, assignment targets,
+        initial values for left and right operands, and the
+        expected values of the results.
+
+
+          =  +=  -=  *=  /=  %=  >>=  <<=  &=  ^=  |=	
+char      2   7   3  10   2   1   1    20   8   6  14
+short     2   7   3  10   2   1   1    20   8   6  14
+int       2   7   3  10   2   1   1    20   8   6  14
+long      2   7   3  10   2   1   1    20   8   6  14
+unsigned  2   7   3  10   2   1   1    20   8   6  14
+float     2   7   3  10 2.5 |             |
+double    2   7   3  10 2.5 |             |
+                            |             |
+initial         (5,2)       |    (5,2)    |  (12,10)
+
+        The following machine-generated program reflects the
+        tests described in the table.
+                                                                */
+
+   cl = 5; cr = 2;
+   cl = cr;
+   if(cl != 2){
+     lrc = 1;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl = sr;
+   if(cl != 2){
+     lrc = 2;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl = ir;
+   if(cl != 2){
+     lrc = 3;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl = lr;
+   if(cl != 2){
+     lrc = 4;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl = ur;
+   if(cl != 2){
+     lrc = 5;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; fr = 2;
+   cl = fr;
+   if(cl != 2){
+     lrc = 6;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; dr = 2;
+   cl = dr;
+   if(cl != 2){
+     lrc = 7;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl = cr;
+   if(sl != 2){
+     lrc = 8;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl = sr;
+   if(sl != 2){
+     lrc = 9;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl = ir;
+   if(sl != 2){
+     lrc = 10;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl = lr;
+   if(sl != 2){
+     lrc = 11;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl = ur;
+   if(sl != 2){
+     lrc = 12;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; fr = 2;
+   sl = fr;
+   if(sl != 2){
+     lrc = 13;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; dr = 2;
+   sl = dr;
+   if(sl != 2){
+     lrc = 14;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il = cr;
+   if(il != 2){
+     lrc = 15;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il = sr;
+   if(il != 2){
+     lrc = 16;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il = ir;
+   if(il != 2){
+     lrc = 17;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il = lr;
+   if(il != 2){
+     lrc = 18;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il = ur;
+   if(il != 2){
+     lrc = 19;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; fr = 2;
+   il = fr;
+   if(il != 2){
+     lrc = 20;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; dr = 2;
+   il = dr;
+   if(il != 2){
+     lrc = 21;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll = cr;
+   if(ll != 2){
+     lrc = 22;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll = sr;
+   if(ll != 2){
+     lrc = 23;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll = ir;
+   if(ll != 2){
+     lrc = 24;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll = lr;
+   if(ll != 2){
+     lrc = 25;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll = ur;
+   if(ll != 2){
+     lrc = 26;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; fr = 2;
+   ll = fr;
+   if(ll != 2){
+     lrc = 27;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; dr = 2;
+   ll = dr;
+   if(ll != 2){
+     lrc = 28;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul = cr;
+   if(ul != 2){
+     lrc = 29;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul = sr;
+   if(ul != 2){
+     lrc = 30;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul = ir;
+   if(ul != 2){
+     lrc = 31;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul = lr;
+   if(ul != 2){
+     lrc = 32;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul = ur;
+   if(ul != 2){
+     lrc = 33;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; fr = 2;
+   ul = fr;
+   if(ul != 2){
+     lrc = 34;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; dr = 2;
+   ul = dr;
+   if(ul != 2){
+     lrc = 35;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; cr = 2;
+   fl = cr;
+   if(fl != 2){
+     lrc = 36;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; sr = 2;
+   fl = sr;
+   if(fl != 2){
+     lrc = 37;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ir = 2;
+   fl = ir;
+   if(fl != 2){
+     lrc = 38;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; lr = 2;
+   fl = lr;
+   if(fl != 2){
+     lrc = 39;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ur = 2;
+   fl = ur;
+   if(fl != 2){
+     lrc = 40;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; fr = 2;
+   fl = fr;
+   if(fl != 2){
+     lrc = 41;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; dr = 2;
+   fl = dr;
+   if(fl != 2){
+     lrc = 42;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; cr = 2;
+   dl = cr;
+   if(dl != 2){
+     lrc = 43;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; sr = 2;
+   dl = sr;
+   if(dl != 2){
+     lrc = 44;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ir = 2;
+   dl = ir;
+   if(dl != 2){
+     lrc = 45;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; lr = 2;
+   dl = lr;
+   if(dl != 2){
+     lrc = 46;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ur = 2;
+   dl = ur;
+   if(dl != 2){
+     lrc = 47;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; fr = 2;
+   dl = fr;
+   if(dl != 2){
+     lrc = 48;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; dr = 2;
+   dl = dr;
+   if(dl != 2){
+     lrc = 49;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl += cr;
+   if(cl != 7){
+     lrc = 50;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl += sr;
+   if(cl != 7){
+     lrc = 51;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl += ir;
+   if(cl != 7){
+     lrc = 52;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl += lr;
+   if(cl != 7){
+     lrc = 53;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl += ur;
+   if(cl != 7){
+     lrc = 54;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; fr = 2;
+   cl += fr;
+   if(cl != 7){
+     lrc = 55;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; dr = 2;
+   cl += dr;
+   if(cl != 7){
+     lrc = 56;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl += cr;
+   if(sl != 7){
+     lrc = 57;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl += sr;
+   if(sl != 7){
+     lrc = 58;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl += ir;
+   if(sl != 7){
+     lrc = 59;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl += lr;
+   if(sl != 7){
+     lrc = 60;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl += ur;
+   if(sl != 7){
+     lrc = 61;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; fr = 2;
+   sl += fr;
+   if(sl != 7){
+     lrc = 62;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; dr = 2;
+   sl += dr;
+   if(sl != 7){
+     lrc = 63;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il += cr;
+   if(il != 7){
+     lrc = 64;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il += sr;
+   if(il != 7){
+     lrc = 65;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il += ir;
+   if(il != 7){
+     lrc = 66;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il += lr;
+   if(il != 7){
+     lrc = 67;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il += ur;
+   if(il != 7){
+     lrc = 68;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; fr = 2;
+   il += fr;
+   if(il != 7){
+     lrc = 69;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; dr = 2;
+   il += dr;
+   if(il != 7){
+     lrc = 70;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll += cr;
+   if(ll != 7){
+     lrc = 71;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll += sr;
+   if(ll != 7){
+     lrc = 72;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll += ir;
+   if(ll != 7){
+     lrc = 73;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll += lr;
+   if(ll != 7){
+     lrc = 74;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll += ur;
+   if(ll != 7){
+     lrc = 75;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; fr = 2;
+   ll += fr;
+   if(ll != 7){
+     lrc = 76;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; dr = 2;
+   ll += dr;
+   if(ll != 7){
+     lrc = 77;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul += cr;
+   if(ul != 7){
+     lrc = 78;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul += sr;
+   if(ul != 7){
+     lrc = 79;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul += ir;
+   if(ul != 7){
+     lrc = 80;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul += lr;
+   if(ul != 7){
+     lrc = 81;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul += ur;
+   if(ul != 7){
+     lrc = 82;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; fr = 2;
+   ul += fr;
+   if(ul != 7){
+     lrc = 83;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; dr = 2;
+   ul += dr;
+   if(ul != 7){
+     lrc = 84;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; cr = 2;
+   fl += cr;
+   if(fl != 7){
+     lrc = 85;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; sr = 2;
+   fl += sr;
+   if(fl != 7){
+     lrc = 86;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ir = 2;
+   fl += ir;
+   if(fl != 7){
+     lrc = 87;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; lr = 2;
+   fl += lr;
+   if(fl != 7){
+     lrc = 88;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ur = 2;
+   fl += ur;
+   if(fl != 7){
+     lrc = 89;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; fr = 2;
+   fl += fr;
+   if(fl != 7){
+     lrc = 90;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; dr = 2;
+   fl += dr;
+   if(fl != 7){
+     lrc = 91;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; cr = 2;
+   dl += cr;
+   if(dl != 7){
+     lrc = 92;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; sr = 2;
+   dl += sr;
+   if(dl != 7){
+     lrc = 93;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ir = 2;
+   dl += ir;
+   if(dl != 7){
+     lrc = 94;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; lr = 2;
+   dl += lr;
+   if(dl != 7){
+     lrc = 95;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ur = 2;
+   dl += ur;
+   if(dl != 7){
+     lrc = 96;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; fr = 2;
+   dl += fr;
+   if(dl != 7){
+     lrc = 97;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; dr = 2;
+   dl += dr;
+   if(dl != 7){
+     lrc = 98;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl -= cr;
+   if(cl != 3){
+     lrc = 99;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl -= sr;
+   if(cl != 3){
+     lrc = 100;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl -= ir;
+   if(cl != 3){
+     lrc = 101;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl -= lr;
+   if(cl != 3){
+     lrc = 102;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl -= ur;
+   if(cl != 3){
+     lrc = 103;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; fr = 2;
+   cl -= fr;
+   if(cl != 3){
+     lrc = 104;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; dr = 2;
+   cl -= dr;
+   if(cl != 3){
+     lrc = 105;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl -= cr;
+   if(sl != 3){
+     lrc = 106;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl -= sr;
+   if(sl != 3){
+     lrc = 107;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl -= ir;
+   if(sl != 3){
+     lrc = 108;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl -= lr;
+   if(sl != 3){
+     lrc = 109;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl -= ur;
+   if(sl != 3){
+     lrc = 110;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; fr = 2;
+   sl -= fr;
+   if(sl != 3){
+     lrc = 111;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; dr = 2;
+   sl -= dr;
+   if(sl != 3){
+     lrc = 112;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il -= cr;
+   if(il != 3){
+     lrc = 113;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il -= sr;
+   if(il != 3){
+     lrc = 114;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il -= ir;
+   if(il != 3){
+     lrc = 115;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il -= lr;
+   if(il != 3){
+     lrc = 116;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il -= ur;
+   if(il != 3){
+     lrc = 117;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; fr = 2;
+   il -= fr;
+   if(il != 3){
+     lrc = 118;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; dr = 2;
+   il -= dr;
+   if(il != 3){
+     lrc = 119;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll -= cr;
+   if(ll != 3){
+     lrc = 120;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll -= sr;
+   if(ll != 3){
+     lrc = 121;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll -= ir;
+   if(ll != 3){
+     lrc = 122;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll -= lr;
+   if(ll != 3){
+     lrc = 123;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll -= ur;
+   if(ll != 3){
+     lrc = 124;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; fr = 2;
+   ll -= fr;
+   if(ll != 3){
+     lrc = 125;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; dr = 2;
+   ll -= dr;
+   if(ll != 3){
+     lrc = 126;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul -= cr;
+   if(ul != 3){
+     lrc = 127;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul -= sr;
+   if(ul != 3){
+     lrc = 128;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul -= ir;
+   if(ul != 3){
+     lrc = 129;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul -= lr;
+   if(ul != 3){
+     lrc = 130;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul -= ur;
+   if(ul != 3){
+     lrc = 131;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; fr = 2;
+   ul -= fr;
+   if(ul != 3){
+     lrc = 132;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; dr = 2;
+   ul -= dr;
+   if(ul != 3){
+     lrc = 133;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; cr = 2;
+   fl -= cr;
+   if(fl != 3){
+     lrc = 134;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; sr = 2;
+   fl -= sr;
+   if(fl != 3){
+     lrc = 135;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ir = 2;
+   fl -= ir;
+   if(fl != 3){
+     lrc = 136;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; lr = 2;
+   fl -= lr;
+   if(fl != 3){
+     lrc = 137;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ur = 2;
+   fl -= ur;
+   if(fl != 3){
+     lrc = 138;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; fr = 2;
+   fl -= fr;
+   if(fl != 3){
+     lrc = 139;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; dr = 2;
+   fl -= dr;
+   if(fl != 3){
+     lrc = 140;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; cr = 2;
+   dl -= cr;
+   if(dl != 3){
+     lrc = 141;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; sr = 2;
+   dl -= sr;
+   if(dl != 3){
+     lrc = 142;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ir = 2;
+   dl -= ir;
+   if(dl != 3){
+     lrc = 143;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; lr = 2;
+   dl -= lr;
+   if(dl != 3){
+     lrc = 144;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ur = 2;
+   dl -= ur;
+   if(dl != 3){
+     lrc = 145;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; fr = 2;
+   dl -= fr;
+   if(dl != 3){
+     lrc = 146;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; dr = 2;
+   dl -= dr;
+   if(dl != 3){
+     lrc = 147;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl *= cr;
+   if(cl != 10){
+     lrc = 148;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl *= sr;
+   if(cl != 10){
+     lrc = 149;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl *= ir;
+   if(cl != 10){
+     lrc = 150;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl *= lr;
+   if(cl != 10){
+     lrc = 151;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl *= ur;
+   if(cl != 10){
+     lrc = 152;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; fr = 2;
+   cl *= fr;
+   if(cl != 10){
+     lrc = 153;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; dr = 2;
+   cl *= dr;
+   if(cl != 10){
+     lrc = 154;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl *= cr;
+   if(sl != 10){
+     lrc = 155;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl *= sr;
+   if(sl != 10){
+     lrc = 156;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl *= ir;
+   if(sl != 10){
+     lrc = 157;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl *= lr;
+   if(sl != 10){
+     lrc = 158;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl *= ur;
+   if(sl != 10){
+     lrc = 159;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; fr = 2;
+   sl *= fr;
+   if(sl != 10){
+     lrc = 160;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; dr = 2;
+   sl *= dr;
+   if(sl != 10){
+     lrc = 161;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il *= cr;
+   if(il != 10){
+     lrc = 162;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il *= sr;
+   if(il != 10){
+     lrc = 163;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il *= ir;
+   if(il != 10){
+     lrc = 164;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il *= lr;
+   if(il != 10){
+     lrc = 165;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il *= ur;
+   if(il != 10){
+     lrc = 166;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; fr = 2;
+   il *= fr;
+   if(il != 10){
+     lrc = 167;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; dr = 2;
+   il *= dr;
+   if(il != 10){
+     lrc = 168;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll *= cr;
+   if(ll != 10){
+     lrc = 169;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll *= sr;
+   if(ll != 10){
+     lrc = 170;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll *= ir;
+   if(ll != 10){
+     lrc = 171;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll *= lr;
+   if(ll != 10){
+     lrc = 172;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll *= ur;
+   if(ll != 10){
+     lrc = 173;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; fr = 2;
+   ll *= fr;
+   if(ll != 10){
+     lrc = 174;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; dr = 2;
+   ll *= dr;
+   if(ll != 10){
+     lrc = 175;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul *= cr;
+   if(ul != 10){
+     lrc = 176;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul *= sr;
+   if(ul != 10){
+     lrc = 177;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul *= ir;
+   if(ul != 10){
+     lrc = 178;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul *= lr;
+   if(ul != 10){
+     lrc = 179;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul *= ur;
+   if(ul != 10){
+     lrc = 180;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; fr = 2;
+   ul *= fr;
+   if(ul != 10){
+     lrc = 181;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; dr = 2;
+   ul *= dr;
+   if(ul != 10){
+     lrc = 182;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; cr = 2;
+   fl *= cr;
+   if(fl != 10){
+     lrc = 183;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; sr = 2;
+   fl *= sr;
+   if(fl != 10){
+     lrc = 184;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ir = 2;
+   fl *= ir;
+   if(fl != 10){
+     lrc = 185;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; lr = 2;
+   fl *= lr;
+   if(fl != 10){
+     lrc = 186;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ur = 2;
+   fl *= ur;
+   if(fl != 10){
+     lrc = 187;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; fr = 2;
+   fl *= fr;
+   if(fl != 10){
+     lrc = 188;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; dr = 2;
+   fl *= dr;
+   if(fl != 10){
+     lrc = 189;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; cr = 2;
+   dl *= cr;
+   if(dl != 10){
+     lrc = 190;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; sr = 2;
+   dl *= sr;
+   if(dl != 10){
+     lrc = 191;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ir = 2;
+   dl *= ir;
+   if(dl != 10){
+     lrc = 192;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; lr = 2;
+   dl *= lr;
+   if(dl != 10){
+     lrc = 193;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ur = 2;
+   dl *= ur;
+   if(dl != 10){
+     lrc = 194;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; fr = 2;
+   dl *= fr;
+   if(dl != 10){
+     lrc = 195;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; dr = 2;
+   dl *= dr;
+   if(dl != 10){
+     lrc = 196;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl /= cr;
+   if(cl != 2){
+     lrc = 197;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl /= sr;
+   if(cl != 2){
+     lrc = 198;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl /= ir;
+   if(cl != 2){
+     lrc = 199;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl /= lr;
+   if(cl != 2){
+     lrc = 200;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl /= ur;
+   if(cl != 2){
+     lrc = 201;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; fr = 2;
+   cl /= fr;
+   if(cl != 2){
+     lrc = 202;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; dr = 2;
+   cl /= dr;
+   if(cl != 2){
+     lrc = 203;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl /= cr;
+   if(sl != 2){
+     lrc = 204;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl /= sr;
+   if(sl != 2){
+     lrc = 205;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl /= ir;
+   if(sl != 2){
+     lrc = 206;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl /= lr;
+   if(sl != 2){
+     lrc = 207;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl /= ur;
+   if(sl != 2){
+     lrc = 208;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; fr = 2;
+   sl /= fr;
+   if(sl != 2){
+     lrc = 209;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; dr = 2;
+   sl /= dr;
+   if(sl != 2){
+     lrc = 210;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il /= cr;
+   if(il != 2){
+     lrc = 211;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il /= sr;
+   if(il != 2){
+     lrc = 212;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il /= ir;
+   if(il != 2){
+     lrc = 213;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il /= lr;
+   if(il != 2){
+     lrc = 214;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il /= ur;
+   if(il != 2){
+     lrc = 215;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; fr = 2;
+   il /= fr;
+   if(il != 2){
+     lrc = 216;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; dr = 2;
+   il /= dr;
+   if(il != 2){
+     lrc = 217;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll /= cr;
+   if(ll != 2){
+     lrc = 218;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll /= sr;
+   if(ll != 2){
+     lrc = 219;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll /= ir;
+   if(ll != 2){
+     lrc = 220;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll /= lr;
+   if(ll != 2){
+     lrc = 221;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll /= ur;
+   if(ll != 2){
+     lrc = 222;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; fr = 2;
+   ll /= fr;
+   if(ll != 2){
+     lrc = 223;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; dr = 2;
+   ll /= dr;
+   if(ll != 2){
+     lrc = 224;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul /= cr;
+   if(ul != 2){
+     lrc = 225;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul /= sr;
+   if(ul != 2){
+     lrc = 226;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul /= ir;
+   if(ul != 2){
+     lrc = 227;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul /= lr;
+   if(ul != 2){
+     lrc = 228;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul /= ur;
+   if(ul != 2){
+     lrc = 229;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; fr = 2;
+   ul /= fr;
+   if(ul != 2){
+     lrc = 230;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; dr = 2;
+   ul /= dr;
+   if(ul != 2){
+     lrc = 231;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; cr = 2;
+   fl /= cr;
+   if(fl != 2.5){
+     lrc = 232;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; sr = 2;
+   fl /= sr;
+   if(fl != 2.5){
+     lrc = 233;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ir = 2;
+   fl /= ir;
+   if(fl != 2.5){
+     lrc = 234;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; lr = 2;
+   fl /= lr;
+   if(fl != 2.5){
+     lrc = 235;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; ur = 2;
+   fl /= ur;
+   if(fl != 2.5){
+     lrc = 236;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; fr = 2;
+   fl /= fr;
+   if(fl != 2.5){
+     lrc = 237;
+     if(prlc) printf(f,lrc);
+   }
+   fl = 5; dr = 2;
+   fl /= dr;
+   if(fl != 2.5){
+     lrc = 238;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; cr = 2;
+   dl /= cr;
+   if(dl != 2.5){
+     lrc = 239;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; sr = 2;
+   dl /= sr;
+   if(dl != 2.5){
+     lrc = 240;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ir = 2;
+   dl /= ir;
+   if(dl != 2.5){
+     lrc = 241;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; lr = 2;
+   dl /= lr;
+   if(dl != 2.5){
+     lrc = 242;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; ur = 2;
+   dl /= ur;
+   if(dl != 2.5){
+     lrc = 243;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; fr = 2;
+   dl /= fr;
+   if(dl != 2.5){
+     lrc = 244;
+     if(prlc) printf(f,lrc);
+   }
+   dl = 5; dr = 2;
+   dl /= dr;
+   if(dl != 2.5){
+     lrc = 245;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl %= cr;
+   if(cl != 1){
+     lrc = 246;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl %= sr;
+   if(cl != 1){
+     lrc = 247;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl %= ir;
+   if(cl != 1){
+     lrc = 248;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl %= lr;
+   if(cl != 1){
+     lrc = 249;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl %= ur;
+   if(cl != 1){
+     lrc = 250;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl %= cr;
+   if(sl != 1){
+     lrc = 251;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl %= sr;
+   if(sl != 1){
+     lrc = 252;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl %= ir;
+   if(sl != 1){
+     lrc = 253;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl %= lr;
+   if(sl != 1){
+     lrc = 254;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl %= ur;
+   if(sl != 1){
+     lrc = 255;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il %= cr;
+   if(il != 1){
+     lrc = 256;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il %= sr;
+   if(il != 1){
+     lrc = 257;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il %= ir;
+   if(il != 1){
+     lrc = 258;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il %= lr;
+   if(il != 1){
+     lrc = 259;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il %= ur;
+   if(il != 1){
+     lrc = 260;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll %= cr;
+   if(ll != 1){
+     lrc = 261;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll %= sr;
+   if(ll != 1){
+     lrc = 262;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll %= ir;
+   if(ll != 1){
+     lrc = 263;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll %= lr;
+   if(ll != 1){
+     lrc = 264;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll %= ur;
+   if(ll != 1){
+     lrc = 265;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul %= cr;
+   if(ul != 1){
+     lrc = 266;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul %= sr;
+   if(ul != 1){
+     lrc = 267;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul %= ir;
+   if(ul != 1){
+     lrc = 268;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul %= lr;
+   if(ul != 1){
+     lrc = 269;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul %= ur;
+   if(ul != 1){
+     lrc = 270;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl >>= cr;
+   if(cl != 1){
+     lrc = 271;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl >>= sr;
+   if(cl != 1){
+     lrc = 272;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl >>= ir;
+   if(cl != 1){
+     lrc = 273;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl >>= lr;
+   if(cl != 1){
+     lrc = 274;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl >>= ur;
+   if(cl != 1){
+     lrc = 275;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl >>= cr;
+   if(sl != 1){
+     lrc = 276;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl >>= sr;
+   if(sl != 1){
+     lrc = 277;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl >>= ir;
+   if(sl != 1){
+     lrc = 278;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl >>= lr;
+   if(sl != 1){
+     lrc = 279;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl >>= ur;
+   if(sl != 1){
+     lrc = 280;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il >>= cr;
+   if(il != 1){
+     lrc = 281;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il >>= sr;
+   if(il != 1){
+     lrc = 282;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il >>= ir;
+   if(il != 1){
+     lrc = 283;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il >>= lr;
+   if(il != 1){
+     lrc = 284;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il >>= ur;
+   if(il != 1){
+     lrc = 285;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll >>= cr;
+   if(ll != 1){
+     lrc = 286;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll >>= sr;
+   if(ll != 1){
+     lrc = 287;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll >>= ir;
+   if(ll != 1){
+     lrc = 288;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll >>= lr;
+   if(ll != 1){
+     lrc = 289;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll >>= ur;
+   if(ll != 1){
+     lrc = 290;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul >>= cr;
+   if(ul != 1){
+     lrc = 291;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul >>= sr;
+   if(ul != 1){
+     lrc = 292;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul >>= ir;
+   if(ul != 1){
+     lrc = 293;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul >>= lr;
+   if(ul != 1){
+     lrc = 294;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul >>= ur;
+   if(ul != 1){
+     lrc = 295;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; cr = 2;
+   cl <<= cr;
+   if(cl != 20){
+     lrc = 296;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; sr = 2;
+   cl <<= sr;
+   if(cl != 20){
+     lrc = 297;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ir = 2;
+   cl <<= ir;
+   if(cl != 20){
+     lrc = 298;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; lr = 2;
+   cl <<= lr;
+   if(cl != 20){
+     lrc = 299;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 5; ur = 2;
+   cl <<= ur;
+   if(cl != 20){
+     lrc = 300;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; cr = 2;
+   sl <<= cr;
+   if(sl != 20){
+     lrc = 301;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; sr = 2;
+   sl <<= sr;
+   if(sl != 20){
+     lrc = 302;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ir = 2;
+   sl <<= ir;
+   if(sl != 20){
+     lrc = 303;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; lr = 2;
+   sl <<= lr;
+   if(sl != 20){
+     lrc = 304;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 5; ur = 2;
+   sl <<= ur;
+   if(sl != 20){
+     lrc = 305;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; cr = 2;
+   il <<= cr;
+   if(il != 20){
+     lrc = 306;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; sr = 2;
+   il <<= sr;
+   if(il != 20){
+     lrc = 307;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ir = 2;
+   il <<= ir;
+   if(il != 20){
+     lrc = 308;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; lr = 2;
+   il <<= lr;
+   if(il != 20){
+     lrc = 309;
+     if(prlc) printf(f,lrc);
+   }
+   il = 5; ur = 2;
+   il <<= ur;
+   if(il != 20){
+     lrc = 310;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; cr = 2;
+   ll <<= cr;
+   if(ll != 20){
+     lrc = 311;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; sr = 2;
+   ll <<= sr;
+   if(ll != 20){
+     lrc = 312;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ir = 2;
+   ll <<= ir;
+   if(ll != 20){
+     lrc = 313;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; lr = 2;
+   ll <<= lr;
+   if(ll != 20){
+     lrc = 314;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 5; ur = 2;
+   ll <<= ur;
+   if(ll != 20){
+     lrc = 315;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; cr = 2;
+   ul <<= cr;
+   if(ul != 20){
+     lrc = 316;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; sr = 2;
+   ul <<= sr;
+   if(ul != 20){
+     lrc = 317;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ir = 2;
+   ul <<= ir;
+   if(ul != 20){
+     lrc = 318;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; lr = 2;
+   ul <<= lr;
+   if(ul != 20){
+     lrc = 319;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 5; ur = 2;
+   ul <<= ur;
+   if(ul != 20){
+     lrc = 320;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; cr = 10;
+   cl &= cr;
+   if(cl != 8){
+     lrc = 321;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; sr = 10;
+   cl &= sr;
+   if(cl != 8){
+     lrc = 322;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ir = 10;
+   cl &= ir;
+   if(cl != 8){
+     lrc = 323;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; lr = 10;
+   cl &= lr;
+   if(cl != 8){
+     lrc = 324;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ur = 10;
+   cl &= ur;
+   if(cl != 8){
+     lrc = 325;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; cr = 10;
+   sl &= cr;
+   if(sl != 8){
+     lrc = 326;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; sr = 10;
+   sl &= sr;
+   if(sl != 8){
+     lrc = 327;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ir = 10;
+   sl &= ir;
+   if(sl != 8){
+     lrc = 328;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; lr = 10;
+   sl &= lr;
+   if(sl != 8){
+     lrc = 329;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ur = 10;
+   sl &= ur;
+   if(sl != 8){
+     lrc = 330;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; cr = 10;
+   il &= cr;
+   if(il != 8){
+     lrc = 331;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; sr = 10;
+   il &= sr;
+   if(il != 8){
+     lrc = 332;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ir = 10;
+   il &= ir;
+   if(il != 8){
+     lrc = 333;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; lr = 10;
+   il &= lr;
+   if(il != 8){
+     lrc = 334;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ur = 10;
+   il &= ur;
+   if(il != 8){
+     lrc = 335;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; cr = 10;
+   ll &= cr;
+   if(ll != 8){
+     lrc = 336;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; sr = 10;
+   ll &= sr;
+   if(ll != 8){
+     lrc = 337;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ir = 10;
+   ll &= ir;
+   if(ll != 8){
+     lrc = 338;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; lr = 10;
+   ll &= lr;
+   if(ll != 8){
+     lrc = 339;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ur = 10;
+   ll &= ur;
+   if(ll != 8){
+     lrc = 340;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; cr = 10;
+   ul &= cr;
+   if(ul != 8){
+     lrc = 341;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; sr = 10;
+   ul &= sr;
+   if(ul != 8){
+     lrc = 342;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ir = 10;
+   ul &= ir;
+   if(ul != 8){
+     lrc = 343;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; lr = 10;
+   ul &= lr;
+   if(ul != 8){
+     lrc = 344;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ur = 10;
+   ul &= ur;
+   if(ul != 8){
+     lrc = 345;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; cr = 10;
+   cl ^= cr;
+   if(cl != 6){
+     lrc = 346;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; sr = 10;
+   cl ^= sr;
+   if(cl != 6){
+     lrc = 347;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ir = 10;
+   cl ^= ir;
+   if(cl != 6){
+     lrc = 348;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; lr = 10;
+   cl ^= lr;
+   if(cl != 6){
+     lrc = 349;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ur = 10;
+   cl ^= ur;
+   if(cl != 6){
+     lrc = 350;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; cr = 10;
+   sl ^= cr;
+   if(sl != 6){
+     lrc = 351;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; sr = 10;
+   sl ^= sr;
+   if(sl != 6){
+     lrc = 352;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ir = 10;
+   sl ^= ir;
+   if(sl != 6){
+     lrc = 353;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; lr = 10;
+   sl ^= lr;
+   if(sl != 6){
+     lrc = 354;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ur = 10;
+   sl ^= ur;
+   if(sl != 6){
+     lrc = 355;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; cr = 10;
+   il ^= cr;
+   if(il != 6){
+     lrc = 356;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; sr = 10;
+   il ^= sr;
+   if(il != 6){
+     lrc = 357;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ir = 10;
+   il ^= ir;
+   if(il != 6){
+     lrc = 358;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; lr = 10;
+   il ^= lr;
+   if(il != 6){
+     lrc = 359;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ur = 10;
+   il ^= ur;
+   if(il != 6){
+     lrc = 360;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; cr = 10;
+   ll ^= cr;
+   if(ll != 6){
+     lrc = 361;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; sr = 10;
+   ll ^= sr;
+   if(ll != 6){
+     lrc = 362;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ir = 10;
+   ll ^= ir;
+   if(ll != 6){
+     lrc = 363;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; lr = 10;
+   ll ^= lr;
+   if(ll != 6){
+     lrc = 364;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ur = 10;
+   ll ^= ur;
+   if(ll != 6){
+     lrc = 365;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; cr = 10;
+   ul ^= cr;
+   if(ul != 6){
+     lrc = 366;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; sr = 10;
+   ul ^= sr;
+   if(ul != 6){
+     lrc = 367;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ir = 10;
+   ul ^= ir;
+   if(ul != 6){
+     lrc = 368;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; lr = 10;
+   ul ^= lr;
+   if(ul != 6){
+     lrc = 369;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ur = 10;
+   ul ^= ur;
+   if(ul != 6){
+     lrc = 370;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; cr = 10;
+   cl |= cr;
+   if(cl != 14){
+     lrc = 371;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; sr = 10;
+   cl |= sr;
+   if(cl != 14){
+     lrc = 372;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ir = 10;
+   cl |= ir;
+   if(cl != 14){
+     lrc = 373;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; lr = 10;
+   cl |= lr;
+   if(cl != 14){
+     lrc = 374;
+     if(prlc) printf(f,lrc);
+   }
+   cl = 12; ur = 10;
+   cl |= ur;
+   if(cl != 14){
+     lrc = 375;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; cr = 10;
+   sl |= cr;
+   if(sl != 14){
+     lrc = 376;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; sr = 10;
+   sl |= sr;
+   if(sl != 14){
+     lrc = 377;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ir = 10;
+   sl |= ir;
+   if(sl != 14){
+     lrc = 378;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; lr = 10;
+   sl |= lr;
+   if(sl != 14){
+     lrc = 379;
+     if(prlc) printf(f,lrc);
+   }
+   sl = 12; ur = 10;
+   sl |= ur;
+   if(sl != 14){
+     lrc = 380;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; cr = 10;
+   il |= cr;
+   if(il != 14){
+     lrc = 381;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; sr = 10;
+   il |= sr;
+   if(il != 14){
+     lrc = 382;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ir = 10;
+   il |= ir;
+   if(il != 14){
+     lrc = 383;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; lr = 10;
+   il |= lr;
+   if(il != 14){
+     lrc = 384;
+     if(prlc) printf(f,lrc);
+   }
+   il = 12; ur = 10;
+   il |= ur;
+   if(il != 14){
+     lrc = 385;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; cr = 10;
+   ll |= cr;
+   if(ll != 14){
+     lrc = 386;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; sr = 10;
+   ll |= sr;
+   if(ll != 14){
+     lrc = 387;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ir = 10;
+   ll |= ir;
+   if(ll != 14){
+     lrc = 388;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; lr = 10;
+   ll |= lr;
+   if(ll != 14){
+     lrc = 389;
+     if(prlc) printf(f,lrc);
+   }
+   ll = 12; ur = 10;
+   ll |= ur;
+   if(ll != 14){
+     lrc = 390;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; cr = 10;
+   ul |= cr;
+   if(ul != 14){
+     lrc = 391;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; sr = 10;
+   ul |= sr;
+   if(ul != 14){
+     lrc = 392;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ir = 10;
+   ul |= ir;
+   if(ul != 14){
+     lrc = 393;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; lr = 10;
+   ul |= lr;
+   if(ul != 14){
+     lrc = 394;
+     if(prlc) printf(f,lrc);
+   }
+   ul = 12; ur = 10;
+   ul |= ur;
+   if(ul != 14){
+     lrc = 395;
+     if(prlc) printf(f,lrc);
+   }
+   if(lrc != 0) {
+     rc = 1;
+     if(pd0->flgd != 0) printf(s714er,1);
+   }
+   return rc;
+}
+s715(pd0)          /*  7.15 Comma operator     */
+struct defs *pd0;
+{
+   static char s715er[] = "s715,er%d\n";
+   static char qs715[8] = "s715   ";
+   int rc;
+   char *ps, *pt;
+   int a, t, c, i;
+   a = c = 0;
+   ps = qs715;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* A pair of expressions separated by a comma is
+        evaluated left to right and the value of the left
+        expression is discarded.
+                                                                */
+   i = 1;
+   if( i++,i++,i++,i++,++i != 6 ){
+     if(pd0->flgd != 0) printf(s715er,1);
+     rc = rc+1;
+   }
+
+        /* In contexts where the comma is given a special mean-
+        ing, for example in a list of actual arguments to 
+        functions (sic) and lists of initializers, the comma
+        operator as described in this section can only appear
+        in parentheses; for example
+
+                f( a, (t=3, t+2), c)
+
+        has three arguments, the second of which has the
+        value 5.
+                                                                */
+
+   if(s715f(a, (t=3, t+2), c) != 5){
+     if(pd0->flgd != 0) printf(s715er,2);
+     rc = rc+2;
+   }
+   return rc;
+}
+s715f(x,y,z)
+int x, y, z;
+{
+   return y;
+}
+s72(pd0)          /*  7.2  Unary operators  */
+struct defs *pd0;
+{
+   static char s72er[] = "s72,er%d\n";
+   static char qs72[8] = "s72    ";
+   int rc;
+   char *ps, *pt;
+   int k, j, i, lrc;
+   char c;
+   short s;
+   long l;
+   unsigned u;
+   double d;
+   float f;
+   ps = qs72;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The *, denoting indirection, and the &, denoting a
+        pointer, are duals of each other, and ought to behave as 
+        such...                                                 */
+
+   k = 2;
+   if(*&*&k != 2){
+     rc = rc+1;
+     printf(s72er,1);
+   }
+
+        /* The unary minus has the conventional meaning.        */
+
+   if(k+(-k) != 0){
+     rc = rc+2;
+     printf(s72er,2);
+   }
+
+        /*  The negation operator (!) has been thoroughly checked out,
+        perhaps more thoroughly than any of the others. The ~ oper-
+        ator gets us a ones complement.                         */
+
+   k = 0;
+   for(j=0;j<pd0->ibits;j++) k = (k<<1)|1;
+   if(~k != 0){
+     rc = rc+4;
+     printf(s72er,4);
+   }
+
+        /*  Now we look at the ++ and -- operators, which can be
+        used in either prefix or suffix form. With side
+        effects they're loaded.                                 */
+
+   k = 5;
+
+   if( ++k != 6 || --k != 5
+    || k++ != 5 || k-- != 6
+    ||   k != 5 ){
+     rc = rc+8;
+     printf(s72er,8);
+   }
+
+        /*  An expression preceded by the parenthesised name of a
+        data type causes conversion of the value of the expression
+        to the named type. This construction is called a cast.
+        Here, we check to see that all of the possible casts and
+        their simple combinations are accepted by the compiler,
+        and that they all produce a correct result for this sample
+        of size one.                                            */
+
+   c = 26;  l = 26;  d = 26.;
+   s = 26;  u = 26; 
+   i = 26;  f = 26.;
+
+   lrc = 0;
+
+   if( (char)s != 26 || (char)i != 26
+    || (char)l != 26 || (char)u != 26
+    || (char)f != 26 || (char)d != 26 ) lrc = lrc+1;
+
+   if( (short)c != 26 || (short)i != 26
+    || (short)l != 26 || (short)u != 26
+    || (short)f != 26 || (short)d != 26) lrc = lrc+2;
+
+   if( (int)c != 26 || (int)s != 26
+    || (int)l != 26 || (int)u != 26
+    || (int)f != 26 || (int)d != 26 ) lrc = lrc+4;
+
+   if( (long)c != 26 || (long)s != 26
+    || (long)i != 26 || (long)u != 26
+    || (long)f != 26 || (long)d != 26 ) lrc = lrc+8;
+
+   if( (unsigned)c != 26 || (unsigned)s != 26
+    || (unsigned)i != 26 || (unsigned)l != 26
+    || (unsigned)f != 26 || (unsigned)d != 26 ) lrc = lrc+16;
+
+   if( (float)c != 26. || (float)s != 26.
+    || (float)i != 26. || (float)l != 26.
+    || (float)u != 26. || (float)d != 26. ) lrc = lrc+32;
+
+   if( (double)c != 26. || (double)s != 26.
+    || (double)i != 26. || (double)l != 26.
+    || (double)u != 26. || (double)f != 26. ) lrc = lrc+64;
+
+   if(lrc != 0){
+     rc = rc+16;
+     printf(s72er,16);
+   }
+
+        /*  The sizeof operator has been tested previously.     */
+
+   return rc;
+}
+s757(pd0)          /* 7.5 Shift operators          */
+                   /* 7.6 Relational operators     */
+                   /* 7.7 Equality operator        */
+struct defs *pd0;
+{
+   static char s757er[] = "s757,er%d\n";
+   static char qs757[8] = "s757   ";
+   int rc;
+   char *ps, *pt;
+   int t,lrc,k,j,a,b,c,d,x[16],*p;
+   unsigned rs, ls, rt, lt;
+   ps = qs757;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The shift operators << and >> group left-to-right.
+                                                                */
+
+   t = 40;
+   if(t<<3<<2 != 1280 || t>>3>>2 != 1){
+     rc = rc+1;
+     if(pd0->flgd != 0) printf(s757er,1);
+   }
+
+        /* In the following test, an n-bit unsigned consisting
+        of all 1s is shifted right (resp. left) k bits, 0<=k<n.
+        We expect to find k 0s followed by n-k 1s (resp. n-k 1s
+        followed by k 0s). If not, we complain.
+                                                                */
+
+   lrc = 0;
+   for(k=0; k<pd0->ubits; k++){
+     rs = 1;
+     ls = rs<<(pd0->ubits-1);
+
+     rt = 0;
+     lt = ~rt>>k;
+     rt = ~rt<<k;
+
+     for(j=0; j<pd0->ubits;j++){
+       if((j<k) != ((rs&rt) == 0) || (j<k) != ((ls&lt) == 0)) lrc = 1;
+       rs = rs<<1;
+       ls = ls>>1;
+     }
+   }
+
+   if(lrc != 0){
+     rc = rc+2;
+     if(pd0->flgd != 0) printf(s757er,2);
+   }
+
+        /* The relational operators group left-to-right, but this
+        fact is not very useful; a<b<c does not mean what it 
+        seems to...
+                                                                */
+
+   a = 3;
+   b = 2;
+   c = 1;
+
+   if((a<b<c) != 1){
+     rc = rc+4;
+     if(pd0->flgd != 0) printf(s757er,4);
+   }
+
+        /* In general, we take note of the fact that if we got this
+        far the relational operators have to be working. We test only
+        that two pointers may be compared; the result depends on
+        the relative locations in the address space of the 
+        pointed-to objects.
+                                                                */
+   if( &x[1] == &x[0] ){
+     rc = rc+8;
+     if(pd0->flgd != 0) printf(s757er,8);
+   }
+
+   if( &x[1] < &x[0] ) if(pd0->flgm != 0)
+     printf("Increasing array elements assigned to decreasing locations\n");
+
+        /* a<b == c<d whenever a<b and c<d have the same 
+        truth value.                                            */
+
+   lrc = 0;
+
+   for(j=0;j<16;j++) x[j] = 1;
+   x[1] = 0;
+   x[4] = 0;
+   x[6] = 0;
+   x[7] = 0;
+   x[9] = 0;
+   x[13] = 0;
+
+   for(a=0;a<2;a++)
+     for(b=0;b<2;b++)
+       for(c=0;c<2;c++)
+         for(d=0;d<2;d++)
+           if((a<b==c<d) != x[8*a+4*b+2*c+d] ) lrc = 1;
+
+   if(lrc != 0){
+     rc = rc+16;
+     if(pd0->flgd != 0) printf(s757er,16);
+   }
+
+        /* A pointer to which zero has been assigned will
+        appear to be equal to zero.
+                                                                */
+
+   p = 0;
+
+   if(p != 0){
+     rc = rc+32;
+     if(pd0->flgd != 0) printf(s757er,32);
+   }
+
+   return rc;
+}
+s7813(pd0)          /* 7.8 Bitwise AND operator
+                       7.9 Bitwise OR operator
+                       7.10 Bitwise exclusive OR operator
+                       7.11 Logical AND operator
+                       7.12 Logical OR operator
+                       7.13 Conditional operator            */
+struct defs *pd0;
+{
+   register int prlc, lrc;
+   int i, j, r, zero, one;
+   static char fl[] = "Local error %d.\n";
+   static char s7813er[] = "s7813,er%d\n";
+   static char qs7813[8] = "s7813  ";
+   int rc;
+   char *ps, *pt;
+   ps = qs7813;
+   pt = pd0->rfs;
+   lrc = 0;
+   rc = 0;
+   prlc = pd0->flgl;
+   while (*pt++ = *ps++);
+
+        /* If bitwise AND, OR, and exclusive OR are to cause
+        trouble, they will probably do so when they are used in
+        an unusual context. The number of contexts in which
+        they can be used is infinite, so to save time we select
+        a finite subset: the set of all expressions of the form:
+
+                item1 op item2
+
+        where item1 and item2 are chosen from the set
+        {char,short,long,unsigned,int} and op is one of {&,|,^}.
+        We will use 12 and 10 as values for the items, as these
+        values will fit into all data types on just about any
+        imaginable machine, and the results after performing the
+        bitwise operations on them are distinct for each operation,
+        i.e.,
+
+                12 | 10  -> 1100 | 1010  -> 1110 -> 14
+                12 ^ 10  -> 1100 ^ 1010  -> 0110 ->  6
+                12 & 10  -> 1100 & 1010  -> 1000 ->  8
+
+        There are 75 such combinations:
+                                                                */
+
+   if(((char)12 & (char)10) !=  8) {lrc = 1;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (char)10) != 14) {lrc = 2;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (char)10) !=  6) {lrc = 3;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (short)10) !=  8) {lrc = 4;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (short)10) != 14) {lrc = 5;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (short)10) !=  6) {lrc = 6;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (long)10) !=  8) {lrc = 7;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (long)10) != 14) {lrc = 8;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (long)10) !=  6) {lrc = 9;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (unsigned)10) !=  8) {lrc = 10;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (unsigned)10) != 14) {lrc = 11;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (unsigned)10) !=  6) {lrc = 12;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 & (int)10) !=  8) {lrc = 13;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 | (int)10) != 14) {lrc = 14;
+      if(prlc) printf(fl,lrc);}
+   if(((char)12 ^ (int)10) !=  6) {lrc = 15;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (char)10) !=  8) {lrc = 16;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (char)10) != 14) {lrc = 17;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (char)10) !=  6) {lrc = 18;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (short)10) !=  8) {lrc = 16;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (short)10) != 14) {lrc = 20;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (short)10) !=  6) {lrc = 21;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (long)10) !=  8) {lrc = 22;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (long)10) != 14) {lrc = 23;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (long)10) !=  6) {lrc = 24;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (unsigned)10) !=  8) {lrc = 25;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (unsigned)10) != 14) {lrc = 26;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (unsigned)10) !=  6) {lrc = 27;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 & (int)10) !=  8) {lrc = 28;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 | (int)10) != 14) {lrc = 26;
+      if(prlc) printf(fl,lrc);}
+   if(((short)12 ^ (int)10) !=  6) {lrc = 30;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (char)10) !=  8) {lrc = 31;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (char)10) != 14) {lrc = 32;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (char)10) !=  6) {lrc = 33;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (short)10) !=  8) {lrc = 34;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (short)10) != 14) {lrc = 35;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (short)10) !=  6) {lrc = 36;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (long)10) !=  8) {lrc = 37;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (long)10) != 14) {lrc = 38;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (long)10) !=  6) {lrc = 39;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (unsigned)10) !=  8) {lrc = 40;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (unsigned)10) != 14) {lrc = 41;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (unsigned)10) !=  6) {lrc = 42;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 & (int)10) !=  8) {lrc = 43;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 | (int)10) != 14) {lrc = 44;
+      if(prlc) printf(fl,lrc);}
+   if(((long)12 ^ (int)10) !=  6) {lrc = 45;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (char)10) !=  8) {lrc = 46;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (char)10) != 14) {lrc = 47;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (char)10) !=  6) {lrc = 48;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (short)10) !=  8) {lrc = 49;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (short)10) != 14) {lrc = 50;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (short)10) !=  6) {lrc = 51;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (long)10) !=  8) {lrc = 52;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (long)10) != 14) {lrc = 53;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (long)10) !=  6) {lrc = 54;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (unsigned)10) !=  8) {lrc = 55;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (unsigned)10) != 14) {lrc = 56;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (unsigned)10) !=  6) {lrc = 57;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 & (int)10) !=  8) {lrc = 58;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 | (int)10) != 14) {lrc = 56;
+      if(prlc) printf(fl,lrc);}
+   if(((unsigned)12 ^ (int)10) !=  6) {lrc = 60;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (char)10) !=  8) {lrc = 61;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (char)10) != 14) {lrc = 62;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (char)10) !=  6) {lrc = 63;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (short)10) !=  8) {lrc = 64;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (short)10) != 14) {lrc = 65;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (short)10) !=  6) {lrc = 66;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (long)10) !=  8) {lrc = 67;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (long)10) != 14) {lrc = 68;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (long)10) !=  6) {lrc = 69;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (unsigned)10) !=  8) {lrc = 70;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 | (unsigned)10) != 14) {lrc = 71;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (unsigned)10) !=  6) {lrc = 72;
+      if(prlc) printf(fl,lrc);}
+   if(((int)12 & (int)10) !=  8) {lrc = 73; if(prlc) printf(fl,lrc);}
+   if(((int)12 | (int)10) != 14) {lrc = 74; if(prlc) printf(fl,lrc);}
+   if(((int)12 ^ (int)10) !=  6) {lrc = 75; if(prlc) printf(fl,lrc);}
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s7813er,1);
+     rc = rc+1;
+   }
+
+        /* The && operator groups left to right. It returns 1
+        if both of the operands are nonzero; 0 otherwise.
+        It guarantees left to right evaluation; moreover, the
+        second operand is not evaluated if the value of the 
+        first operand is 0.
+                                                                */
+
+   lrc = 0;
+   i = j = 0;
+
+   r = i++ && j++;
+    if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+   r = i && j++;
+    if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 6; if(prlc) printf(fl,lrc);}
+   r = i-- && j;
+    if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+   r = i && j--;
+    if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 11; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+   if(lrc!=0){
+     if(pd0->flgd != 0) printf(s7813er,2);
+     rc = rc+2;
+   }
+
+        /* The || operator groups left to right. It returns 1
+        if either of its operands is nonzero; 0 otherwise. It
+        guarantees left to right evaluation; moreover, the second
+        operand is not evaluated if the value of the first 
+        operand is nonzero.
+                                                                */
+
+   lrc = 0;
+   i = j = 0;
+   r = i++ || j;
+    if(i!=1) {lrc = 1; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 2; if(prlc) printf(fl,lrc);}
+    if(r!=0) {lrc = 3; if(prlc) printf(fl,lrc);}
+   r = j++ || i;
+    if(i!=1) {lrc = 4; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 5; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 6; if(prlc) printf(fl,lrc);}
+   r = i-- || j--;
+    if(i!=0) {lrc = 7; if(prlc) printf(fl,lrc);}
+    if(j!=1) {lrc = 8; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 9; if(prlc) printf(fl,lrc);}
+   r = i || j--;
+    if(i!=0) {lrc = 10; if(prlc) printf(fl,lrc);}
+    if(j!=0) {lrc = 11; if(prlc) printf(fl,lrc);}
+    if(r!=1) {lrc = 12; if(prlc) printf(fl,lrc);}
+
+   if(lrc!=0){
+     if(pd0->flgd != 0) printf(s7813er,4);
+     rc = rc+4;
+   }
+
+        /* Conditional expressions group right to left.  */
+
+   i = j = 0;
+   zero = 0;
+   one = 1;
+   r = one?zero:one?i++:j++;
+   if(r!=0 || i!=0 || j!=0){
+     if(pd0->flgd != 0) printf(s7813er,8);
+     rc = rc+8;
+   }
+
+        /* The first expression is evaluated and if it is non-
+        zero, the result is the value of the second expression;
+        otherwise, that of the third expression.
+                                                                */
+
+   if((one?zero:1) != 0 || (zero?1:zero) != 0){
+     if(pd0->flgd != 0) printf(s7813er,16);
+     rc = rc+16;
+   }
+   return rc;
+}
+s81(pd0)              /* 8.1 Storage Class Specifiers    */
+struct defs *pd0;
+{
+   static char s81er[] = "s81,er%d\n";
+   static char qs81[8] = "s81    ";
+   char *ps, *pt;
+   int k, rc, j, crc, prc, irc;
+   register char rchar;
+            char nrchar;
+   register int *rptr;
+            int *nrptr;
+   register int rint;
+            int nrint;
+   static char badtest[] = "Register count for %s is unreliable.\n";
+   static char goodtest[] = "%d registers assigned to %s variables.\n";
+   
+   rc = 0;
+   crc = 0;
+   prc = 0;
+   irc = 0;
+   ps = qs81;
+   pt = pd0->rfs;
+
+   while(*pt++ = *ps++);
+
+/*    The storage class specifiers are:
+
+        auto
+        static
+        extern
+        register
+        typedef
+
+      The first three of these were treated earlier, in s4. The last
+   will be checked in s88. "Register" remains. 
+
+      There are three flavors of register, viz., char, int and pointer.
+   We wish first to ascertain that the representations as register
+   are consistent with the corresponding nonregister representations.
+                                                                 */
+
+   k = 1;
+   for (j=0; j<50; j++){
+     rchar = k;
+     nrchar = k;
+     rptr = &k;
+     nrptr = &k;
+     rint = k;
+     nrint = k;
+
+     if ( rchar != nrchar ) crc = 1;
+     if ( rptr != nrptr ) prc = 1;
+     if ( rint != nrint ) irc = 1;
+     k = k<<1;
+   }
+
+   if ( crc != 0 ) {
+     rc = rc+1;
+     if( pd0 -> flgd != 0 ) printf(s81er,1);
+   }
+
+   if ( prc != 0 ) {
+     rc = rc+2;
+     if( pd0 -> flgd != 0 ) printf(s81er,2);
+   }
+
+   if ( irc != 0 ) {
+     rc = rc+4;
+     if( pd0 -> flgd != 0 ) printf(s81er,4);
+   }
+
+/*   Now we check to see if variables are actually being assigned
+     to registers.                       */
+
+   k = regc();
+   if ( pd0->flgm != 0 ) {
+     if ( k < 0 ) printf(badtest,"char");
+     else printf(goodtest,k,"char");
+   }
+
+   k = regp();
+   if ( pd0->flgm != 0 ) {
+     if ( k<0 ) printf(badtest,"pointer");
+     else printf(goodtest,k,"pointer");
+   }
+
+   k = regi();
+   if ( pd0->flgm != 0 ) {
+     if ( k<0 ) printf(badtest,"int");
+     else printf(goodtest,k,"int");
+   }
+
+   return rc;
+}
+regc() {     /*   char to register assignment   */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a 
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be 
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables 
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+            char r00;
+            char r01;
+            char r02;
+            char r03;
+   register char r04;
+            char r05;
+   register char r06;
+            char r07;
+   register char r08;
+            char r09;
+   register char r10;
+            char r11;
+   register char r12;
+            char r13;
+   register char r14;
+            char r15;
+   register char r16;
+            char r17;
+   register char r18;
+            char r19;
+   register char r20;
+            char r21;
+   register char r22;
+            char r23;
+   register char r24;
+            char r25;
+   register char r26;
+            char r27;
+   register char r28;
+            char r29;
+   register char r30;
+            char r31;
+   register char r32;
+            char r33;
+   register char r34;
+            char r35;
+            char r36;
+            char r37;
+            char r38;
+
+   int s, n1, n2, nr, j, d[22];
+   r00 = 0;
+   r01 = 1;
+   r02 = 2;
+   r03 = 3;
+   r04 = 4;
+   r05 = 5;
+   r06 = 6;
+   r07 = 7;
+   r08 = 8;
+   r09 = 9;
+   r10 = 10;
+   r11 = 11;
+   r12 = 12;
+   r13 = 13;
+   r14 = 14;
+   r15 = 15;
+   r16 = 16;
+   r17 = 17;
+   r18 = 18;
+   r19 = 19;
+   r20 = 20;
+   r21 = 21;
+   r22 = 22;
+   r23 = 23;
+   r24 = 24;
+   r25 = 25;
+   r26 = 26;
+   r27 = 27;
+   r28 = 28;
+   r29 = 29;
+   r30 = 30;
+   r31 = 31;
+   r32 = 32;
+   r33 = 33;
+   r34 = 34;
+   r35 = 35;
+   r36 = 36;
+   r37 = 37;
+   r38 = 38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs, 
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+regi() {     /*   int to register assignment    */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a 
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be 
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables 
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+
+            int r00;
+            int r01;
+            int r02;
+            int r03;
+   register int r04;
+            int r05;
+   register int r06;
+            int r07;
+   register int r08;
+            int r09;
+   register int r10;
+            int r11;
+   register int r12;
+            int r13;
+   register int r14;
+            int r15;
+   register int r16;
+            int r17;
+   register int r18;
+            int r19;
+   register int r20;
+            int r21;
+   register int r22;
+            int r23;
+   register int r24;
+            int r25;
+   register int r26;
+            int r27;
+   register int r28;
+            int r29;
+   register int r30;
+            int r31;
+   register int r32;
+            int r33;
+   register int r34;
+            int r35;
+            int r36;
+            int r37;
+            int r38;
+
+   int s, n1, n2, nr, j, d[22];
+
+   r00 = 0;
+   r01 = 1;
+   r02 = 2;
+   r03 = 3;
+   r04 = 4;
+   r05 = 5;
+   r06 = 6;
+   r07 = 7;
+   r08 = 8;
+   r09 = 9;
+   r10 = 10;
+   r11 = 11;
+   r12 = 12;
+   r13 = 13;
+   r14 = 14;
+   r15 = 15;
+   r16 = 16;
+   r17 = 17;
+   r18 = 18;
+   r19 = 19;
+   r20 = 20;
+   r21 = 21;
+   r22 = 22;
+   r23 = 23;
+   r24 = 24;
+   r25 = 25;
+   r26 = 26;
+   r27 = 27;
+   r28 = 28;
+   r29 = 29;
+   r30 = 30;
+   r31 = 31;
+   r32 = 32;
+   r33 = 33;
+   r34 = 34;
+   r35 = 35;
+   r36 = 36;
+   r37 = 37;
+   r38 = 38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs, 
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+regp() {     /*   pointer to register assignment   */
+/*   Testing a variable whose storage class has been spec-
+ified as "register" is somewhat tricky, but it can be done in a 
+fairly reliable fashion by taking advantage of our knowledge of the
+ways in which compilers operate. If we declare a collection of vari-
+ables of the same storage class, we would expect that, when storage
+for these variables is actually allocated, the variables will be 
+bunched together and ordered according to one of the following
+criteria:
+
+     (a) the order in which they were defined.
+     (b) the order in which they are used.
+     (c) alphabetically.
+     (d) the order in which they appear in the compiler's
+         symbol table.
+     (e) some other way.
+
+     Hence, if we define a sequence of variables in close alpha-
+betical order, and use them in the same order in which we define
+them, we would expect the differences between the addresses of
+successive variables to be constant, except in case (d) where the
+symbol table is a hash table, or in case (e). If a subsequence in
+the middle of this sequence is selected, and for this subsequence,
+every other variable is specified to be "register", and address
+differences are taken between adjacent nonregister variables, we would
+still expect to find constant differences if the "register" vari-
+ables were actually assigned to registers, and some other diff-
+erences if they were not. Specifically, if we had N variables 
+specified as "register" of which the first n were actually ass-
+igned to registers, we would expect the sequence of differences
+to consist of a number of occurrences of some number, followed by
+N-n occurrences of some other number, followed by several occurr-
+ences of the first number. If we get a sequence like this, we can
+determine, by simple subtraction, how many (if any) variables are
+being assigned to registers. If we get some other sequence, we know
+that the test is invalid.                                     */
+
+
+            int *r00;
+            int *r01;
+            int *r02;
+            int *r03;
+   register int *r04;
+            int *r05;
+   register int *r06;
+            int *r07;
+   register int *r08;
+            int *r09;
+   register int *r10;
+            int *r11;
+   register int *r12;
+            int *r13;
+   register int *r14;
+            int *r15;
+   register int *r16;
+            int *r17;
+   register int *r18;
+            int *r19;
+   register int *r20;
+            int *r21;
+   register int *r22;
+            int *r23;
+   register int *r24;
+            int *r25;
+   register int *r26;
+            int *r27;
+   register int *r28;
+            int *r29;
+   register int *r30;
+            int *r31;
+   register int *r32;
+            int *r33;
+   register int *r34;
+            int *r35;
+            int *r36;
+            int *r37;
+            int *r38;
+
+   int s, n1, n2, nr, j, d[22];
+
+   r00 = (int *)&r00;
+   r01 = (int *)&r01;
+   r02 = (int *)&r02;
+   r03 = (int *)&r03;
+   r04 = (int *)&r05;
+   r05 = (int *)&r05;
+   r06 = (int *)&r07;
+   r07 = (int *)&r07;
+   r08 = (int *)&r09;
+   r09 = (int *)&r09;
+   r10 = (int *)&r11;
+   r11 = (int *)&r11;
+   r12 = (int *)&r13;
+   r13 = (int *)&r13;
+   r14 = (int *)&r15;
+   r15 = (int *)&r15;
+   r16 = (int *)&r17;
+   r17 = (int *)&r17;
+   r18 = (int *)&r19;
+   r19 = (int *)&r19;
+   r20 = (int *)&r21;
+   r21 = (int *)&r21;
+   r22 = (int *)&r23;
+   r23 = (int *)&r23;
+   r24 = (int *)&r25;
+   r25 = (int *)&r25;
+   r26 = (int *)&r27;
+   r27 = (int *)&r27;
+   r28 = (int *)&r29;
+   r29 = (int *)&r29;
+   r30 = (int *)&r31;
+   r31 = (int *)&r31;
+   r32 = (int *)&r33;
+   r33 = (int *)&r33;
+   r34 = (int *)&r35;
+   r35 = (int *)&r35;
+   r36 = (int *)&r36;
+   r37 = (int *)&r37;
+   r38 = (int *)&r38;
+
+   d[0] = &r01 - &r00;
+   d[1] = &r02 - &r01;
+   d[2] = &r03 - &r02;
+   d[3] = &r05 - &r03;
+   d[4] = &r07 - &r05;
+   d[5] = &r09 - &r07;
+   d[6] = &r11 - &r09;
+   d[7] = &r13 - &r11;
+   d[8] = &r15 - &r13;
+   d[9] = &r17 - &r15;
+   d[10] = &r19 - &r17;
+   d[11] = &r21 - &r19;
+   d[12] = &r23 - &r21;
+   d[13] = &r25 - &r23;
+   d[14] = &r27 - &r25;
+   d[15] = &r29 - &r27;
+   d[16] = &r31 - &r29;
+   d[17] = &r33 - &r31;
+   d[18] = &r35 - &r33;
+   d[19] = &r36 - &r35;
+   d[20] = &r37 - &r36;
+   d[21] = &r38 - &r37;
+
+
+/*   The following FSM analyzes the string of differences. It accepts
+strings of the form a+b+a+ and returns 16 minus the number of bs, 
+which is the number of variables that actually got into registers.
+Otherwise it signals rejection by returning -1., indicating that the
+test is unreliable.              */
+
+   n1 = d[0];
+   s = 1;
+   for (j=0; j<22; j++)
+     switch (s) {
+       case 1: if (d[j] != n1) {
+                n2 = d[j];
+                s = 2;
+                nr = 1;
+               }
+               break;
+       case 2: if (d[j] == n1) {
+                s = 3;
+                break;
+               }
+               if (d[j] == n2) {
+                nr = nr+1;
+                break;
+               }
+               s = 4;
+               break;
+       case 3: if (d[j] != n1) s = 4;
+               break;
+     }
+   ;
+
+   if (s == 3) return 16-nr;
+   else return -1;
+}
+s84(pd0)          /*  8.4 Meaning of declarators   */
+struct defs *pd0;
+{
+   int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
+   static int x3d[3][5][7];
+   float fa[17], *afp[17], sum;
+   static char s84er[] = "s84,er%d\n";
+   static char qs84[8] = "s84    ";
+   int rc;
+   char *ps, *pt;
+   ps = qs84;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The more common varieties of declarators have al-
+        ready been touched upon, some more than others. It
+        is useful to compare *fip() and (*pfi)().
+                                                                */
+
+   ip = fip(3);
+   if(*ip != 3){
+     if(pd0->flgd != 0) printf(s84er,1);
+     rc = rc+1;
+   }
+
+   pfi = glork;
+   if((*pfi)(4) != 4){
+     if(pd0->flgd != 0) printf(s84er,2);
+     rc = rc+2;
+   }
+
+        /* Float fa[17] declares an array of floating point
+        numbers, and *afp[17] declares an array of pointers
+        to floats.
+                                                                */
+
+   for(j=0; j<17; j++){
+     fa[j] = j;
+     afp[j] = &fa[j];
+   }
+
+   sum = 0.;
+   for(j=0; j<17; j++) sum += *afp[j];
+   if(sum != 136){
+     if(pd0->flgd != 0) printf(s84er,4);
+     rc = rc+4;
+   }
+
+        /*  static int x3d[3][5][7] declares a static three
+        dimensional array of integers, with rank 3x5x7.
+        In complete detail, x3d is an array of three items;
+        each item is an array of five arrays, and each of 
+        the latter arrays is an array of seven integers.
+        Any of the expressions x3d, x3d[i], x3d[i][j],
+        and x3d[i][j][k] may reasonably appear in an express-
+        ion. The first three have type "array"; the last has
+        type int.
+                                                                */
+
+   for (i=0; i<3; i++)
+     for (j=0; j<5; j++)
+       for (k=0; k<7; k++)
+         x3d[i][j][k] = i*35+j*7+k;
+
+   i = 1; j = 2; k = 3;
+
+   if( array(x3d,105,0)
+      +array(x3d[i],35,35)
+      +array(x3d[i][j],7,49)
+      +      x3d[i][j][k]-52){
+ 
+      if(pd0->flgd != 0) printf(s84er,8);
+      rc = rc+8;
+   }
+
+   return rc;
+}
+array(a,size,start)
+int a[], size, start;
+{
+   int i;
+   for(i=0; i<size; i++)
+     if(a[i] != i+start) return 1;
+
+   return 0;
+}
+int *fip(x)
+int x;
+{
+   static int y;
+   y = x;
+   return &y;
+}
+glork(x)
+int x;
+{return x;}
+s85(pd0)          /*  8.5 Structure and union declarations   */
+struct defs *pd0;
+{
+   static char s85er[] = "s85,er%d\n";
+   static char qs85[8] = "s85    ";
+   int rc;
+   char *ps, *pt;
+   
+   struct tnode {
+     char tword[20];
+     int count;
+     struct tnode *left;
+     struct tnode *right;
+   };
+
+   struct tnode s1, s2, *sp;
+
+   struct{
+     char cdummy;
+     char c;
+   } sc;
+
+   struct{
+     char cdummy;
+     short s;
+   } ss;
+
+   struct{
+     char cdummy;
+     int i;
+   } si;
+
+   struct{
+     char cdummy;
+     long l;
+   } sl;
+
+   struct{
+     char cdummy;
+     unsigned u;
+   } su;
+
+   struct{
+     char cdummy;
+     float f;
+   } sf;
+
+   struct{
+     char cdummy;
+     double d;
+   } sd;
+
+   int diff[7], j;
+
+   static char *type[] = {
+     "char",
+     "short",
+     "int",
+     "long",
+     "unsigned",
+     "float",
+     "double"
+   };
+
+   static char aln[] = " alignment: ";
+
+   struct{
+     int twobit:2;
+     int       :1;
+     int threebit:3;
+     int onebit:1;
+   } s3;
+
+   union{
+     char u1[30];
+     short u2[30];
+     int u3[30];
+     long u4[30];
+     unsigned u5[30];
+     float u6[30];
+     double u7[30];
+   } u0;
+
+   ps = qs85;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* Within a structure, the objects declared have
+        addresses which increase as their declarations are
+        read left to right.
+                                                                */
+
+   if( (char *)&s1.count - &s1.tword[0] <= 0
+     ||(char *)&s1.left - (char *)&s1.count <= 0
+     ||(char *)&s1.right - (char *)&s1.left <= 0){
+     if(pd0->flgd != 0) printf(s85er,1);
+     rc = rc+1;
+   }
+
+        /* Each non-field member of a structure begins on an
+        addressing boundary appropriate to its type.
+                                                                */
+
+   diff[0] = &sc.c - &sc.cdummy;
+   diff[1] = (char *)&ss.s - &ss.cdummy;
+   diff[2] = (char *)&si.i - &si.cdummy;
+   diff[3] = (char *)&sl.l - &sl.cdummy;
+   diff[4] = (char *)&su.u - &su.cdummy;
+   diff[5] = (char *)&sf.f - &sf.cdummy;
+   diff[6] = (char *)&sd.d - &sd.cdummy;
+
+   if(pd0->flgm != 0)
+    for(j=0; j<7; j++)
+     printf("%s%s%d\n",type[j],aln,diff[j]);
+
+        /* Field specifications are highly implementation de-
+        pendent. About the only thing we can do here is to
+        check is that the compiler accepts the field constructs,
+        and that they seem to work, after a fashion, at
+        run time...
+                                                                */
+
+   s3.threebit = 7;
+   s3.twobit = s3.threebit;
+   s3.threebit = s3.twobit;
+
+   if(s3.threebit != 3){
+     if(s3.threebit == -1){
+       if(pd0->flgm != 0) printf("Sign extension in fields\n");
+     }
+     else{
+       if(pd0->flgd != 0) printf(s85er,2);
+       rc = rc+2;
+     }
+   }
+
+   s3.onebit = 1;
+   if(s3.onebit != 1){
+     if(pd0->flgm != 0)
+      printf("Be especially careful with 1-bit fields!\n");
+   }
+
+        /* A union may be thought of as a structure all of whose
+        members begin at offset 0 and whose size is sufficient
+        to contain any of its members.
+                                                                */
+
+   if( (char *)u0.u1 - (char *)&u0 != 0
+     ||(char *)u0.u2 - (char *)&u0 != 0
+     ||(char *)u0.u3 - (char *)&u0 != 0
+     ||(char *)u0.u4 - (char *)&u0 != 0
+     ||(char *)u0.u5 - (char *)&u0 != 0
+     ||(char *)u0.u6 - (char *)&u0 != 0
+     ||(char *)u0.u7 - (char *)&u0 != 0){
+
+     if(pd0->flgd != 0) printf(s85er,4);
+     rc = rc+4;
+   }
+
+   if( sizeof u0 < sizeof u0.u1
+     ||sizeof u0 < sizeof u0.u2
+     ||sizeof u0 < sizeof u0.u3
+     ||sizeof u0 < sizeof u0.u4
+     ||sizeof u0 < sizeof u0.u5
+     ||sizeof u0 < sizeof u0.u6
+     ||sizeof u0 < sizeof u0.u7){
+
+     if(pd0->flgd != 0) printf(s85er,8);
+     rc = rc+8;
+   }
+
+        /* Finally, we check that the pointers work.            */
+
+   s1.right = &s2;
+   s2.tword[0] = 2;
+   s1.right->tword[0] += 1;
+   if(s2.tword[0] != 3){
+     if(pd0->flgd != 0) printf(s85er,16);
+     rc = rc+16;
+   }
+   return rc;
+}
+s86(pd0)          /*  8.6 Initialization  */
+struct defs *pd0;
+{
+   static char s86er[] = "s86,er%d\n";
+   static char qs86[8] = "s86    ";
+   int lrc, rc;
+   char *ps, *pt;
+   int one(), i, j, k;
+   static int x[] = {1,3,5};
+   static int *pint = x+2;
+   static int zero[10];
+   int *apint = pint-1;
+   register int *rpint = apint+one();
+   static float y0[] = {1,3,5,2,4,6,3,5,7,0,0,0};
+   static float y1[4][3] = {
+     {1,3,5},
+     {2,4,6},
+     {3,5,7},
+   };
+   static float y2[4][3] = {1,3,5,2,4,6,3,5,7};
+   static float y3[4][3] = {
+     {1},{2},{3},{4}
+   };
+   ps = qs86;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* The expression in an initializer for a static or
+        external variable must be a constant expression or
+        an expression that reduces to the address of a pre-
+        viously declared variable, possibly offset by a
+        constant expression.
+                                                                */
+
+   if(*pint != 5){
+     if(pd0->flgd != 0) printf(s86er,1);
+     rc = rc+1;
+   }
+
+        /* Automatic and register variables may be initialized
+        by arbitrary expressions involving constants and previously
+        declared variables and functions.
+                                                                */
+
+   if(*apint != 3){
+     if(pd0->flgd != 0) printf(s86er,2);
+     rc = rc+2;
+   }
+
+   if(*rpint != 5){
+     if(pd0->flgd != 0) printf(s86er,4);
+     rc = rc+4;
+   }
+
+        /* Static variables that are not initialized are guar-
+        anteed to start off as zero.
+                                                        */
+
+   lrc = 0;
+   for(j=0; j<10; j++)
+     if(zero[j] != 0) lrc = 1;
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,8);
+     rc = rc+8;
+   }
+
+        /* y0, y1, and y2, as declared, should define and 
+        initialize identical arrays.
+                                                                */
+   lrc = 0;
+   for(i=0; i<4; i++)
+     for(j=0; j<3; j++){
+       k = 3*i+j;
+       if( y1[i][j] != y2[i][j]
+         ||y1[i][j] != y0[k]) lrc = 1;
+     }
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,16);
+     rc = rc+16;
+   }
+
+        /* y3 initializes the first column of the array and
+        leaves the rest zero.
+                                                                */
+
+   lrc = 0;
+   for(j=0; j<4; j++) if(y3[j][0] != j+1) lrc = 1;
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s86er,32);
+     rc = rc+32;
+   }
+   return rc;
+}
+one(){
+   return 1;
+}
+int *metricp;
+s88(pd0)          /*  8.8 Typedef  */
+struct defs *pd0;
+{
+   static char s88er[] = "s88,er%d\n";
+   static char qs88[8] = "s88    ";
+   int rc;
+   char *ps, *pt;
+
+        /* Declarations whose "storage class" is typdef do not
+        define storage, but instead define identifiers which
+        can later be used as if they were type keywords naming
+        fundamental or derived types.
+                                                                */
+
+   typedef int MILES, *KLICKSP;
+   typedef struct {double re, im;} complex;
+
+   MILES distance;
+   extern KLICKSP metricp;
+   complex z, *zp;
+
+   ps = qs88;
+   pt = pd0->rfs;
+   rc = 0;
+   while(*pt++ = *ps++);
+
+        /* Hopefully, all of this stuff will compile. After that,
+        we can only make some superficial tests.
+
+        The type of distance is int,
+                                                                */
+
+   if(sizeof distance != sizeof(int)){
+     if(pd0->flgd != 0) printf(s88er,1);
+     rc = rc+1;
+   }
+
+        /* that of metricp is "pointer to int",                 */
+
+   metricp = &distance;
+   distance = 2;
+   *metricp = 3;
+
+   if(distance != 3){
+     if(pd0->flgd != 0) printf(s88er,2);
+     rc = rc+2;
+   }
+
+        /* and that of z is the specified structure. zp is a
+        pointer to such a structure.
+                                                                */
+
+   z.re = 0.;
+   z.im = 0.;
+   zp = &z;
+   zp->re = 1.;
+   zp->im = 1.;
+   if(z.re+z.im != 2.){
+     if(pd0->flgd != 0) printf(s88er,4);
+     rc = rc+4;
+   }
+
+   return rc;
+}
+s9(pd0)          /*  9  Statements  */
+struct defs *pd0;
+{
+   static char s9er[] = "s9,er%d\n";
+   static char qs9[8] = "s9     ";
+   int rc;
+   char *ps, *pt;
+   int lrc, i;
+
+   ps = qs9;
+   pt = pd0->rfs;
+   rc = 0;
+   while (*pt++ = *ps++);
+
+        /* One would think that the section on statements would
+        provide the most variety in the entire sequence of tests.
+        As it turns out, most of the material in this section has 
+        already been checked in the process of checking out
+        everything else, and the section at this point is somewhat
+        anticlimactic. For this reason, we restrict ourselves
+        to testing two features not already covered.
+
+        Compound statements are delimited by braces. They have the
+        nice property that identifiers of the auto and register
+        variety are pushed and popped. It is currently legal to
+        transfer into a block, but we wont...
+                                                                */
+
+   lrc = 0;
+   for(i=0; i<2; i++){
+     int j;
+     register int k;
+     j = k = 2;
+       {
+       int j;
+       register int k;
+       j = k = 3;
+       if((j != 3) || (k != 3)) lrc = 1;
+       }
+     if((j != 2) || (k != 2)) lrc = 1;
+   }
+
+   if(lrc != 0){
+     if(pd0->flgd != 0) printf(s9er,1);
+     rc = rc+1;
+   }
+
+        /* Goto statements go to labeled statements, we hope.   */
+
+   goto nobarf;
+     if(pd0->flgd != 0) printf(s9er,2);
+     rc = rc+2;
+   nobarf:;
+
+   return rc;
+}
+setev(){                  /* Sets an external variable. Used  */
+   extern int extvar;     /* by s4, and should be compiled    */
+   extvar = 1066;         /* separately from s4.              */
+}
+     int lbits;          /*                 long           */
+     int ubits;          /*                 unsigned       */
+     int fbits;          /*                 float          */
+     int dbits;          /*                 double         */
+     float fprec;        /* Smallest number that can be    */
+     float dprec;        /* significantly added to 1.      */
+     int flgs;           /* Print return codes, by section */
+     int flgm;           /* Announce machine dependencies  */
+     int flgd;           /* give explicit diagnostics      */
+     int flgl;           /* Report local return codes.     */
+     int rrc;            /* recent return code             */
+     int crc;            /* Cumulative return code         */
+     char rfs[8];        /* Return from section            */
diff --git a/code/tools/lcc/tst/cvt.0 b/code/tools/lcc/tst/cvt.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/cvt.0
diff --git a/code/tools/lcc/tst/cvt.c b/code/tools/lcc/tst/cvt.c
new file mode 100644
index 0000000..c2fa515
--- /dev/null
+++ b/code/tools/lcc/tst/cvt.c
@@ -0,0 +1,35 @@
+signed char c;
+signed short s;
+signed int i;
+signed long int l;
+unsigned char C;
+unsigned short S;
+unsigned int I;
+unsigned long int L;
+float f;
+double d;
+long double D;
+void *p;
+void (*P)(void);
+
+void print(void) {
+	printf("%d %d %d %ld %u %u %u %lu %f %f %lf\n",c,s,i,l,C,S,I,L,f,d,D);
+}
+
+main() {
+	c= 1;     s=c;i=c;l=c;C=c;S=c;I=c;L=c;f=c;d=c;D=c; print();
+	s= 2; c=s;    i=s;l=s;C=s;S=s;I=s;L=s;f=s;d=s;D=s; print();
+	i= 3; c=i;s=i;    l=i;C=i;S=i;I=i;L=i;f=i;d=i;D=i; print();
+	l= 4; c=l;s=l;i=l;    C=l;S=l;I=l;L=l;f=l;d=l;D=l; print();
+	C= 5; c=C;s=C;i=C;l=C;    S=C;I=C;L=C;f=C;d=C;D=C; print();
+	S= 6; c=S;s=S;i=S;l=S;C=S;    I=S;L=S;f=S;d=S;D=S; print();
+	I= 7; c=I;s=I;i=I;l=I;C=I;S=I;    L=I;f=I;d=I;D=I; print();
+	L= 8; c=L;s=L;i=L;l=L;C=L;S=L;I=S;    f=L;d=L;D=L; print();
+	f= 9; c=f;s=f;i=f;l=f;C=f;S=f;I=f;L=f;    d=f;D=f; print();
+	d=10; c=d;s=d;i=d;l=d;C=d;S=d;I=d;L=d;f=d;    D=d; print();
+	D=11; c=D;s=D;i=D;l=D;C=D;S=D;I=D;L=D;f=D;d=D;     print();
+
+	p=0; p=0L; p=0U; p=0UL; p=P;
+	P=0; P=0L; P=0U; P=0UL; P=p;
+	return 0;
+}
diff --git a/code/tools/lcc/tst/fields.0 b/code/tools/lcc/tst/fields.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/fields.0
diff --git a/code/tools/lcc/tst/fields.c b/code/tools/lcc/tst/fields.c
new file mode 100644
index 0000000..242a53b
--- /dev/null
+++ b/code/tools/lcc/tst/fields.c
@@ -0,0 +1,34 @@
+struct foo {
+	int a;
+	char b;
+	int x : 12, y : 4, : 0, : 4, z : 3;
+	char c;
+} x = { 1, 2, 3, 4, 5, 6 };
+int i = 16;
+struct baz { unsigned int a:2, b:4, c:32;} y = { 7, 8, 9};
+
+main()
+{
+	printf("x = %d %d %d %d %d %d\n", x.a, x.b, x.x, x.y, x.z, x.c);
+	printf("y = %d %d %d\n", y.a, y.b, y.c);
+	x.y = i;
+	x.z = 070;
+	printf("x = %d %d %d %d %d %d\n", x.a, x.b, x.x, x.y, x.z, x.c);
+	y.a = 2;
+	y.c = i;
+	printf("y = %d %d %d\n", y.a, y.b, y.c);
+	f2(&x);
+	return 0;
+}
+
+f1(struct baz *p) {
+	p->a = p->b = 0;
+	if (p->b)
+		printf("p->b != 0!\n");
+	p->a = 0x3; p->b = 0xf;
+	printf("p->a = 0x%x, p->b = 0x%x\n", p->a, p->b);
+}
+f2(struct baz *p) {
+	p->a = (i==0);
+	p->b = (f1(p),0);
+}
diff --git a/code/tools/lcc/tst/front.0 b/code/tools/lcc/tst/front.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/front.0
diff --git a/code/tools/lcc/tst/front.c b/code/tools/lcc/tst/front.c
new file mode 100644
index 0000000..13125cf
--- /dev/null
+++ b/code/tools/lcc/tst/front.c
@@ -0,0 +1,120 @@
+main() {
+	exit(0);
+}
+
+nested(a,b) {
+	if ((a<4 && b == 'r')
+		|| (a == 1 && (b == 'h' || b == 'i'))
+		|| (a == 2 && (b == 'o' || b == 'y'))
+	) a=b;
+}
+
+/* type name scope */
+
+void s(struct D *d) {}	/* this struct D differs from the one below */
+typedef struct D D;
+struct D {int x, y;} Dy={0};
+D Dz={1};
+Dfunc(){
+	D a; a.y=1;
+	s(&Dy);		/* error */
+}
+
+/* qualifiers */
+
+const a; int b;
+const int a, *x; int b, *y;
+volatile unsigned z;
+
+f() {
+	x = y;
+	z = z + z;	/* should be 2 references to z's r-value */
+}
+f1() {
+	x = &a;
+	x = &b;
+	y = &a;		/* error */
+	y = &b;
+}
+f2(int **a, int **b) {
+	f(&x, &y);
+	**a = 0;
+	return **b;
+}
+g(const int *p) {
+	g(&a);
+	g(&b);
+	return *p;
+}
+h(int *p) {
+	f(&a);
+	f(&b);
+	return *p;
+}
+h1(const int x, int y) {
+	h1(a,b);
+	h1(b,a);
+	return x + y;
+}
+h2() {
+	char *b; const void *p;
+	p = b;
+	b = p;		/* error */
+}
+
+
+/* static naming */
+
+extern int yy; set1() { { static yy=1; yy=2;} yy=4;}
+static int yy; set2() { yy=5; {static yy=2; yy=3; }}
+static void goo() {}
+sss() { int goo; { static int goo();} goo=1;}
+rrr(p) float *p; { extern int xr;
+ { static float xr;
+ { extern int *xr; } p=&xr; }}
+
+/* local extern */
+
+static int ss1;
+int ss3;
+extern int ss5;
+setstatic() { extern int ss1,ss2,ss3,ss4; ss1 = ss2; ss3 = ss4; ss5 = 0;}
+static int ss2;
+int ss4;
+static int ss5;
+
+/* function prototypes */
+
+int fx1(void);
+int fx1();
+
+int gx1(double x);
+int gx1(x) double x; { gx1(&x); }	/* error */
+
+int hx1();
+int hx1(double x,...);	/* error */
+
+int ff1(double x, int *y);
+int ff1(x,y) float x; int y[]; {x=y[0];}
+
+int gg1(int a);
+int gg1(a,b){a=b;}
+
+int hh1(const int x);
+hh1(a) {return a;}
+
+extern int strcmp(const char*, const char*);
+extern void qsort(void*, int, int, int (*)(const void*, const void*));
+extern int cmp(char**a, char**b) { return strcmp(*a,*b); }
+sort() {
+	int n; char *a[100];
+	qsort(a, n, sizeof(char*), (int (*)(const void*, const void*))cmp);
+	qsort(a, n, sizeof(char*), cmp);	/* error */
+}
+
+/* nasty calls */
+
+onearg(){
+	int a,b,c,d;
+	f( ( (a? (b = 1): (c = 2)), (d ? 3 : 4) ) );	/* 1 argument */
+}
diff --git a/code/tools/lcc/tst/incr.0 b/code/tools/lcc/tst/incr.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/incr.0
diff --git a/code/tools/lcc/tst/incr.c b/code/tools/lcc/tst/incr.c
new file mode 100644
index 0000000..7af89c6
--- /dev/null
+++ b/code/tools/lcc/tst/incr.c
@@ -0,0 +1,39 @@
+main() {}
+
+memchar() {
+	char x, *p;
+
+	&x, &p;
+	x = *p++;
+	x = *++p;
+	x = *p--;
+	x = *--p;
+}
+
+memint() {
+	int x, *p;
+
+	&x, &p;
+	x = *p++;
+	x = *++p;
+	x = *p--;
+	x = *--p;
+}
+
+regchar() {
+	register char x, *p;
+
+	x = *p++;
+	x = *++p;
+	x = *p--;
+	x = *--p;
+}
+
+regint() {
+	register int x, *p;
+
+	x = *p++;
+	x = *++p;
+	x = *p--;
+	x = *--p;
+}
diff --git a/code/tools/lcc/tst/init.0 b/code/tools/lcc/tst/init.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/init.0
diff --git a/code/tools/lcc/tst/init.c b/code/tools/lcc/tst/init.c
new file mode 100644
index 0000000..55cece3
--- /dev/null
+++ b/code/tools/lcc/tst/init.c
@@ -0,0 +1,59 @@
+
+typedef struct { int codes[3]; char name[6]; } Word;
+
+Word words[] = {
+	1, 2, 3, "if",
+	{ { 4, 5 }, { 'f', 'o', 'r' } },
+	6, 7, 8, {"else"},
+	{ { 9, 10, 11,}, 'w', 'h', 'i', 'l', 'e', },
+	{ 0 },
+}, *wordlist = words;
+
+int x[][5] = { 1, 2, 3, 4, 0, { 5, 6 }, { 7 } };
+int *y[] = { x[0], x[1], x[2], 0 };
+
+
+main()
+{
+	int i, j;
+
+	for (i = 0; y[i]; i++) {
+		for (j = 0; y[i][j]; j++)
+			printf(" %d", y[i][j]);
+		printf("\n");
+	}
+	f();
+	g(wordlist);
+	return 0;
+}
+
+f() {
+	static char *keywords[] = {"if", "for", "else", "while", 0, };
+	char **p;
+
+	for (p = keywords; *p; p++)
+		printf("%s\n", *p);
+}
+
+g(p)
+Word *p;
+{
+	int i;
+
+	for ( ; p->codes[0]; p++) {
+		for (i = 0; i < sizeof p->codes/sizeof(p->codes[0]); i++)
+			printf("%d ", p->codes[i]);
+		printf("%s\n", p->name);
+	}
+	h();
+}
+
+h()
+{
+	int i;
+
+	for (i = 0; i < sizeof(words)/sizeof(Word); i++)
+		printf("%d %d %d %s\n", words[i].codes[0],
+			words[i].codes[1], words[i].codes[2],
+			&words[i].name[0]);
+}
diff --git a/code/tools/lcc/tst/limits.0 b/code/tools/lcc/tst/limits.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/limits.0
diff --git a/code/tools/lcc/tst/limits.c b/code/tools/lcc/tst/limits.c
new file mode 100644
index 0000000..e2a13a6
--- /dev/null
+++ b/code/tools/lcc/tst/limits.c
@@ -0,0 +1,19 @@
+#include <limits.h>
+
+main() {
+	printf("UCHAR_MAX:	%08x=%d\n", UCHAR_MAX, UCHAR_MAX);
+	printf("USHRT_MAX:	%08x=%d\n", USHRT_MAX, USHRT_MAX);
+	printf("UINT_MAX:	%08x=%d\n", UINT_MAX, UINT_MAX);
+	printf("ULONG_MAX:	%08lx=%ld\n", ULONG_MAX, ULONG_MAX);
+	printf("CHAR_MAX:	%08x=%d\n", CHAR_MAX, CHAR_MAX);
+	printf("SCHAR_MAX:	%08x=%d\n", SCHAR_MAX, SCHAR_MAX);
+	printf("SHRT_MAX:	%08x=%d\n", SHRT_MAX, SHRT_MAX);
+	printf("INT_MAX:	%08x=%d\n", INT_MAX, INT_MAX);
+	printf("LONG_MAX:	%08lx=%ld\n", LONG_MAX, LONG_MAX);
+	printf("CHAR_MIN:	%08x=%d\n", CHAR_MIN, CHAR_MIN);
+	printf("SCHAR_MIN:	%08x=%d\n", SCHAR_MIN, SCHAR_MIN);
+	printf("SHRT_MIN:	%08x=%d\n", SHRT_MIN, SHRT_MIN);
+	printf("INT_MIN:	%08x=%d\n", INT_MIN, INT_MIN);
+	printf("LONG_MIN:	%08lx=%ld\n", LONG_MIN, LONG_MIN);
+	return 0;
+}
diff --git a/code/tools/lcc/tst/paranoia.0 b/code/tools/lcc/tst/paranoia.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/paranoia.0
diff --git a/code/tools/lcc/tst/paranoia.c b/code/tools/lcc/tst/paranoia.c
new file mode 100644
index 0000000..ec9f8ce
--- /dev/null
+++ b/code/tools/lcc/tst/paranoia.c
@@ -0,0 +1,2203 @@
+#undef V9
+#define NOPAUSE
+/*	A C version of Kahan's Floating Point Test "Paranoia"
+
+			Thos Sumner, UCSF, Feb. 1985
+			David Gay, BTL, Jan. 1986
+
+	This is a rewrite from the Pascal version by
+
+			B. A. Wichmann, 18 Jan. 1985
+
+	(and does NOT exhibit good C programming style).
+
+(C) Apr 19 1983 in BASIC version by:
+	Professor W. M. Kahan,
+	567 Evans Hall
+	Electrical Engineering & Computer Science Dept.
+	University of California
+	Berkeley, California 94720
+	USA
+
+converted to Pascal by:
+	B. A. Wichmann
+	National Physical Laboratory
+	Teddington Middx
+	TW11 OLW
+	UK
+
+converted to C by:
+
+	David M. Gay		and	Thos Sumner
+	AT&T Bell Labs			Computer Center, Rm. U-76
+	600 Mountain Avenue		University of California
+	Murray Hill, NJ 07974		San Francisco, CA 94143
+	USA				USA
+
+with simultaneous corrections to the Pascal source (reflected
+in the Pascal source available over netlib).
+[A couple of bug fixes from dgh = sun!dhough incorporated 31 July 1986.]
+
+Reports of results on various systems from all the versions
+of Paranoia are being collected by Richard Karpinski at the
+same address as Thos Sumner.  This includes sample outputs,
+bug reports, and criticisms.
+
+You may copy this program freely if you acknowledge its source.
+Comments on the Pascal version to NPL, please.
+
+
+The C version catches signals from floating-point exceptions.
+If signal(SIGFPE,...) is unavailable in your environment, you may
+#define NOSIGNAL to comment out the invocations of signal.
+
+This source file is too big for some C compilers, but may be split
+into pieces.  Comments containing "SPLIT" suggest convenient places
+for this splitting.  At the end of these comments is an "ed script"
+(for the UNIX(tm) editor ed) that will do this splitting.
+
+By #defining Single when you compile this source, you may obtain
+a single-precision C version of Paranoia.
+
+
+The following is from the introductory commentary from Wichmann's work:
+
+The BASIC program of Kahan is written in Microsoft BASIC using many
+facilities which have no exact analogy in Pascal.  The Pascal
+version below cannot therefore be exactly the same.  Rather than be
+a minimal transcription of the BASIC program, the Pascal coding
+follows the conventional style of block-structured languages.  Hence
+the Pascal version could be useful in producing versions in other
+structured languages.
+
+Rather than use identifiers of minimal length (which therefore have
+little mnemonic significance), the Pascal version uses meaningful
+identifiers as follows [Note: A few changes have been made for C]:
+
+
+BASIC   C               BASIC   C               BASIC   C               
+
+   A                       J                       S    StickyBit
+   A1   AInverse           J0   NoErrors           T
+   B    Radix                    [Failure]         T0   Underflow
+   B1   BInverse           J1   NoErrors           T2   ThirtyTwo
+   B2   RadixD2                  [SeriousDefect]   T5   OneAndHalf
+   B9   BMinusU2           J2   NoErrors           T7   TwentySeven
+   C                             [Defect]          T8   TwoForty
+   C1   CInverse           J3   NoErrors           U    OneUlp
+   D                             [Flaw]            U0   UnderflowThreshold
+   D4   FourD              K    PageNo             U1
+   E0                      L    Milestone          U2
+   E1                      M                       V
+   E2   Exp2               N                       V0
+   E3                      N1                      V8
+   E5   MinSqEr            O    Zero               V9
+   E6   SqEr               O1   One                W
+   E7   MaxSqEr            O2   Two                X
+   E8                      O3   Three              X1
+   E9                      O4   Four               X8
+   F1   MinusOne           O5   Five               X9   Random1
+   F2   Half               O8   Eight              Y
+   F3   Third              O9   Nine               Y1
+   F6                      P    Precision          Y2
+   F9                      Q                       Y9   Random2
+   G1   GMult              Q8                      Z
+   G2   GDiv               Q9                      Z0   PseudoZero
+   G3   GAddSub            R                       Z1
+   H                       R1   RMult              Z2
+   H1   HInverse           R2   RDiv               Z9
+   I                       R3   RAddSub
+   IO   NoTrials           R4   RSqrt
+   I3   IEEE               R9   Random9
+
+   SqRWrng
+
+All the variables in BASIC are true variables and in consequence,
+the program is more difficult to follow since the "constants" must
+be determined (the glossary is very helpful).  The Pascal version
+uses Real constants, but checks are added to ensure that the values
+are correctly converted by the compiler.
+
+The major textual change to the Pascal version apart from the
+identifiersis that named procedures are used, inserting parameters
+wherehelpful.  New procedures are also introduced.  The
+correspondence is as follows:
+
+
+BASIC       Pascal
+lines 
+
+  90- 140   Pause
+ 170- 250   Instructions
+ 380- 460   Heading
+ 480- 670   Characteristics
+ 690- 870   History
+2940-2950   Random
+3710-3740   NewD
+4040-4080   DoesYequalX
+4090-4110   PrintIfNPositive
+4640-4850   TestPartialUnderflow
+
+=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=
+
+Below is an "ed script" that splits para.c into 10 files
+of the form part[1-8].c, subs.c, and msgs.c, plus a header
+file, paranoia.h, that these files require.
+
+r paranoia.c
+$
+?SPLIT
++,$w msgs.c
+ .,$d
+?SPLIT
+ .d
++d
+-,$w subs.c
+-,$d
+?part8
++d
+?include
+ .,$w part8.c
+ .,$d
+-d
+?part7
++d
+?include
+ .,$w part7.c
+ .,$d
+-d
+?part6
++d
+?include
+ .,$w part6.c
+ .,$d
+-d
+?part5
++d
+?include
+ .,$w part5.c
+ .,$d
+-d
+?part4
++d
+?include
+ .,$w part4.c
+ .,$d
+-d
+?part3
++d
+?include
+ .,$w part3.c
+ .,$d
+-d
+?part2
++d
+?include
+ .,$w part2.c
+ .,$d
+?SPLIT
+ .d
+1,/^#include/-1d
+1,$w part1.c
+/Computed constants/,$d
+1,$s/^int/extern &/
+1,$s/^FLOAT/extern &/
+1,$s/^char/extern &/
+1,$s! = .*!;!
+/^Guard/,/^Round/s/^/extern /
+/^jmp_buf/s/^/extern /
+/^Sig_type/s/^/extern /
+s/$/\
+extern void sigfpe();/
+w paranoia.h
+q
+
+*/
+
+#include <stdio.h>
+#ifndef NOSIGNAL
+#include <signal.h>
+#endif
+#include <setjmp.h>
+
+extern double fabs(), floor(), log(), pow(), sqrt();
+
+#ifdef Single
+#define FLOAT float
+#define FABS(x) (float)fabs((double)(x))
+#define FLOOR(x) (float)floor((double)(x))
+#define LOG(x) (float)log((double)(x))
+#define POW(x,y) (float)pow((double)(x),(double)(y))
+#define SQRT(x) (float)sqrt((double)(x))
+#else
+#define FLOAT double
+#define FABS(x) fabs(x)
+#define FLOOR(x) floor(x)
+#define LOG(x) log(x)
+#define POW(x,y) pow(x,y)
+#define SQRT(x) sqrt(x)
+#endif
+
+jmp_buf ovfl_buf;
+typedef void (*Sig_type)();
+Sig_type sigsave;
+
+#define KEYBOARD 0
+
+FLOAT Radix, BInvrse, RadixD2, BMinusU2;
+FLOAT Sign(), Random();
+
+/*Small floating point constants.*/
+FLOAT Zero = 0.0;
+FLOAT Half = 0.5;
+FLOAT One = 1.0;
+FLOAT Two = 2.0;
+FLOAT Three = 3.0;
+FLOAT Four = 4.0;
+FLOAT Five = 5.0;
+FLOAT Eight = 8.0;
+FLOAT Nine = 9.0;
+FLOAT TwentySeven = 27.0;
+FLOAT ThirtyTwo = 32.0;
+FLOAT TwoForty = 240.0;
+FLOAT MinusOne = -1.0;
+FLOAT OneAndHalf = 1.5;
+/*Integer constants*/
+int NoTrials = 20; /*Number of tests for commutativity. */
+#define False 0
+#define True 1
+
+/* Definitions for declared types 
+	Guard == (Yes, No);
+	Rounding == (Chopped, Rounded, Other);
+	Message == packed array [1..40] of char;
+	Class == (Flaw, Defect, Serious, Failure);
+	  */
+#define Yes 1
+#define No  0
+#define Chopped 2
+#define Rounded 1
+#define Other   0
+#define Flaw    3
+#define Defect  2
+#define Serious 1
+#define Failure 0
+typedef int Guard, Rounding, Class;
+typedef char Message;
+
+/* Declarations of Variables */
+int Indx;
+char ch[8];
+FLOAT AInvrse, A1;
+FLOAT C, CInvrse;
+FLOAT D, FourD;
+FLOAT E0, E1, Exp2, E3, MinSqEr;
+FLOAT SqEr, MaxSqEr, E9;
+FLOAT Third;
+FLOAT F6, F9;
+FLOAT H, HInvrse;
+int I;
+FLOAT StickyBit, J;
+FLOAT MyZero;
+FLOAT Precision;
+FLOAT Q, Q9;
+FLOAT R, Random9;
+FLOAT T, Underflow, S;
+FLOAT OneUlp, UfThold, U1, U2;
+FLOAT V, V0, V9;
+FLOAT W;
+FLOAT X, X1, X2, X8, Random1;
+FLOAT Y, Y1, Y2, Random2;
+FLOAT Z, PseudoZero, Z1, Z2, Z9;
+int ErrCnt[4];
+int fpecount;
+int Milestone;
+int PageNo;
+int M, N, N1;
+Guard GMult, GDiv, GAddSub;
+Rounding RMult, RDiv, RAddSub, RSqrt;
+int Break, Done, NotMonot, Monot, Anomaly, IEEE,
+		SqRWrng, UfNGrad;
+/* Computed constants. */
+/*U1  gap below 1.0, i.e, 1.0-U1 is next number below 1.0 */
+/*U2  gap above 1.0, i.e, 1.0+U2 is next number above 1.0 */
+
+/* floating point exception receiver */
+ void
+sigfpe(i)
+{
+	fpecount++;
+	printf("\n* * * FLOATING-POINT ERROR * * *\n");
+	fflush(stdout);
+	if (sigsave) {
+#ifndef NOSIGNAL
+		signal(SIGFPE, sigsave);
+#endif
+		sigsave = 0;
+		longjmp(ovfl_buf, 1);
+		}
+	abort();
+}
+
+main()
+{
+#ifdef mc
+	char *out;
+	ieee_flags("set", "precision", "double", &out);
+#endif
+	/* First two assignments use integer right-hand sides. */
+	Zero = 0;
+	One = 1;
+	Two = One + One;
+	Three = Two + One;
+	Four = Three + One;
+	Five = Four + One;
+	Eight = Four + Four;
+	Nine = Three * Three;
+	TwentySeven = Nine * Three;
+	ThirtyTwo = Four * Eight;
+	TwoForty = Four * Five * Three * Four;
+	MinusOne = -One;
+	Half = One / Two;
+	OneAndHalf = One + Half;
+	ErrCnt[Failure] = 0;
+	ErrCnt[Serious] = 0;
+	ErrCnt[Defect] = 0;
+	ErrCnt[Flaw] = 0;
+	PageNo = 1;
+	/*=============================================*/
+	Milestone = 0;
+	/*=============================================*/
+#ifndef NOSIGNAL
+	signal(SIGFPE, sigfpe);
+#endif
+	Instructions();
+	Pause();
+	Heading();
+	Pause();
+	Characteristics();
+	Pause();
+	History();
+	Pause();
+	/*=============================================*/
+	Milestone = 7;
+	/*=============================================*/
+	printf("Program is now RUNNING tests on small integers:\n");
+	
+	TstCond (Failure, (Zero + Zero == Zero) && (One - One == Zero)
+		   && (One > Zero) && (One + One == Two),
+			"0+0 != 0, 1-1 != 0, 1 <= 0, or 1+1 != 2");
+	Z = - Zero;
+	if (Z != 0.0) {
+		ErrCnt[Failure] = ErrCnt[Failure] + 1;
+		printf("Comparison alleges that -0.0 is Non-zero!\n");
+		U1 = 0.001;
+		Radix = 1;
+		TstPtUf();
+		}
+	TstCond (Failure, (Three == Two + One) && (Four == Three + One)
+		   && (Four + Two * (- Two) == Zero)
+		   && (Four - Three - One == Zero),
+		   "3 != 2+1, 4 != 3+1, 4+2*(-2) != 0, or 4-3-1 != 0");
+	TstCond (Failure, (MinusOne == (0 - One))
+		   && (MinusOne + One == Zero ) && (One + MinusOne == Zero)
+		   && (MinusOne + FABS(One) == Zero)
+		   && (MinusOne + MinusOne * MinusOne == Zero),
+		   "-1+1 != 0, (-1)+abs(1) != 0, or -1+(-1)*(-1) != 0");
+	TstCond (Failure, Half + MinusOne + Half == Zero,
+		  "1/2 + (-1) + 1/2 != 0");
+	/*=============================================*/
+	/*SPLIT
+	part2();
+	part3();
+	part4();
+	part5();
+	part6();
+	part7();
+	part8();
+	}
+#include "paranoia.h"
+part2(){
+*/
+	Milestone = 10;
+	/*=============================================*/
+	TstCond (Failure, (Nine == Three * Three)
+		   && (TwentySeven == Nine * Three) && (Eight == Four + Four)
+		   && (ThirtyTwo == Eight * Four)
+		   && (ThirtyTwo - TwentySeven - Four - One == Zero),
+		   "9 != 3*3, 27 != 9*3, 32 != 8*4, or 32-27-4-1 != 0");
+	TstCond (Failure, (Five == Four + One) &&
+			(TwoForty == Four * Five * Three * Four)
+		   && (TwoForty / Three - Four * Four * Five == Zero)
+		   && ( TwoForty / Four - Five * Three * Four == Zero)
+		   && ( TwoForty / Five - Four * Three * Four == Zero),
+		  "5 != 4+1, 240/3 != 80, 240/4 != 60, or 240/5 != 48");
+	if (ErrCnt[Failure] == 0) {
+		printf("-1, 0, 1/2, 1, 2, 3, 4, 5, 9, 27, 32 & 240 are O.K.\n");
+		printf("\n");
+		}
+	printf("Searching for Radix and Precision.\n");
+	W = One;
+	do  {
+		W = W + W;
+		Y = W + One;
+		Z = Y - W;
+		Y = Z - One;
+		} while (MinusOne + FABS(Y) < Zero);
+	/*.. now W is just big enough that |((W+1)-W)-1| >= 1 ...*/
+	Precision = Zero;
+	Y = One;
+	do  {
+		Radix = W + Y;
+		Y = Y + Y;
+		Radix = Radix - W;
+		} while ( Radix == Zero);
+	if (Radix < Two) Radix = One;
+	printf("Radix = %f .\n", Radix);
+	if (Radix != 1) {
+		W = One;
+		do  {
+			Precision = Precision + One;
+			W = W * Radix;
+			Y = W + One;
+			} while ((Y - W) == One);
+		}
+	/*... now W == Radix^Precision is barely too big to satisfy (W+1)-W == 1
+			                              ...*/
+	U1 = One / W;
+	U2 = Radix * U1;
+	printf("Closest relative separation found is U1 = %.7e .\n\n", U1);
+	printf("Recalculating radix and precision\n ");
+	
+	/*save old values*/
+	E0 = Radix;
+	E1 = U1;
+	E9 = U2;
+	E3 = Precision;
+	
+	X = Four / Three;
+	Third = X - One;
+	F6 = Half - Third;
+	X = F6 + F6;
+	X = FABS(X - Third);
+	if (X < U2) X = U2;
+	
+	/*... now X = (unknown no.) ulps of 1+...*/
+	do  {
+		U2 = X;
+		Y = Half * U2 + ThirtyTwo * U2 * U2;
+		Y = One + Y;
+		X = Y - One;
+		} while ( ! ((U2 <= X) || (X <= Zero)));
+	
+	/*... now U2 == 1 ulp of 1 + ... */
+	X = Two / Three;
+	F6 = X - Half;
+	Third = F6 + F6;
+	X = Third - Half;
+	X = FABS(X + F6);
+	if (X < U1) X = U1;
+	
+	/*... now  X == (unknown no.) ulps of 1 -... */
+	do  {
+		U1 = X;
+		Y = Half * U1 + ThirtyTwo * U1 * U1;
+		Y = Half - Y;
+		X = Half + Y;
+		Y = Half - X;
+		X = Half + Y;
+		} while ( ! ((U1 <= X) || (X <= Zero)));
+	/*... now U1 == 1 ulp of 1 - ... */
+	if (U1 == E1) printf("confirms closest relative separation U1 .\n");
+	else printf("gets better closest relative separation U1 = %.7e .\n", U1);
+	W = One / U1;
+	F9 = (Half - U1) + Half;
+	Radix = FLOOR(0.01 + U2 / U1);
+	if (Radix == E0) printf("Radix confirmed.\n");
+	else printf("MYSTERY: recalculated Radix = %.7e .\n", Radix);
+	TstCond (Defect, Radix <= Eight + Eight,
+		   "Radix is too big: roundoff problems");
+	TstCond (Flaw, (Radix == Two) || (Radix == 10)
+		   || (Radix == One), "Radix is not as good as 2 or 10");
+	/*=============================================*/
+	Milestone = 20;
+	/*=============================================*/
+	TstCond (Failure, F9 - Half < Half,
+		   "(1-U1)-1/2 < 1/2 is FALSE, prog. fails?");
+	X = F9;
+	I = 1;
+	Y = X - Half;
+	Z = Y - Half;
+	TstCond (Failure, (X != One)
+		   || (Z == Zero), "Comparison is fuzzy,X=1 but X-1/2-1/2 != 0");
+	X = One + U2;
+	I = 0;
+	/*=============================================*/
+	Milestone = 25;
+	/*=============================================*/
+	/*... BMinusU2 = nextafter(Radix, 0) */
+	BMinusU2 = Radix - One;
+	BMinusU2 = (BMinusU2 - U2) + One;
+	/* Purify Integers */
+	if (Radix != One)  {
+		X = - TwoForty * LOG(U1) / LOG(Radix);
+		Y = FLOOR(Half + X);
+		if (FABS(X - Y) * Four < One) X = Y;
+		Precision = X / TwoForty;
+		Y = FLOOR(Half + Precision);
+		if (FABS(Precision - Y) * TwoForty < Half) Precision = Y;
+		}
+	if ((Precision != FLOOR(Precision)) || (Radix == One)) {
+		printf("Precision cannot be characterized by an Integer number\n");
+		printf("of significant digits but, by itself, this is a minor flaw.\n");
+		}
+	if (Radix == One) 
+		printf("logarithmic encoding has precision characterized solely by U1.\n");
+	else printf("The number of significant digits of the Radix is %f .\n",
+			Precision);
+	TstCond (Serious, U2 * Nine * Nine * TwoForty < One,
+		   "Precision worse than 5 decimal figures  ");
+	/*=============================================*/
+	Milestone = 30;
+	/*=============================================*/
+	/* Test for extra-precise subepressions */
+	X = FABS(((Four / Three - One) - One / Four) * Three - One / Four);
+	do  {
+		Z2 = X;
+		X = (One + (Half * Z2 + ThirtyTwo * Z2 * Z2)) - One;
+		} while ( ! ((Z2 <= X) || (X <= Zero)));
+	X = Y = Z = FABS((Three / Four - Two / Three) * Three - One / Four);
+	do  {
+		Z1 = Z;
+		Z = (One / Two - ((One / Two - (Half * Z1 + ThirtyTwo * Z1 * Z1))
+			+ One / Two)) + One / Two;
+		} while ( ! ((Z1 <= Z) || (Z <= Zero)));
+	do  {
+		do  {
+			Y1 = Y;
+			Y = (Half - ((Half - (Half * Y1 + ThirtyTwo * Y1 * Y1)) + Half
+				)) + Half;
+			} while ( ! ((Y1 <= Y) || (Y <= Zero)));
+		X1 = X;
+		X = ((Half * X1 + ThirtyTwo * X1 * X1) - F9) + F9;
+		} while ( ! ((X1 <= X) || (X <= Zero)));
+	if ((X1 != Y1) || (X1 != Z1)) {
+		BadCond(Serious, "Disagreements among the values X1, Y1, Z1,\n");
+		printf("respectively  %.7e,  %.7e,  %.7e,\n", X1, Y1, Z1);
+		printf("are symptoms of inconsistencies introduced\n");
+		printf("by extra-precise evaluation of arithmetic subexpressions.\n");
+		notify("Possibly some part of this");
+		if ((X1 == U1) || (Y1 == U1) || (Z1 == U1))  printf(
+			"That feature is not tested further by this program.\n") ;
+		}
+	else  {
+		if ((Z1 != U1) || (Z2 != U2)) {
+			if ((Z1 >= U1) || (Z2 >= U2)) {
+				BadCond(Failure, "");
+				notify("Precision");
+				printf("\tU1 = %.7e, Z1 - U1 = %.7e\n",U1,Z1-U1);
+				printf("\tU2 = %.7e, Z2 - U2 = %.7e\n",U2,Z2-U2);
+				}
+			else {
+				if ((Z1 <= Zero) || (Z2 <= Zero)) {
+					printf("Because of unusual Radix = %f", Radix);
+					printf(", or exact rational arithmetic a result\n");
+					printf("Z1 = %.7e, or Z2 = %.7e ", Z1, Z2);
+					notify("of an\nextra-precision");
+					}
+				if (Z1 != Z2 || Z1 > Zero) {
+					X = Z1 / U1;
+					Y = Z2 / U2;
+					if (Y > X) X = Y;
+					Q = - LOG(X);
+					printf("Some subexpressions appear to be calculated extra\n");
+					printf("precisely with about %g extra B-digits, i.e.\n",
+						(Q / LOG(Radix)));
+					printf("roughly %g extra significant decimals.\n",
+						Q / LOG(10.));
+					}
+				printf("That feature is not tested further by this program.\n");
+				}
+			}
+		}
+	Pause();
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part3(){
+*/
+	Milestone = 35;
+	/*=============================================*/
+	if (Radix >= Two) {
+		X = W / (Radix * Radix);
+		Y = X + One;
+		Z = Y - X;
+		T = Z + U2;
+		X = T - Z;
+		TstCond (Failure, X == U2,
+			"Subtraction is not normalized X=Y,X+Z != Y+Z!");
+		if (X == U2) printf(
+			"Subtraction appears to be normalized, as it should be.");
+		}
+	printf("\nChecking for guard digit in *, /, and -.\n");
+	Y = F9 * One;
+	Z = One * F9;
+	X = F9 - Half;
+	Y = (Y - Half) - X;
+	Z = (Z - Half) - X;
+	X = One + U2;
+	T = X * Radix;
+	R = Radix * X;
+	X = T - Radix;
+	X = X - Radix * U2;
+	T = R - Radix;
+	T = T - Radix * U2;
+	X = X * (Radix - One);
+	T = T * (Radix - One);
+	if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)) GMult = Yes;
+	else {
+		GMult = No;
+		TstCond (Serious, False,
+			"* lacks a Guard Digit, so 1*X != X");
+		}
+	Z = Radix * U2;
+	X = One + Z;
+	Y = FABS((X + Z) - X * X) - U2;
+	X = One - U2;
+	Z = FABS((X - U2) - X * X) - U1;
+	TstCond (Failure, (Y <= Zero)
+		   && (Z <= Zero), "* gets too many final digits wrong.\n");
+	Y = One - U2;
+	X = One + U2;
+	Z = One / Y;
+	Y = Z - X;
+	X = One / Three;
+	Z = Three / Nine;
+	X = X - Z;
+	T = Nine / TwentySeven;
+	Z = Z - T;
+	TstCond(Defect, X == Zero && Y == Zero && Z == Zero,
+		"Division lacks a Guard Digit, so error can exceed 1 ulp\nor  1/3  and  3/9  and  9/27 may disagree");
+	Y = F9 / One;
+	X = F9 - Half;
+	Y = (Y - Half) - X;
+	X = One + U2;
+	T = X / One;
+	X = T - X;
+	if ((X == Zero) && (Y == Zero) && (Z == Zero)) GDiv = Yes;
+	else {
+		GDiv = No;
+		TstCond (Serious, False,
+			"Division lacks a Guard Digit, so X/1 != X");
+		}
+	X = One / (One + U2);
+	Y = X - Half - Half;
+	TstCond (Serious, Y < Zero,
+		   "Computed value of 1/1.000..1 >= 1");
+	X = One - U2;
+	Y = One + Radix * U2;
+	Z = X * Radix;
+	T = Y * Radix;
+	R = Z / Radix;
+	StickyBit = T / Radix;
+	X = R - X;
+	Y = StickyBit - Y;
+	TstCond (Failure, X == Zero && Y == Zero,
+			"* and/or / gets too many last digits wrong");
+	Y = One - U1;
+	X = One - F9;
+	Y = One - Y;
+	T = Radix - U2;
+	Z = Radix - BMinusU2;
+	T = Radix - T;
+	if ((X == U1) && (Y == U1) && (Z == U2) && (T == U2)) GAddSub = Yes;
+	else {
+		GAddSub = No;
+		TstCond (Serious, False,
+			"- lacks Guard Digit, so cancellation is obscured");
+		}
+	if (F9 != One && F9 - One >= Zero) {
+		BadCond(Serious, "comparison alleges  (1-U1) < 1  although\n");
+		printf("  subtraction yields  (1-U1) - 1 = 0 , thereby vitiating\n");
+		printf("  such precautions against division by zero as\n");
+		printf("  ...  if (X == 1.0) {.....} else {.../(X-1.0)...}\n");
+		}
+	if (GMult == Yes && GDiv == Yes && GAddSub == Yes) printf(
+		"     *, /, and - appear to have guard digits, as they should.\n");
+	/*=============================================*/
+	Milestone = 40;
+	/*=============================================*/
+	Pause();
+	printf("Checking rounding on multiply, divide and add/subtract.\n");
+	RMult = Other;
+	RDiv = Other;
+	RAddSub = Other;
+	RadixD2 = Radix / Two;
+	A1 = Two;
+	Done = False;
+	do  {
+		AInvrse = Radix;
+		do  {
+			X = AInvrse;
+			AInvrse = AInvrse / A1;
+			} while ( ! (FLOOR(AInvrse) != AInvrse));
+		Done = (X == One) || (A1 > Three);
+		if (! Done) A1 = Nine + One;
+		} while ( ! (Done));
+	if (X == One) A1 = Radix;
+	AInvrse = One / A1;
+	X = A1;
+	Y = AInvrse;
+	Done = False;
+	do  {
+		Z = X * Y - Half;
+		TstCond (Failure, Z == Half,
+			"X * (1/X) differs from 1");
+		Done = X == Radix;
+		X = Radix;
+		Y = One / X;
+		} while ( ! (Done));
+	Y2 = One + U2;
+	Y1 = One - U2;
+	X = OneAndHalf - U2;
+	Y = OneAndHalf + U2;
+	Z = (X - U2) * Y2;
+	T = Y * Y1;
+	Z = Z - X;
+	T = T - X;
+	X = X * Y2;
+	Y = (Y + U2) * Y1;
+	X = X - OneAndHalf;
+	Y = Y - OneAndHalf;
+	if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T <= Zero)) {
+		X = (OneAndHalf + U2) * Y2;
+		Y = OneAndHalf - U2 - U2;
+		Z = OneAndHalf + U2 + U2;
+		T = (OneAndHalf - U2) * Y1;
+		X = X - (Z + U2);
+		StickyBit = Y * Y1;
+		S = Z * Y2;
+		T = T - Y;
+		Y = (U2 - Y) + StickyBit;
+		Z = S - (Z + U2 + U2);
+		StickyBit = (Y2 + U2) * Y1;
+		Y1 = Y2 * Y1;
+		StickyBit = StickyBit - Y2;
+		Y1 = Y1 - Half;
+		if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+			&& ( StickyBit == Zero) && (Y1 == Half)) {
+			RMult = Rounded;
+			printf("Multiplication appears to round correctly.\n");
+			}
+		else	if ((X + U2 == Zero) && (Y < Zero) && (Z + U2 == Zero)
+				&& (T < Zero) && (StickyBit + U2 == Zero)
+				&& (Y1 < Half)) {
+				RMult = Chopped;
+				printf("Multiplication appears to chop.\n");
+				}
+			else printf("* is neither chopped nor correctly rounded.\n");
+		if ((RMult == Rounded) && (GMult == No)) notify("Multiplication");
+		}
+	else printf("* is neither chopped nor correctly rounded.\n");
+	/*=============================================*/
+	Milestone = 45;
+	/*=============================================*/
+	Y2 = One + U2;
+	Y1 = One - U2;
+	Z = OneAndHalf + U2 + U2;
+	X = Z / Y2;
+	T = OneAndHalf - U2 - U2;
+	Y = (T - U2) / Y1;
+	Z = (Z + U2) / Y2;
+	X = X - OneAndHalf;
+	Y = Y - T;
+	T = T / Y1;
+	Z = Z - (OneAndHalf + U2);
+	T = (U2 - OneAndHalf) + T;
+	if (! ((X > Zero) || (Y > Zero) || (Z > Zero) || (T > Zero))) {
+		X = OneAndHalf / Y2;
+		Y = OneAndHalf - U2;
+		Z = OneAndHalf + U2;
+		X = X - Y;
+		T = OneAndHalf / Y1;
+		Y = Y / Y1;
+		T = T - (Z + U2);
+		Y = Y - Z;
+		Z = Z / Y2;
+		Y1 = (Y2 + U2) / Y2;
+		Z = Z - OneAndHalf;
+		Y2 = Y1 - Y2;
+		Y1 = (F9 - U1) / F9;
+		if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
+			&& (Y2 == Zero) && (Y2 == Zero)
+			&& (Y1 - Half == F9 - Half )) {
+			RDiv = Rounded;
+			printf("Division appears to round correctly.\n");
+			if (GDiv == No) notify("Division");
+			}
+		else if ((X < Zero) && (Y < Zero) && (Z < Zero) && (T < Zero)
+			&& (Y2 < Zero) && (Y1 - Half < F9 - Half)) {
+			RDiv = Chopped;
+			printf("Division appears to chop.\n");
+			}
+		}
+	if (RDiv == Other) printf("/ is neither chopped nor correctly rounded.\n");
+	BInvrse = One / Radix;
+	TstCond (Failure, (BInvrse * Radix - Half == Half),
+		   "Radix * ( 1 / Radix ) differs from 1");
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part4(){
+*/
+	Milestone = 50;
+	/*=============================================*/
+	TstCond (Failure, ((F9 + U1) - Half == Half)
+		   && ((BMinusU2 + U2 ) - One == Radix - One),
+		   "Incomplete carry-propagation in Addition");
+	X = One - U1 * U1;
+	Y = One + U2 * (One - U2);
+	Z = F9 - Half;
+	X = (X - Half) - Z;
+	Y = Y - One;
+	if ((X == Zero) && (Y == Zero)) {
+		RAddSub = Chopped;
+		printf("Add/Subtract appears to be chopped.\n");
+		}
+	if (GAddSub == Yes) {
+		X = (Half + U2) * U2;
+		Y = (Half - U2) * U2;
+		X = One + X;
+		Y = One + Y;
+		X = (One + U2) - X;
+		Y = One - Y;
+		if ((X == Zero) && (Y == Zero)) {
+			X = (Half + U2) * U1;
+			Y = (Half - U2) * U1;
+			X = One - X;
+			Y = One - Y;
+			X = F9 - X;
+			Y = One - Y;
+			if ((X == Zero) && (Y == Zero)) {
+				RAddSub = Rounded;
+				printf("Addition/Subtraction appears to round correctly.\n");
+				if (GAddSub == No) notify("Add/Subtract");
+				}
+			else printf("Addition/Subtraction neither rounds nor chops.\n");
+			}
+		else printf("Addition/Subtraction neither rounds nor chops.\n");
+		}
+	else printf("Addition/Subtraction neither rounds nor chops.\n");
+	S = One;
+	X = One + Half * (One + Half);
+	Y = (One + U2) * Half;
+	Z = X - Y;
+	T = Y - X;
+	StickyBit = Z + T;
+	if (StickyBit != Zero) {
+		S = Zero;
+		BadCond(Flaw, "(X - Y) + (Y - X) is non zero!\n");
+		}
+	StickyBit = Zero;
+	if ((GMult == Yes) && (GDiv == Yes) && (GAddSub == Yes)
+		&& (RMult == Rounded) && (RDiv == Rounded)
+		&& (RAddSub == Rounded) && (FLOOR(RadixD2) == RadixD2)) {
+		printf("Checking for sticky bit.\n");
+		X = (Half + U1) * U2;
+		Y = Half * U2;
+		Z = One + Y;
+		T = One + X;
+		if ((Z - One <= Zero) && (T - One >= U2)) {
+			Z = T + Y;
+			Y = Z - X;
+			if ((Z - T >= U2) && (Y - T == Zero)) {
+				X = (Half + U1) * U1;
+				Y = Half * U1;
+				Z = One - Y;
+				T = One - X;
+				if ((Z - One == Zero) && (T - F9 == Zero)) {
+					Z = (Half - U1) * U1;
+					T = F9 - Z;
+					Q = F9 - Y;
+					if ((T - F9 == Zero) && (F9 - U1 - Q == Zero)) {
+						Z = (One + U2) * OneAndHalf;
+						T = (OneAndHalf + U2) - Z + U2;
+						X = One + Half / Radix;
+						Y = One + Radix * U2;
+						Z = X * Y;
+						if (T == Zero && X + Radix * U2 - Z == Zero) {
+							if (Radix != Two) {
+								X = Two + U2;
+								Y = X / Two;
+								if ((Y - One == Zero)) StickyBit = S;
+								}
+							else StickyBit = S;
+							}
+						}
+					}
+				}
+			}
+		}
+	if (StickyBit == One) printf("Sticky bit apparently used correctly.\n");
+	else printf("Sticky bit used incorrectly or not at all.\n");
+	TstCond (Flaw, !(GMult == No || GDiv == No || GAddSub == No ||
+			RMult == Other || RDiv == Other || RAddSub == Other),
+		"lack(s) of guard digits or failure(s) to correctly round or chop\n(noted above) count as one flaw in the final tally below");
+	/*=============================================*/
+	Milestone = 60;
+	/*=============================================*/
+	printf("\n");
+	printf("Does Multiplication commute?  ");
+	printf("Testing on %d random pairs.\n", NoTrials);
+	Random9 = SQRT(3.0);
+	Random1 = Third;
+	I = 1;
+	do  {
+		X = Random();
+		Y = Random();
+		Z9 = Y * X;
+		Z = X * Y;
+		Z9 = Z - Z9;
+		I = I + 1;
+		} while ( ! ((I > NoTrials) || (Z9 != Zero)));
+	if (I == NoTrials) {
+		Random1 = One + Half / Three;
+		Random2 = (U2 + U1) + One;
+		Z = Random1 * Random2;
+		Y = Random2 * Random1;
+		Z9 = (One + Half / Three) * ((U2 + U1) + One) - (One + Half /
+			Three) * ((U2 + U1) + One);
+		}
+	if (! ((I == NoTrials) || (Z9 == Zero)))
+		BadCond(Defect, "X * Y == Y * X trial fails.\n");
+	else printf("     No failures found in %d integer pairs.\n", NoTrials);
+	/*=============================================*/
+	Milestone = 70;
+	/*=============================================*/
+	printf("\nRunning test of square root(x).\n");
+	TstCond (Failure, (Zero == SQRT(Zero))
+		   && (- Zero == SQRT(- Zero))
+		   && (One == SQRT(One)), "Square root of 0.0, -0.0 or 1.0 wrong");
+	MinSqEr = Zero;
+	MaxSqEr = Zero;
+	J = Zero;
+	X = Radix;
+	OneUlp = U2;
+	SqXMinX (Serious);
+	X = BInvrse;
+	OneUlp = BInvrse * U1;
+	SqXMinX (Serious);
+	X = U1;
+	OneUlp = U1 * U1;
+	SqXMinX (Serious);
+	if (J != Zero) Pause();
+	printf("Testing if sqrt(X * X) == X for %d Integers X.\n", NoTrials);
+	J = Zero;
+	X = Two;
+	Y = Radix;
+	if ((Radix != One)) do  {
+		X = Y;
+		Y = Radix * Y;
+		} while ( ! ((Y - X >= NoTrials)));
+	OneUlp = X * U2;
+	I = 1;
+	while (I <= NoTrials) {
+		X = X + One;
+		SqXMinX (Defect);
+		if (J > Zero) break;
+		I = I + 1;
+		}
+	printf("Test for sqrt monotonicity.\n");
+	I = - 1;
+	X = BMinusU2;
+	Y = Radix;
+	Z = Radix + Radix * U2;
+	NotMonot = False;
+	Monot = False;
+	while ( ! (NotMonot || Monot)) {
+		I = I + 1;
+		X = SQRT(X);
+		Q = SQRT(Y);
+		Z = SQRT(Z);
+		if ((X > Q) || (Q > Z)) NotMonot = True;
+		else {
+			Q = FLOOR(Q + Half);
+			if ((I > 0) || (Radix == Q * Q)) Monot = True;
+			else if (I > 0) {
+			if (I > 1) Monot = True;
+			else {
+				Y = Y * BInvrse;
+				X = Y - U1;
+				Z = Y + U1;
+				}
+			}
+			else {
+				Y = Q;
+				X = Y - U2;
+				Z = Y + U2;
+				}
+			}
+		}
+	if (Monot) printf("sqrt has passed a test for Monotonicity.\n");
+	else {
+		BadCond(Defect, "");
+		printf("sqrt(X) is non-monotonic for X near %.7e .\n", Y);
+		}
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part5(){
+*/
+	Milestone = 80;
+	/*=============================================*/
+	MinSqEr = MinSqEr + Half;
+	MaxSqEr = MaxSqEr - Half;
+	Y = (SQRT(One + U2) - One) / U2;
+	SqEr = (Y - One) + U2 / Eight;
+	if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+	SqEr = Y + U2 / Eight;
+	if (SqEr < MinSqEr) MinSqEr = SqEr;
+	Y = ((SQRT(F9) - U2) - (One - U2)) / U1;
+	SqEr = Y + U1 / Eight;
+	if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+	SqEr = (Y + One) + U1 / Eight;
+	if (SqEr < MinSqEr) MinSqEr = SqEr;
+	OneUlp = U2;
+	X = OneUlp;
+	for( Indx = 1; Indx <= 3; ++Indx) {
+		Y = SQRT((X + U1 + X) + F9);
+		Y = ((Y - U2) - ((One - U2) + X)) / OneUlp;
+		Z = ((U1 - X) + F9) * Half * X * X / OneUlp;
+		SqEr = (Y + Half) + Z;
+		if (SqEr < MinSqEr) MinSqEr = SqEr;
+		SqEr = (Y - Half) + Z;
+		if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+		if (((Indx == 1) || (Indx == 3))) 
+			X = OneUlp * Sign (X) * FLOOR(Eight / (Nine * SQRT(OneUlp)));
+		else {
+			OneUlp = U1;
+			X = - OneUlp;
+			}
+		}
+	/*=============================================*/
+	Milestone = 85;
+	/*=============================================*/
+	SqRWrng = False;
+	Anomaly = False;
+	RSqrt = Other; /* ~dgh */
+	if (Radix != One) {
+		printf("Testing whether sqrt is rounded or chopped.\n");
+		D = FLOOR(Half + POW(Radix, One + Precision - FLOOR(Precision)));
+	/* ... == Radix^(1 + fract) if (Precision == Integer + fract. */
+		X = D / Radix;
+		Y = D / A1;
+		if ((X != FLOOR(X)) || (Y != FLOOR(Y))) {
+			Anomaly = True;
+			}
+		else {
+			X = Zero;
+			Z2 = X;
+			Y = One;
+			Y2 = Y;
+			Z1 = Radix - One;
+			FourD = Four * D;
+			do  {
+				if (Y2 > Z2) {
+					Q = Radix;
+					Y1 = Y;
+					do  {
+						X1 = FABS(Q + FLOOR(Half - Q / Y1) * Y1);
+						Q = Y1;
+						Y1 = X1;
+						} while ( ! (X1 <= Zero));
+					if (Q <= One) {
+						Z2 = Y2;
+						Z = Y;
+						}
+					}
+				Y = Y + Two;
+				X = X + Eight;
+				Y2 = Y2 + X;
+				if (Y2 >= FourD) Y2 = Y2 - FourD;
+				} while ( ! (Y >= D));
+			X8 = FourD - Z2;
+			Q = (X8 + Z * Z) / FourD;
+			X8 = X8 / Eight;
+			if (Q != FLOOR(Q)) Anomaly = True;
+			else {
+				Break = False;
+				do  {
+					X = Z1 * Z;
+					X = X - FLOOR(X / Radix) * Radix;
+					if (X == One) 
+						Break = True;
+					else
+						Z1 = Z1 - One;
+					} while ( ! (Break || (Z1 <= Zero)));
+				if ((Z1 <= Zero) && (! Break)) Anomaly = True;
+				else {
+					if (Z1 > RadixD2) Z1 = Z1 - Radix;
+					do  {
+						NewD();
+						} while ( ! (U2 * D >= F9));
+					if (D * Radix - D != W - D) Anomaly = True;
+					else {
+						Z2 = D;
+						I = 0;
+						Y = D + (One + Z) * Half;
+						X = D + Z + Q;
+						SR3750();
+						Y = D + (One - Z) * Half + D;
+						X = D - Z + D;
+						X = X + Q + X;
+						SR3750();
+						NewD();
+						if (D - Z2 != W - Z2) Anomaly = True;
+						else {
+							Y = (D - Z2) + (Z2 + (One - Z) * Half);
+							X = (D - Z2) + (Z2 - Z + Q);
+							SR3750();
+							Y = (One + Z) * Half;
+							X = Q;
+							SR3750();
+							if (I == 0) Anomaly = True;
+							}
+						}
+					}
+				}
+			}
+		if ((I == 0) || Anomaly) {
+			BadCond(Failure, "Anomalous arithmetic with Integer < ");
+			printf("Radix^Precision = %.7e\n", W);
+			printf(" fails test whether sqrt rounds or chops.\n");
+			SqRWrng = True;
+			}
+		}
+	if (! Anomaly) {
+		if (! ((MinSqEr < Zero) || (MaxSqEr > Zero))) {
+			RSqrt = Rounded;
+			printf("Square root appears to be correctly rounded.\n");
+			}
+		else  {
+			if ((MaxSqEr + U2 > U2 - Half) || (MinSqEr > Half)
+				|| (MinSqEr + Radix < Half)) SqRWrng = True;
+			else {
+				RSqrt = Chopped;
+				printf("Square root appears to be chopped.\n");
+				}
+			}
+		}
+	if (SqRWrng) {
+		printf("Square root is neither chopped nor correctly rounded.\n");
+		printf("Observed errors run from %.7e ", MinSqEr - Half);
+		printf("to %.7e ulps.\n", Half + MaxSqEr);
+		TstCond (Serious, MaxSqEr - MinSqEr < Radix * Radix,
+			"sqrt gets too many last digits wrong");
+		}
+	/*=============================================*/
+	Milestone = 90;
+	/*=============================================*/
+	Pause();
+	printf("Testing powers Z^i for small Integers Z and i.\n");
+	N = 0;
+	/* ... test powers of zero. */
+	I = 0;
+	Z = -Zero;
+	M = 3.0;
+	Break = False;
+	do  {
+		X = One;
+		SR3980();
+		if (I <= 10) {
+			I = 1023;
+			SR3980();
+			}
+		if (Z == MinusOne) Break = True;
+		else {
+			Z = MinusOne;
+			PrintIfNPositive();
+			N = 0;
+			/* .. if(-1)^N is invalid, replace MinusOne by One. */
+			I = - 4;
+			}
+		} while ( ! Break);
+	PrintIfNPositive();
+	N1 = N;
+	N = 0;
+	Z = A1;
+	M = FLOOR(Two * LOG(W) / LOG(A1));
+	Break = False;
+	do  {
+		X = Z;
+		I = 1;
+		SR3980();
+		if (Z == AInvrse) Break = True;
+		else Z = AInvrse;
+		} while ( ! (Break));
+	/*=============================================*/
+		Milestone = 100;
+	/*=============================================*/
+	/*  Powers of Radix have been tested, */
+	/*         next try a few primes     */
+	M = NoTrials;
+	Z = Three;
+	do  {
+		X = Z;
+		I = 1;
+		SR3980();
+		do  {
+			Z = Z + Two;
+			} while ( Three * FLOOR(Z / Three) == Z );
+		} while ( Z < Eight * Three );
+	if (N > 0) {
+		printf("Errors like this may invalidate financial calculations\n");
+		printf("\tinvolving interest rates.\n");
+		}
+	PrintIfNPositive();
+	N += N1;
+	if (N == 0) printf("... no discrepancis found.\n");
+	if (N > 0) Pause();
+	else printf("\n");
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part6(){
+*/
+	Milestone = 110;
+	/*=============================================*/
+	printf("Seeking Underflow thresholds UfThold and E0.\n");
+	D = U1;
+	if (Precision != FLOOR(Precision)) {
+		D = BInvrse;
+		X = Precision;
+		do  {
+			D = D * BInvrse;
+			X = X - One;
+			} while ( X > Zero);
+		}
+	Y = One;
+	Z = D;
+	/* ... D is power of 1/Radix < 1. */
+	do  {
+		C = Y;
+		Y = Z;
+		Z = Y * Y;
+		} while ((Y > Z) && (Z + Z > Z));
+	Y = C;
+	Z = Y * D;
+	do  {
+		C = Y;
+		Y = Z;
+		Z = Y * D;
+		} while ((Y > Z) && (Z + Z > Z));
+	if (Radix < Two) HInvrse = Two;
+	else HInvrse = Radix;
+	H = One / HInvrse;
+	/* ... 1/HInvrse == H == Min(1/Radix, 1/2) */
+	CInvrse = One / C;
+	E0 = C;
+	Z = E0 * H;
+	/* ...1/Radix^(BIG Integer) << 1 << CInvrse == 1/C */
+	do  {
+		Y = E0;
+		E0 = Z;
+		Z = E0 * H;
+		} while ((E0 > Z) && (Z + Z > Z));
+	UfThold = E0;
+	E1 = Zero;
+	Q = Zero;
+	E9 = U2;
+	S = One + E9;
+	D = C * S;
+	if (D <= C) {
+		E9 = Radix * U2;
+		S = One + E9;
+		D = C * S;
+		if (D <= C) {
+			BadCond(Failure, "multiplication gets too many last digits wrong.\n");
+			Underflow = E0;
+			Y1 = Zero;
+			PseudoZero = Z;
+			Pause();
+			}
+		}
+	else {
+		Underflow = D;
+		PseudoZero = Underflow * H;
+		UfThold = Zero;
+		do  {
+			Y1 = Underflow;
+			Underflow = PseudoZero;
+			if (E1 + E1 <= E1) {
+				Y2 = Underflow * HInvrse;
+				E1 = FABS(Y1 - Y2);
+				Q = Y1;
+				if ((UfThold == Zero) && (Y1 != Y2)) UfThold = Y1;
+				}
+			PseudoZero = PseudoZero * H;
+			} while ((Underflow > PseudoZero)
+				&& (PseudoZero + PseudoZero > PseudoZero));
+		}
+	/* Comment line 4530 .. 4560 */
+	if (PseudoZero != Zero) {
+		printf("\n");
+		Z = PseudoZero;
+	/* ... Test PseudoZero for "phoney- zero" violates */
+	/* ... PseudoZero < Underflow or PseudoZero < PseudoZero + PseudoZero
+		   ... */
+		if (PseudoZero <= Zero) {
+			BadCond(Failure, "Positive expressions can underflow to an\n");
+			printf("allegedly negative value\n");
+			printf("PseudoZero that prints out as: %g .\n", PseudoZero);
+			X = - PseudoZero;
+			if (X <= Zero) {
+				printf("But -PseudoZero, which should be\n");
+				printf("positive, isn't; it prints out as  %g .\n", X);
+				}
+			}
+		else {
+			BadCond(Flaw, "Underflow can stick at an allegedly positive\n");
+			printf("value PseudoZero that prints out as %g .\n", PseudoZero);
+			}
+		TstPtUf();
+		}
+	/*=============================================*/
+	Milestone = 120;
+	/*=============================================*/
+	if (CInvrse * Y > CInvrse * Y1) {
+		S = H * S;
+		E0 = Underflow;
+		}
+	if (! ((E1 == Zero) || (E1 == E0))) {
+		BadCond(Defect, "");
+		if (E1 < E0) {
+			printf("Products underflow at a higher");
+			printf(" threshold than differences.\n");
+			if (PseudoZero == Zero) 
+			E0 = E1;
+			}
+		else {
+			printf("Difference underflows at a higher");
+			printf(" threshold than products.\n");
+			}
+		}
+	printf("Smallest strictly positive number found is E0 = %g .\n", E0);
+	Z = E0;
+	TstPtUf();
+	Underflow = E0;
+	if (N == 1) Underflow = Y;
+	I = 4;
+	if (E1 == Zero) I = 3;
+	if (UfThold == Zero) I = I - 2;
+	UfNGrad = True;
+	switch (I)  {
+		case	1:
+		UfThold = Underflow;
+		if ((CInvrse * Q) != ((CInvrse * Y) * S)) {
+			UfThold = Y;
+			BadCond(Failure, "Either accuracy deteriorates as numbers\n");
+			printf("approach a threshold = %.17e\n", UfThold);;
+			printf(" coming down from %.17e\n", C);
+			printf(" or else multiplication gets too many last digits wrong.\n");
+			}
+		Pause();
+		break;
+	
+		case	2:
+		BadCond(Failure, "Underflow confuses Comparison, which alleges that\n");
+		printf("Q == Y while denying that |Q - Y| == 0; these values\n");
+		printf("print out as Q = %.17e, Y = %.17e .\n", Q, Y2);
+		printf ("|Q - Y| = %.17e .\n" , FABS(Q - Y2));
+		UfThold = Q;
+		break;
+	
+		case	3:
+		X = X;
+		break;
+	
+		case	4:
+		if ((Q == UfThold) && (E1 == E0)
+			&& (FABS( UfThold - E1 / E9) <= E1)) {
+			UfNGrad = False;
+			printf("Underflow is gradual; it incurs Absolute Error =\n");
+			printf("(roundoff in UfThold) < E0.\n");
+			Y = E0 * CInvrse;
+			Y = Y * (OneAndHalf + U2);
+			X = CInvrse * (One + U2);
+			Y = Y / X;
+			IEEE = (Y == E0);
+			}
+		}
+	if (UfNGrad) {
+		printf("\n");
+		sigsave = sigfpe;
+		if (setjmp(ovfl_buf)) {
+			printf("Underflow / UfThold failed!\n");
+			R = H + H;
+			}
+		else R = SQRT(Underflow / UfThold);
+		sigsave = 0;
+		if (R <= H) {
+			Z = R * UfThold;
+			X = Z * (One + R * H * (One + H));
+			}
+		else {
+			Z = UfThold;
+			X = Z * (One + H * H * (One + H));
+			}
+		if (! ((X == Z) || (X - Z != Zero))) {
+			BadCond(Flaw, "");
+			printf("X = %.17e\n\tis not equal to Z = %.17e .\n", X, Z);
+			Z9 = X - Z;
+			printf("yet X - Z yields %.17e .\n", Z9);
+			printf("    Should this NOT signal Underflow, ");
+			printf("this is a SERIOUS DEFECT\nthat causes ");
+			printf("confusion when innocent statements like\n");;
+			printf("    if (X == Z)  ...  else");
+			printf("  ... (f(X) - f(Z)) / (X - Z) ...\n");
+			printf("encounter Division by Zero although actually\n");
+			sigsave = sigfpe;
+			if (setjmp(ovfl_buf)) printf("X / Z fails!\n");
+			else printf("X / Z = 1 + %g .\n", (X / Z - Half) - Half);
+			sigsave = 0;
+			}
+		}
+	printf("The Underflow threshold is %.17e, %s\n", UfThold,
+		   " below which");
+	printf("calculation may suffer larger Relative error than ");
+	printf("merely roundoff.\n");
+	Y2 = U1 * U1;
+	Y = Y2 * Y2;
+	Y2 = Y * U1;
+	if (Y2 <= UfThold) {
+		if (Y > E0) {
+			BadCond(Defect, "");
+			I = 5;
+			}
+		else {
+			BadCond(Serious, "");
+			I = 4;
+			}
+		printf("Range is too narrow; U1^%d Underflows.\n", I);
+		}
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part7(){
+*/
+	Milestone = 130;
+	/*=============================================*/
+	Y = - FLOOR(Half - TwoForty * LOG(UfThold) / LOG(HInvrse)) / TwoForty;
+	Y2 = Y + Y;
+	printf("Since underflow occurs below the threshold\n");
+	printf("UfThold = (%.17e) ^ (%.17e)\nonly underflow ", HInvrse, Y);
+	printf("should afflict the expression\n\t(%.17e) ^ (%.17e);\n", HInvrse, Y);
+	V9 = POW(HInvrse, Y2);
+	printf("actually calculating yields: %.17e .\n", V9);
+	if (! ((V9 >= Zero) && (V9 <= (Radix + Radix + E9) * UfThold))) {
+		BadCond(Serious, "this is not between 0 and underflow\n");
+		printf("   threshold = %.17e .\n", UfThold);
+		}
+	else if (! (V9 > UfThold * (One + E9)))
+		printf("This computed value is O.K.\n");
+	else {
+		BadCond(Defect, "this is not between 0 and underflow\n");
+		printf("   threshold = %.17e .\n", UfThold);
+		}
+	/*=============================================*/
+	Milestone = 140;
+	/*=============================================*/
+	printf("\n");
+	/* ...calculate Exp2 == exp(2) == 7.389056099... */
+	X = Zero;
+	I = 2;
+	Y = Two * Three;
+	Q = Zero;
+	N = 0;
+	do  {
+		Z = X;
+		I = I + 1;
+		Y = Y / (I + I);
+		R = Y + Q;
+		X = Z + R;
+		Q = (Z - X) + R;
+		} while(X > Z);
+	Z = (OneAndHalf + One / Eight) + X / (OneAndHalf * ThirtyTwo);
+	X = Z * Z;
+	Exp2 = X * X;
+	X = F9;
+	Y = X - U1;
+	printf("Testing X^((X + 1) / (X - 1)) vs. exp(2) = %.17e as X -> 1.\n",
+		Exp2);
+	for(I = 1;;) {
+		Z = X - BInvrse;
+		Z = (X + One) / (Z - (One - BInvrse));
+		Q = POW(X, Z) - Exp2;
+		if (FABS(Q) > TwoForty * U2) {
+			N = 1;
+	 		V9 = (X - BInvrse) - (One - BInvrse);
+			BadCond(Defect, "Calculated");
+			printf(" %.17e for\n", POW(X,Z));
+			printf("\t(1 + (%.17e) ^ (%.17e);\n", V9, Z);
+			printf("\tdiffers from correct value by %.17e .\n", Q);
+			printf("\tThis much error may spoil financial\n");
+			printf("\tcalculations involving tiny interest rates.\n");
+			break;
+			}
+		else {
+			Z = (Y - X) * Two + Y;
+			X = Y;
+			Y = Z;
+			Z = One + (X - F9)*(X - F9);
+			if (Z > One && I < NoTrials) I++;
+			else  {
+				if (X > One) {
+					if (N == 0)
+					   printf("Accuracy seems adequate.\n");
+					break;
+					}
+				else {
+					X = One + U2;
+					Y = U2 + U2;
+					Y += X;
+					I = 1;
+					}
+				}
+			}
+		}
+	/*=============================================*/
+	Milestone = 150;
+	/*=============================================*/
+	printf("Testing powers Z^Q at four nearly extreme values.\n");
+	N = 0;
+	Z = A1;
+	Q = FLOOR(Half - LOG(C) / LOG(A1));
+	Break = False;
+	do  {
+		X = CInvrse;
+		Y = POW(Z, Q);
+		IsYeqX();
+		Q = - Q;
+		X = C;
+		Y = POW(Z, Q);
+		IsYeqX();
+		if (Z < One) Break = True;
+		else Z = AInvrse;
+		} while ( ! (Break));
+	PrintIfNPositive();
+	if (N == 0) printf(" ... no discrepancies found.\n");
+	printf("\n");
+	
+	/*=============================================*/
+	Milestone = 160;
+	/*=============================================*/
+	Pause();
+	printf("Searching for Overflow threshold:\n");
+	printf("This may generate an error.\n");
+	Y = - CInvrse;
+	V9 = HInvrse * Y;
+	sigsave = sigfpe;
+	if (setjmp(ovfl_buf)) { I = 0; V9 = Y; goto overflow; }
+	do {
+		V = Y;
+		Y = V9;
+		V9 = HInvrse * Y;
+		} while(V9 < Y);
+	I = 1;
+overflow:
+	sigsave = 0;
+	Z = V9;
+	printf("Can `Z = -Y' overflow?\n");
+	printf("Trying it on Y = %.17e .\n", Y);
+	V9 = - Y;
+	V0 = V9;
+	if (V - Y == V + V0) printf("Seems O.K.\n");
+	else {
+		printf("finds a ");
+		BadCond(Flaw, "-(-Y) differs from Y.\n");
+		}
+	if (Z != Y) {
+		BadCond(Serious, "");
+		printf("overflow past %.17e\n\tshrinks to %.17e .\n", Y, Z);
+		}
+	if (I) {
+		Y = V * (HInvrse * U2 - HInvrse);
+		Z = Y + ((One - HInvrse) * U2) * V;
+		if (Z < V0) Y = Z;
+		if (Y < V0) V = Y;
+		if (V0 - V < V0) V = V0;
+		}
+	else {
+		V = Y * (HInvrse * U2 - HInvrse);
+		V = V + ((One - HInvrse) * U2) * Y;
+		}
+	printf("Overflow threshold is V  = %.17e .\n", V);
+	if (I) printf("Overflow saturates at V0 = %.17e .\n", V0);
+	else printf("There is no saturation value because the system traps on overflow.\n");
+	V9 = V * One;
+	printf("No Overflow should be signaled for V * 1 = %.17e\n", V9);
+	V9 = V / One;
+	printf("                           nor for V / 1 = %.17e .\n", V9);
+	printf("Any overflow signal separating this * from the one\n");
+	printf("above is a DEFECT.\n");
+	/*=============================================*/
+	Milestone = 170;
+	/*=============================================*/
+	if (!(-V < V && -V0 < V0 && -UfThold < V && UfThold < V)) {
+		BadCond(Failure, "Comparisons involving ");
+		printf("+-%g, +-%g\nand +-%g are confused by Overflow.",
+			V, V0, UfThold);
+		}
+	/*=============================================*/
+	Milestone = 175;
+	/*=============================================*/
+	printf("\n");
+	for(Indx = 1; Indx <= 3; ++Indx) {
+		switch (Indx)  {
+			case 1: Z = UfThold; break;
+			case 2: Z = E0; break;
+			case 3: Z = PseudoZero; break;
+			}
+		if (Z != Zero) {
+			V9 = SQRT(Z);
+			Y = V9 * V9;
+			if (Y / (One - Radix * E9) < Z
+			   || Y > (One + Radix * E9) * Z) { /* dgh: + E9 --> * E9 */
+				if (V9 > U1) BadCond(Serious, "");
+				else BadCond(Defect, "");
+				printf("Comparison alleges that what prints as Z = %.17e\n", Z);
+				printf(" is too far from sqrt(Z) ^ 2 = %.17e .\n", Y);
+				}
+			}
+		}
+	/*=============================================*/
+	Milestone = 180;
+	/*=============================================*/
+	for(Indx = 1; Indx <= 2; ++Indx) {
+		if (Indx == 1) Z = V;
+		else Z = V0;
+		V9 = SQRT(Z);
+		X = (One - Radix * E9) * V9;
+		V9 = V9 * X;
+		if (((V9 < (One - Two * Radix * E9) * Z) || (V9 > Z))) {
+			Y = V9;
+			if (X < W) BadCond(Serious, "");
+			else BadCond(Defect, "");
+			printf("Comparison alleges that Z = %17e\n", Z);
+			printf(" is too far from sqrt(Z) ^ 2 (%.17e) .\n", Y);
+			}
+		}
+	/*=============================================*/
+	/*SPLIT
+	}
+#include "paranoia.h"
+part8(){
+*/
+	Milestone = 190;
+	/*=============================================*/
+	Pause();
+	X = UfThold * V;
+	Y = Radix * Radix;
+	if (X*Y < One || X > Y) {
+		if (X * Y < U1 || X > Y/U1) BadCond(Defect, "Badly");
+		else BadCond(Flaw, "");
+			
+		printf(" unbalanced range; UfThold * V = %.17e\n\t%s\n",
+			X, "is too far from 1.\n");
+		}
+	/*=============================================*/
+	Milestone = 200;
+	/*=============================================*/
+	for (Indx = 1; Indx <= 5; ++Indx)  {
+		X = F9;
+		switch (Indx)  {
+			case 2: X = One + U2; break;
+			case 3: X = V; break;
+			case 4: X = UfThold; break;
+			case 5: X = Radix;
+			}
+		Y = X;
+		sigsave = sigfpe;
+		if (setjmp(ovfl_buf))
+			printf("  X / X  traps when X = %g\n", X);
+		else {
+			V9 = (Y / X - Half) - Half;
+			if (V9 == Zero) continue;
+			if (V9 == - U1 && Indx < 5) BadCond(Flaw, "");
+			else BadCond(Serious, "");
+			printf("  X / X differs from 1 when X = %.17e\n", X);
+			printf("  instead, X / X - 1/2 - 1/2 = %.17e .\n", V9);
+			}
+		sigsave = 0;
+		}
+	/*=============================================*/
+	Milestone = 210;
+	/*=============================================*/
+	MyZero = Zero;
+	printf("\n");
+	printf("What message and/or values does Division by Zero produce?\n") ;
+#ifndef NOPAUSE
+	printf("This can interupt your program.  You can ");
+	printf("skip this part if you wish.\n");
+	printf("Do you wish to compute 1 / 0? ");
+	fflush(stdout);
+	read (KEYBOARD, ch, 8);
+	if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+		sigsave = sigfpe;
+		printf("    Trying to compute 1 / 0 produces ...");
+		if (!setjmp(ovfl_buf)) printf("  %.7e .\n", One / MyZero);
+		sigsave = 0;
+#ifndef NOPAUSE
+		}
+	else printf("O.K.\n");
+	printf("\nDo you wish to compute 0 / 0? ");
+	fflush(stdout);
+	read (KEYBOARD, ch, 80);
+	if ((ch[0] == 'Y') || (ch[0] == 'y')) {
+#endif
+		sigsave = sigfpe;
+		printf("\n    Trying to compute 0 / 0 produces ...");
+		if (!setjmp(ovfl_buf)) printf("  %.7e .\n", Zero / MyZero);
+		sigsave = 0;
+#ifndef NOPAUSE
+		}
+	else printf("O.K.\n");
+#endif
+	/*=============================================*/
+	Milestone = 220;
+	/*=============================================*/
+	Pause();
+	printf("\n");
+	{
+		static char *msg[] = {
+			"FAILUREs  encountered =",
+			"SERIOUS DEFECTs  discovered =",
+			"DEFECTs  discovered =",
+			"FLAWs  discovered =" };
+		int i;
+		for(i = 0; i < 4; i++) if (ErrCnt[i])
+			printf("The number of  %-29s %d.\n",
+				msg[i], ErrCnt[i]);
+		}
+	printf("\n");
+	if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect]
+			+ ErrCnt[Flaw]) > 0) {
+		if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[
+			Defect] == 0) && (ErrCnt[Flaw] > 0)) {
+			printf("The arithmetic diagnosed seems ");
+			printf("Satisfactory though flawed.\n");
+			}
+		if ((ErrCnt[Failure] + ErrCnt[Serious] == 0)
+			&& ( ErrCnt[Defect] > 0)) {
+			printf("The arithmetic diagnosed may be Acceptable\n");
+			printf("despite inconvenient Defects.\n");
+			}
+		if ((ErrCnt[Failure] + ErrCnt[Serious]) > 0) {
+			printf("The arithmetic diagnosed has ");
+			printf("unacceptable Serious Defects.\n");
+			}
+		if (ErrCnt[Failure] > 0) {
+			printf("Potentially fatal FAILURE may have spoiled this");
+			printf(" program's subsequent diagnoses.\n");
+			}
+		}
+	else {
+		printf("No failures, defects nor flaws have been discovered.\n");
+		if (! ((RMult == Rounded) && (RDiv == Rounded)
+			&& (RAddSub == Rounded) && (RSqrt == Rounded))) 
+			printf("The arithmetic diagnosed seems Satisfactory.\n");
+		else {
+			if (StickyBit >= One &&
+				(Radix - Two) * (Radix - Nine - One) == Zero) {
+				printf("Rounding appears to conform to ");
+				printf("the proposed IEEE standard P");
+				if ((Radix == Two) &&
+					 ((Precision - Four * Three * Two) *
+					  ( Precision - TwentySeven -
+					   TwentySeven + One) == Zero)) 
+					printf("754");
+				else printf("854");
+				if (IEEE) printf(".\n");
+				else {
+					printf(",\nexcept for possibly Double Rounding");
+					printf(" during Gradual Underflow.\n");
+					}
+				}
+			printf("The arithmetic diagnosed appears to be Excellent!\n");
+			}
+		}
+	if (fpecount)
+		printf("\nA total of %d floating point exceptions were registered.\n",
+			fpecount);
+	printf("END OF TEST.\n");
+	return 0;
+	}
+
+/*SPLIT subs.c
+#include "paranoia.h"
+*/
+
+/* Sign */
+
+FLOAT Sign (X)
+FLOAT X;
+{ return X >= 0. ? 1.0 : -1.0; }
+
+/* Pause */
+
+Pause()
+{
+#ifndef NOPAUSE
+	char ch[8];
+
+	printf("\nTo continue, press RETURN");
+	fflush(stdout);
+	read(KEYBOARD, ch, 8);
+#endif
+	printf("\nDiagnosis resumes after milestone Number %d", Milestone);
+	printf("          Page: %d\n\n", PageNo);
+	++Milestone;
+	++PageNo;
+	}
+
+ /* TstCond */
+
+TstCond (K, Valid, T)
+int K, Valid;
+char *T;
+{ if (! Valid) { BadCond(K,T); printf(".\n"); } }
+
+BadCond(K, T)
+int K;
+char *T;
+{
+	static char *msg[] = { "FAILURE", "SERIOUS DEFECT", "DEFECT", "FLAW" };
+
+	ErrCnt [K] = ErrCnt [K] + 1;
+	printf("%s:  %s", msg[K], T);
+	}
+
+/* Random */
+/*  Random computes
+     X = (Random1 + Random9)^5
+     Random1 = X - FLOOR(X) + 0.000005 * X;
+   and returns the new value of Random1
+*/
+
+FLOAT Random()
+{
+	FLOAT X, Y;
+	
+	X = Random1 + Random9;
+	Y = X * X;
+	Y = Y * Y;
+	X = X * Y;
+	Y = X - FLOOR(X);
+	Random1 = Y + X * 0.000005;
+	return(Random1);
+	}
+
+/* SqXMinX */
+
+SqXMinX (ErrKind)
+int ErrKind;
+{
+	FLOAT XA, XB;
+	
+	XB = X * BInvrse;
+	XA = X - XB;
+	SqEr = ((SQRT(X * X) - XB) - XA) / OneUlp;
+	if (SqEr != Zero) {
+		if (SqEr < MinSqEr) MinSqEr = SqEr;
+		if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+		J = J + 1.0;
+		BadCond(ErrKind, "\n");
+		printf("sqrt( %.17e) - %.17e  = %.17e\n", X * X, X, OneUlp * SqEr);
+		printf("\tinstead of correct value 0 .\n");
+		}
+	}
+
+/* NewD */
+
+NewD()
+{
+	X = Z1 * Q;
+	X = FLOOR(Half - X / Radix) * Radix + X;
+	Q = (Q - X * Z) / Radix + X * X * (D / Radix);
+	Z = Z - Two * X * D;
+	if (Z <= Zero) {
+		Z = - Z;
+		Z1 = - Z1;
+		}
+	D = Radix * D;
+	}
+
+/* SR3750 */
+
+SR3750()
+{
+	if (! ((X - Radix < Z2 - Radix) || (X - Z2 > W - Z2))) {
+		I = I + 1;
+		X2 = SQRT(X * D);
+		Y2 = (X2 - Z2) - (Y - Z2);
+		X2 = X8 / (Y - Half);
+		X2 = X2 - Half * X2 * X2;
+		SqEr = (Y2 + Half) + (Half - X2);
+		if (SqEr < MinSqEr) MinSqEr = SqEr;
+		SqEr = Y2 - X2;
+		if (SqEr > MaxSqEr) MaxSqEr = SqEr;
+		}
+	}
+
+/* IsYeqX */
+
+IsYeqX()
+{
+	if (Y != X) {
+		if (N <= 0) {
+			if (Z == Zero && Q <= Zero)
+				printf("WARNING:  computing\n");
+			else BadCond(Defect, "computing\n");
+			printf("\t(%.17e) ^ (%.17e)\n", Z, Q);
+			printf("\tyielded %.17e;\n", Y);
+			printf("\twhich compared unequal to correct %.17e ;\n",
+				X);
+			printf("\t\tthey differ by %.17e .\n", Y - X);
+			}
+		N = N + 1; /* ... count discrepancies. */
+		}
+	}
+
+/* SR3980 */
+
+SR3980()
+{
+	do {
+		Q = (FLOAT) I;
+		Y = POW(Z, Q);
+		IsYeqX();
+		if (++I > M) break;
+		X = Z * X;
+		} while ( X < W );
+	}
+
+/* PrintIfNPositive */
+
+PrintIfNPositive()
+{
+	if (N > 0) printf("Similar discrepancies have occurred %d times.\n", N);
+	}
+
+/* TstPtUf */
+
+TstPtUf()
+{
+	N = 0;
+	if (Z != Zero) {
+		printf("Since comparison denies Z = 0, evaluating ");
+		printf("(Z + Z) / Z should be safe.\n");
+		sigsave = sigfpe;
+		if (setjmp(ovfl_buf)) goto very_serious;
+		Q9 = (Z + Z) / Z;
+		printf("What the machine gets for (Z + Z) / Z is  %.17e .\n",
+			Q9);
+		if (FABS(Q9 - Two) < Radix * U2) {
+			printf("This is O.K., provided Over/Underflow");
+			printf(" has NOT just been signaled.\n");
+			}
+		else {
+			if ((Q9 < One) || (Q9 > Two)) {
+very_serious:
+				N = 1;
+				ErrCnt [Serious] = ErrCnt [Serious] + 1;
+				printf("This is a VERY SERIOUS DEFECT!\n");
+				}
+			else {
+				N = 1;
+				ErrCnt [Defect] = ErrCnt [Defect] + 1;
+				printf("This is a DEFECT!\n");
+				}
+			}
+		sigsave = 0;
+		V9 = Z * One;
+		Random1 = V9;
+		V9 = One * Z;
+		Random2 = V9;
+		V9 = Z / One;
+		if ((Z == Random1) && (Z == Random2) && (Z == V9)) {
+			if (N > 0) Pause();
+			}
+		else {
+			N = 1;
+			BadCond(Defect, "What prints as Z = ");
+			printf("%.17e\n\tcompares different from  ", Z);
+			if (Z != Random1) printf("Z * 1 = %.17e ", Random1);
+			if (! ((Z == Random2)
+				|| (Random2 == Random1)))
+				printf("1 * Z == %g\n", Random2);
+			if (! (Z == V9)) printf("Z / 1 = %.17e\n", V9);
+			if (Random2 != Random1) {
+				ErrCnt [Defect] = ErrCnt [Defect] + 1;
+				BadCond(Defect, "Multiplication does not commute!\n");
+				printf("\tComparison alleges that 1 * Z = %.17e\n",
+					Random2);
+				printf("\tdiffers from Z * 1 = %.17e\n", Random1);
+				}
+			Pause();
+			}
+		}
+	}
+
+notify(s)
+char *s;
+{
+	printf("%s test appears to be inconsistent...\n", s);
+	printf("   PLEASE NOTIFY KARPINKSI!\n");
+	}
+
+/*SPLIT msgs.c */
+
+/* Instructions */
+
+msglist(s)
+char **s;
+{ while(*s) printf("%s\n", *s++); }
+
+Instructions()
+{
+  static char *instr[] = {
+	"Lest this program stop prematurely, i.e. before displaying\n",
+	"    `END OF TEST',\n",
+	"try to persuade the computer NOT to terminate execution when an",
+	"error like Over/Underflow or Division by Zero occurs, but rather",
+	"to persevere with a surrogate value after, perhaps, displaying some",
+	"warning.  If persuasion avails naught, don't despair but run this",
+	"program anyway to see how many milestones it passes, and then",
+	"amend it to make further progress.\n",
+	"Answer questions with Y, y, N or n (unless otherwise indicated).\n",
+	0};
+
+	msglist(instr);
+	}
+
+/* Heading */
+
+Heading()
+{
+  static char *head[] = {
+	"Users are invited to help debug and augment this program so it will",
+	"cope with unanticipated and newly uncovered arithmetic pathologies.\n",
+	"Please send suggestions and interesting results to",
+	"\tRichard Karpinski",
+	"\tComputer Center U-76",
+	"\tUniversity of California",
+	"\tSan Francisco, CA 94143-0704, USA\n",
+	"In doing so, please include the following information:",
+#ifdef Single
+	"\tPrecision:\tsingle;",
+#else
+	"\tPrecision:\tdouble;",
+#endif
+	"\tVersion:\t10 February 1989;",
+	"\tComputer:\n",
+	"\tCompiler:\n",
+	"\tOptimization level:\n",
+	"\tOther relevant compiler options:",
+	0};
+
+	msglist(head);
+	}
+
+/* Characteristics */
+
+Characteristics()
+{
+	static char *chars[] = {
+	 "Running this program should reveal these characteristics:",
+	"     Radix = 1, 2, 4, 8, 10, 16, 100, 256 ...",
+	"     Precision = number of significant digits carried.",
+	"     U2 = Radix/Radix^Precision = One Ulp",
+	"\t(OneUlpnit in the Last Place) of 1.000xxx .",
+	"     U1 = 1/Radix^Precision = One Ulp of numbers a little less than 1.0 .",
+	"     Adequacy of guard digits for Mult., Div. and Subt.",
+	"     Whether arithmetic is chopped, correctly rounded, or something else",
+	"\tfor Mult., Div., Add/Subt. and Sqrt.",
+	"     Whether a Sticky Bit used correctly for rounding.",
+	"     UnderflowThreshold = an underflow threshold.",
+	"     E0 and PseudoZero tell whether underflow is abrupt, gradual, or fuzzy.",
+	"     V = an overflow threshold, roughly.",
+	"     V0  tells, roughly, whether  Infinity  is represented.",
+	"     Comparisions are checked for consistency with subtraction",
+	"\tand for contamination with pseudo-zeros.",
+	"     Sqrt is tested.  Y^X is not tested.",
+	"     Extra-precise subexpressions are revealed but NOT YET tested.",
+	"     Decimal-Binary conversion is NOT YET tested for accuracy.",
+	0};
+
+	msglist(chars);
+	}
+
+History()
+
+{ /* History */
+ /* Converted from Brian Wichmann's Pascal version to C by Thos Sumner,
+	with further massaging by David M. Gay. */
+
+  static char *hist[] = {
+	"The program attempts to discriminate among",
+	"   FLAWs, like lack of a sticky bit,",
+	"   Serious DEFECTs, like lack of a guard digit, and",
+	"   FAILUREs, like 2+2 == 5 .",
+	"Failures may confound subsequent diagnoses.\n",
+	"The diagnostic capabilities of this program go beyond an earlier",
+	"program called `MACHAR', which can be found at the end of the",
+	"book  `Software Manual for the Elementary Functions' (1980) by",
+	"W. J. Cody and W. Waite. Although both programs try to discover",
+	"the Radix, Precision and range (over/underflow thresholds)",
+	"of the arithmetic, this program tries to cope with a wider variety",
+	"of pathologies, and to say how well the arithmetic is implemented.",
+	"\nThe program is based upon a conventional radix representation for",
+	"floating-point numbers, but also allows logarithmic encoding",
+	"as used by certain early WANG machines.\n",
+	"BASIC version of this program (C) 1983 by Prof. W. M. Kahan;",
+	"see source comments for more history.",
+	0};
+
+	msglist(hist);
+	}
+
+double
+pow(x, y) /* return x ^ y (exponentiation) */
+double x, y;
+{
+	extern double exp(), frexp(), ldexp(), log(), modf();
+	double xy, ye;
+	long i;
+	int ex, ey = 0, flip = 0;
+
+	if (!y) return 1.0;
+
+	if ((y < -1100. || y > 1100.) && x != -1.) return exp(y * log(x));
+
+	if (y < 0.) { y = -y; flip = 1; }
+	y = modf(y, &ye);
+	if (y) xy = exp(y * log(x));
+	else xy = 1.0;
+	/* next several lines assume >= 32 bit integers */
+	x = frexp(x, &ex);
+	if (i = ye) for(;;) {
+		if (i & 1) { xy *= x; ey += ex; }
+		if (!(i >>= 1)) break;
+		x *= x;
+		ex *= 2;
+		if (x < .5) { x *= 2.; ex -= 1; }
+		}
+	if (flip) { xy = 1. / xy; ey = -ey; }
+	return ldexp(xy, ey);
+}
diff --git a/code/tools/lcc/tst/sort.0 b/code/tools/lcc/tst/sort.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/sort.0
diff --git a/code/tools/lcc/tst/sort.c b/code/tools/lcc/tst/sort.c
new file mode 100644
index 0000000..a0cff62
--- /dev/null
+++ b/code/tools/lcc/tst/sort.c
@@ -0,0 +1,65 @@
+int in[] = {10, 32, -1, 567, 3, 18, 1, -51, 789, 0};
+
+main() {
+	int i;
+
+	sort(in, (sizeof in)/(sizeof in[0]));
+	for (i = 0; i < (sizeof in)/(sizeof in[0]); i++) {
+		putd(in[i]);
+		putchar('\n');
+	}
+	return 0;
+}
+
+/* putd - output decimal number */
+putd(n) {
+	if (n < 0) {
+		putchar('-');
+		n = -n;
+	}
+	if (n/10)
+		putd(n/10);
+	putchar(n%10 + '0');
+}
+
+int *xx;
+
+/* sort - sort a[0..n-1] into increasing order */
+sort(a, n) int a[]; {
+	quick(xx = a, 0, --n);
+}
+
+/* quick - quicksort a[lb..ub] */
+quick(a, lb, ub) int a[]; {
+	int k, partition();
+
+	if (lb >= ub)
+		return;
+	k = partition(a, lb, ub);
+	quick(a, lb, k - 1);
+	quick(a, k + 1, ub);
+}
+
+/* partition - partition a[i..j] */
+int partition(a, i, j) int a[]; {
+	int v, k;
+
+	j++;
+	k = i;
+	v = a[k];
+	while (i < j) {
+		i++; while (a[i] < v) i++;
+		j--; while (a[j] > v) j--;
+		if (i < j) exchange(&a[i], &a[j]);
+	}
+	exchange(&a[k], &a[j]);
+	return j;
+}
+
+/* exchange - exchange *x and *y */
+exchange(x, y) int *x, *y; {
+	int t;
+
+	printf("exchange(%d,%d)\n", x - xx, y - xx);
+	t = *x; *x = *y; *y = t;
+}
diff --git a/code/tools/lcc/tst/spill.0 b/code/tools/lcc/tst/spill.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/spill.0
diff --git a/code/tools/lcc/tst/spill.c b/code/tools/lcc/tst/spill.c
new file mode 100644
index 0000000..2c5da81
--- /dev/null
+++ b/code/tools/lcc/tst/spill.c
@@ -0,0 +1,17 @@
+main(){}
+
+f(i){i=f()+f();}
+
+f2(i){i=f()+(i?f():1);}
+
+f3(int i,int *p){register r1=0,r2=0,r3=0,r4=0,r5=0,r6=0,r7=0,r8=0,r9=0,r10=0;*p++=i?f():0;}
+
+double a[10],b[10];int i;f4(){register r6=0,r7=0,r8=0,r9=0,r10=0,r11=0;i=a[i]+b[i] && i && a[i]-b[i];}
+/* f4 causes parent to spill child on vax when odd double regs are enabled */
+
+int j, k, m, n;
+double *A, *B, x;
+f5(){
+	x=A[k*m]*A[j*m]+B[k*n]*B[j*n];
+	x=A[k*m]*B[j*n]-B[k*n]*A[j*m];
+}  
diff --git a/code/tools/lcc/tst/stdarg.0 b/code/tools/lcc/tst/stdarg.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/stdarg.0
diff --git a/code/tools/lcc/tst/stdarg.c b/code/tools/lcc/tst/stdarg.c
new file mode 100644
index 0000000..c6a5338
--- /dev/null
+++ b/code/tools/lcc/tst/stdarg.c
@@ -0,0 +1,51 @@
+#include <stdarg.h>
+
+struct node { int a[4]; } x = {1,2,3,4};
+
+print(char *fmt, ...);
+
+main() {
+	print("test 1\n");
+	print("test %s\n", "2");
+	print("test %d%c", 3, '\n');
+	print("%s%s %w%c", "te", "st", 4, '\n');
+	print("%s%s %f%c", "te", "st", 5.0, '\n');
+	print("%b %b %b %b %b %b\n", x, x, x, x, x, x);
+	return 0;
+}
+
+print(char *fmt, ...) {
+	va_list ap;
+
+	va_start(ap, fmt);
+	for (; *fmt; fmt++)
+		if (*fmt == '%')
+			switch (*++fmt) {
+			case 'b': {
+				struct node x = va_arg(ap, struct node);
+				printf("{%d %d %d %d}", x.a[0], x.a[1], x.a[2], x.a[3]);
+				break;
+				}
+			case 'c':
+				printf("%c", va_arg(ap, char));
+				break;
+			case 'd':
+				printf("%d", va_arg(ap, int));
+				break;
+			case 'w':
+				printf("%x", va_arg(ap, short));
+				break;
+			case 's':
+				printf("%s", va_arg(ap, char *));
+				break;
+			case 'f':
+				printf("%f", va_arg(ap, double));
+				break;
+			default:
+				printf("%c", *fmt);
+				break;
+			}
+		 else
+			printf("%c", *fmt);
+	va_end(ap);
+}
diff --git a/code/tools/lcc/tst/struct.0 b/code/tools/lcc/tst/struct.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/struct.0
diff --git a/code/tools/lcc/tst/struct.c b/code/tools/lcc/tst/struct.c
new file mode 100644
index 0000000..fe81681
--- /dev/null
+++ b/code/tools/lcc/tst/struct.c
@@ -0,0 +1,69 @@
+typedef struct point { int x,y; } point;
+typedef struct rect { point pt1, pt2; } rect;
+
+point addpoint(point p1, point p2) {	/* add two points */
+	p1.x += p2.x;
+	p1.y += p2.y;
+	return p1;
+}
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+rect canonrect(rect r) {		/* canonicalize rectangle coordinates */
+	rect temp;
+
+	temp.pt1.x = min(r.pt1.x, r.pt2.x);
+	temp.pt1.y = min(r.pt1.y, r.pt2.y);
+	temp.pt2.x = max(r.pt1.x, r.pt2.x);
+	temp.pt2.y = max(r.pt1.y, r.pt2.y);
+	return temp;
+}
+
+point makepoint(int x, int y) {		/* make a point from x and y components */
+	point p;
+
+	p.x = x;
+	p.y = y;
+	return p;
+}
+
+rect makerect(point p1, point p2) {	/* make a rectangle from two points */
+	rect r;
+
+	r.pt1 = p1;
+	r.pt2 = p2;
+	return canonrect(r);
+}
+
+int ptinrect(point p, rect r) {		/* is p in r? */
+	return p.x >= r.pt1.x && p.x < r.pt2.x
+		&& p.y >= r.pt1.y && p.y < r.pt2.y;
+}
+
+struct odd {char a[3]; } y = {'a', 'b', 0};
+
+odd(struct odd y) {
+	struct odd x = y;
+	printf("%s\n", x.a);
+}
+
+main() {
+	int i;
+	point x, origin = { 0, 0 }, maxpt = { 320, 320 };
+	point pts[] = { -1, -1, 1, 1, 20, 300, 500, 400 };
+	rect screen = makerect(addpoint(maxpt, makepoint(-10, -10)),
+		addpoint(origin, makepoint(10, 10)));
+
+	for (i = 0; i < sizeof pts/sizeof pts[0]; i++) {
+		printf("(%d,%d) is ", pts[i].x,
+			(x = makepoint(pts[i].x, pts[i].y)).y);
+		if (ptinrect(x, screen) == 0)
+			printf("not ");
+		printf("within [%d,%d; %d,%d]\n", screen.pt1.x, screen.pt1.y,
+			screen.pt2.x, screen.pt2.y);
+	}
+	odd(y);
+	exit(0);
+}
+
diff --git a/code/tools/lcc/tst/switch.0 b/code/tools/lcc/tst/switch.0
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/code/tools/lcc/tst/switch.0
diff --git a/code/tools/lcc/tst/switch.c b/code/tools/lcc/tst/switch.c
new file mode 100644
index 0000000..dd62d79
--- /dev/null
+++ b/code/tools/lcc/tst/switch.c
@@ -0,0 +1,137 @@
+main()
+{
+	int i; char *s;
+
+	for (s = "bfnrtvx"; *s; s++)
+		printf("%c = 0x%x\n", *s, backslash(*s));
+	f();
+	g();
+	h();
+	for (i = 0x1000000; i&0x7000000; i += 0x1000000)
+		big(i);
+	limit();
+	return 0;
+}	
+
+backslash(c)
+{
+	switch (c) {
+	case 'b':
+		return '\b';
+	case 'f':
+		return '\f';
+	case 'n':
+		return '\n';
+	case 'r':
+		return '\r';
+	case 't':
+		return '\t';
+	case 'v':
+		return '\v';
+	}
+	return c;
+}
+
+f() {
+	int i, x = 0, y;
+
+	printf("f:\n");
+	for (i = 0; i <= 20; i++) {
+		y = i;
+		switch (i) {
+		case 1: x = i; break;
+		case 2: x = i; break;
+		case 7: x = i; break;
+		case 8: x = i; break;
+		case 9: x = i; break;
+		case 16: x = i; break;
+		case 17: x = i; break;
+		case 18: x = i; break;
+		case 19: x = i; break;
+		case 20: x = i; break;
+		}
+		printf("x = %d\n", x);
+	}
+}
+
+g() {
+	int i;
+
+	printf("g:\n");
+	for (i = 1; i <= 10; i++)
+		switch (i) {
+		case 1: case 2: printf("1 %d\n", i); break;
+		case 3: case 4: case 5: printf("2 %d\n", i); break;
+		case 6: case 7: case 8: printf("3 %d\n", i);
+		default:
+			printf("d %d\n", i); break;
+		case 1001: case 1002: case 1003: case 1004:
+			printf("5 %d\n", i); break;
+		case 3001: case 3002: case 3003: case 3004:
+			printf("6 %d\n", i); break;
+	}
+}
+
+h()
+{
+	int i, n=0;
+
+	printf("h:\n");
+	for (i = 1; i <= 500; i++)
+		switch (i) {
+		default: n++; continue;
+		case 128: printf("i = %d\n", i); break;
+		case 16: printf("i = %d\n", i); break;
+		case 8: printf("i = %d\n", i); break;
+		case 120: printf("i = %d\n", i); break;
+		case 280: printf("i = %d\n", i); break;
+		case 264: printf("i = %d\n", i); break;
+		case 248: printf("i = %d\n", i); break;
+		case 272: printf("i = %d\n", i); break;
+		case 304: printf("i = %d\n", i); break;
+		case 296: printf("i = %d\n", i); break;
+		case 288: printf("i = %d\n", i); break;
+		case 312: printf("i = %d\n", i); break;
+		}
+	printf("%d defaults\n", n);
+}
+
+big(x) unsigned x; {
+	switch(x&0x6000000){
+	case -1:
+	case -2:
+	case 0x0000000:
+		printf("x = 0x%x\n", x); break;
+	case 0x2000000:
+		printf("x = 0x%x\n", x); break;
+	case 0x4000000:
+		printf("x = 0x%x\n", x); break;
+	default:
+		printf("x = 0x%x (default)\n", x); break;
+	}
+}
+
+#include <limits.h>
+
+limit() {
+	int i;
+
+	for (i = INT_MIN; i <= INT_MIN+5; i++)
+		switch (i) {
+		case INT_MIN:	printf("0\n"); break;
+		case INT_MIN+1:	printf("1\n"); break;
+		case INT_MIN+2:	printf("2\n"); break;
+		case INT_MIN+3:	printf("3\n"); break;
+		case INT_MIN+4:	printf("4\n"); break;
+		default:	printf("5\n"); break;
+		}
+	for (i = INT_MAX; i >= INT_MAX-5; i--)
+		switch (i) {
+		case INT_MAX:	printf("0\n"); break;
+		case INT_MAX-1:	printf("1\n"); break;
+		case INT_MAX-2:	printf("2\n"); break;
+		case INT_MAX-3:	printf("3\n"); break;
+		case INT_MAX-4:	printf("4\n"); break;
+		default:	printf("5\n"); break;
+		}
+}
diff --git a/code/tools/lcc/tst/wf1.0 b/code/tools/lcc/tst/wf1.0
new file mode 100644
index 0000000..761b526
--- /dev/null
+++ b/code/tools/lcc/tst/wf1.0
@@ -0,0 +1,115 @@
+/* wf1 - print word frequencies; uses structures */
+
+struct node {
+	int count;		/* frequency count */
+	struct node *left;	/* left subtree */
+	struct node *right;	/* right subtree */
+	char *word;		/* word itself */
+} words[2000];
+int next;		/* index of next free entry in words */
+
+struct node *lookup();
+
+main()
+{
+	struct node *root;
+	char word[20];
+
+	root = 0;
+	next = 0;
+	while (getword(word))
+		lookup(word, &root)->count++;
+	tprint(root);
+	return 0;
+}
+
+/* err - print error message s and die	*/
+err(s)
+char *s;
+{
+	printf("? %s\n", s);
+	exit(1);
+}
+
+/* getword - get next input word into buf, return 0 on EOF */
+int getword(buf)
+char *buf;
+{
+	char *s;
+	int c;
+
+	while ((c = getchar()) != -1 && isletter(c) == 0)
+		;
+	for (s = buf; c = isletter(c); c = getchar())
+		*s++ = c;
+	*s = 0;
+	if (s > buf)
+		return (1);
+	return (0);
+}
+
+/* isletter - return folded version of c if it is a letter, 0 otherwise */
+int isletter(c)
+int c;
+{
+	if (c >= 'A' && c <= 'Z')
+		c += 'a' - 'A';
+	if (c >= 'a' && c <= 'z')
+		return (c);
+	return (0);
+}
+
+/* lookup - lookup word in tree; install if necessary */
+struct node *lookup(word, p)
+char *word;
+struct node **p;
+{
+	int cond;
+	char *malloc();
+
+	if (*p) {
+		cond = strcmp(word, (*p)->word);
+		if (cond < 0)
+			return lookup(word, &(*p)->left);
+		else if (cond > 0)
+			return lookup(word, &(*p)->right);
+		else
+			return *p;
+	}
+	if (next >= 2000)
+		err("out of node storage");
+	words[next].count = 0;
+	words[next].left = words[next].right = 0;
+	words[next].word = malloc(strlen(word) + 1);
+	if (words[next].word == 0)
+		err("out of word storage");
+	strcpy(words[next].word, word);
+	return *p = &words[next++];
+}
+
+/* tprint - print tree */
+tprint(tree)
+struct node *tree;
+{
+	if (tree) {
+		tprint(tree->left);
+		printf("%d\t%s\n", tree->count, tree->word);
+		tprint(tree->right);
+	}
+}
+
+/* strcmp - compare s1 and s2, return <0, 0, or >0 */
+int strcmp(s1, s2)
+char *s1, *s2;
+{
+	while (*s1 == *s2) {
+		if (*s1++ == 0)
+			return 0;
+		++s2;
+	}
+	if (*s1 == 0)
+		return -1;
+	else if (*s2 == 0)
+		return 1;
+	return *s1 - *s2;
+}
diff --git a/code/tools/lcc/tst/wf1.c b/code/tools/lcc/tst/wf1.c
new file mode 100644
index 0000000..d0c6e32
--- /dev/null
+++ b/code/tools/lcc/tst/wf1.c
@@ -0,0 +1,101 @@
+/* wf1 - print word frequencies; uses structures */
+
+struct node {
+	int count;		/* frequency count */
+	struct node *left;	/* left subtree */
+	struct node *right;	/* right subtree */
+	char *word;		/* word itself */
+} words[2000];
+int next;		/* index of next free entry in words */
+
+struct node *lookup();
+
+main() {
+	struct node *root;
+	char word[20];
+
+	root = 0;
+	next = 0;
+	while (getword(word))
+		lookup(word, &root)->count++;
+	tprint(root);
+	return 0;
+}
+
+/* err - print error message s and die	*/
+err(s) char *s; {
+	printf("? %s\n", s);
+	exit(1);
+}
+
+/* getword - get next input word into buf, return 0 on EOF */
+int getword(buf) char *buf; {
+	char *s;
+	int c;
+
+	while ((c = getchar()) != -1 && isletter(c) == 0)
+		;
+	for (s = buf; c = isletter(c); c = getchar())
+		*s++ = c;
+	*s = 0;
+	if (s > buf)
+		return (1);
+	return (0);
+}
+
+/* isletter - return folded version of c if it is a letter, 0 otherwise */
+int isletter(c) {
+	if (c >= 'A' && c <= 'Z')
+		c += 'a' - 'A';
+	if (c >= 'a' && c <= 'z')
+		return (c);
+	return (0);
+}
+
+/* lookup - lookup word in tree; install if necessary */
+struct node *lookup(word, p) char *word; struct node **p; {
+	int cond;
+	char *malloc();
+
+	if (*p) {
+		cond = strcmp(word, (*p)->word);
+		if (cond < 0)
+			return lookup(word, &(*p)->left);
+		else if (cond > 0)
+			return lookup(word, &(*p)->right);
+		else
+			return *p;
+	}
+	if (next >= 2000)
+		err("out of node storage");
+	words[next].count = 0;
+	words[next].left = words[next].right = 0;
+	words[next].word = malloc(strlen(word) + 1);
+	if (words[next].word == 0)
+		err("out of word storage");
+	strcpy(words[next].word, word);
+	return *p = &words[next++];
+}
+
+/* tprint - print tree */
+tprint(tree) struct node *tree; {
+	if (tree) {
+		tprint(tree->left);
+		printf("%d\t%s\n", tree->count, tree->word);
+		tprint(tree->right);
+	}
+}
+
+/* strcmp - compare s1 and s2, return <0, 0, or >0 */
+int strcmp(s1, s2) char *s1, *s2; {
+	while (*s1 == *s2) {
+		if (*s1++ == 0)
+			return 0;
+		++s2;
+	}
+	if (*s1 == 0)
+		return -1;
+	else if (*s2 == 0)
+		return 1;
+	return *s1 - *s2;
+}
diff --git a/code/tools/lcc/tst/yacc.0 b/code/tools/lcc/tst/yacc.0
new file mode 100644
index 0000000..46de7cb
--- /dev/null
+++ b/code/tools/lcc/tst/yacc.0
@@ -0,0 +1 @@
+a=-b+5*c
diff --git a/code/tools/lcc/tst/yacc.c b/code/tools/lcc/tst/yacc.c
new file mode 100644
index 0000000..3e297d2
--- /dev/null
+++ b/code/tools/lcc/tst/yacc.c
@@ -0,0 +1,591 @@
+# define ID 257
+# define CON 258
+# define UNARYMINUS 259
+#define yyclearin yychar = -1
+#define yyerrok yyerrflag = 0
+extern int yychar;
+extern short yyerrflag;
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 150
+#endif
+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+YYSTYPE yylval, yyval;
+# define YYERRCODE 256
+
+
+
+#include <stdio.h>
+
+# define U(x) x
+# define NLSTATE yyprevious=YYNEWLINE
+# define BEGIN yybgin = yysvec + 1 +
+# define INITIAL 0
+# define YYLERR yysvec
+# define YYSTATE (yyestate-yysvec-1)
+# define YYOPTIM 1
+# define YYLMAX 200
+# define output(c) (void)putc(c,yyout)
+# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
+# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
+# define yymore() (yymorfg=1)
+# define ECHO fprintf(yyout, "%s",yytext)
+# define REJECT { nstr = yyreject(); goto yyfussy;}
+int yyleng; extern char yytext[];
+int yymorfg;
+extern char *yysptr, yysbuf[];
+int yytchar;
+FILE *yyin ={stdin}, *yyout ={stdout};
+extern int yylineno;
+struct yysvf { 
+	struct yywork *yystoff;
+	struct yysvf *yyother;
+	int *yystops;};
+struct yysvf *yyestate;
+extern struct yysvf yysvec[], *yybgin;
+# define YYNEWLINE 10
+yylex(){
+int nstr; extern int yyprevious;
+while((nstr = yylook()) >= 0)
+yyfussy: switch(nstr){
+case 0:
+if(yywrap()) return(0); break;
+case 1:
+ return ID;
+break;
+case 2:
+                 return CON;
+break;
+case 3:
+                  ;
+break;
+case 4:
+                   return yytext[0];
+break;
+case -1:
+break;
+default:
+fprintf(yyout,"bad switch yylook %d",nstr);
+} return(0); }
+/* end of yylex */
+int yyvstop[] ={
+0,
+
+4,
+0,
+
+3,
+4,
+0,
+
+2,
+4,
+0,
+
+1,
+4,
+0,
+
+2,
+0,
+
+1,
+0,
+0};
+# define YYTYPE char
+struct yywork { YYTYPE verify, advance; } yycrank[] ={
+0,0,	0,0,	1,3,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	1,4,	1,3,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	1,5,	5,7,	5,7,	
+5,7,	5,7,	5,7,	5,7,	
+5,7,	5,7,	5,7,	5,7,	
+0,0,	0,0,	0,0,	0,0,	
+0,0,	0,0,	1,6,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	0,0,	0,0,	0,0,	
+0,0,	0,0,	0,0,	0,0,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	0,0,	0,0,	
+0,0,	0,0,	6,8,	0,0,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	6,8,	6,8,	
+6,8,	6,8,	0,0,	0,0,	
+0,0};
+struct yysvf yysvec[] ={
+0,	0,	0,
+yycrank+-1,	0,		0,	
+yycrank+0,	yysvec+1,	0,	
+yycrank+0,	0,		yyvstop+1,
+yycrank+0,	0,		yyvstop+3,
+yycrank+2,	0,		yyvstop+6,
+yycrank+19,	0,		yyvstop+9,
+yycrank+0,	yysvec+5,	yyvstop+12,
+yycrank+0,	yysvec+6,	yyvstop+14,
+0,	0,	0};
+struct yywork *yytop = yycrank+141;
+struct yysvf *yybgin = yysvec+1;
+char yymatch[] ={
+00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
+01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
+01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
+01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
+011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
+01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
+'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
+'0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
+01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,'A' ,
+01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
+'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
+0};
+char yyextra[] ={
+0,0,0,0,0,0,0,0,
+0};
+/*	ncform	4.1	83/08/11	*/
+
+int yylineno =1;
+# define YYU(x) x
+# define NLSTATE yyprevious=YYNEWLINE
+char yytext[YYLMAX];
+struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
+char yysbuf[YYLMAX];
+char *yysptr = yysbuf;
+int *yyfnd;
+extern struct yysvf *yyestate;
+int yyprevious = YYNEWLINE;
+yylook(){
+	register struct yysvf *yystate, **lsp;
+	register struct yywork *yyt;
+	struct yysvf *yyz;
+	int yych;
+	struct yywork *yyr;
+# ifdef LEXDEBUG
+	int debug;
+# endif
+	char *yylastch;
+	/* start off machines */
+# ifdef LEXDEBUG
+	debug = 0;
+# endif
+	if (!yymorfg)
+		yylastch = yytext;
+	else {
+		yymorfg=0;
+		yylastch = yytext+yyleng;
+		}
+	for(;;){
+		lsp = yylstate;
+		yyestate = yystate = yybgin;
+		if (yyprevious==YYNEWLINE) yystate++;
+		for (;;){
+# ifdef LEXDEBUG
+			if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
+# endif
+			yyt = yystate->yystoff;
+			if(yyt == yycrank){		/* may not be any transitions */
+				yyz = yystate->yyother;
+				if(yyz == 0)break;
+				if(yyz->yystoff == yycrank)break;
+				}
+			*yylastch++ = yych = input();
+		tryagain:
+# ifdef LEXDEBUG
+			if(debug){
+				fprintf(yyout,"char ");
+				allprint(yych);
+				putchar('\n');
+				}
+# endif
+			yyr = yyt;
+			if ( yyt > yycrank){
+				yyt = yyr + yych;
+				if (yyt <= yytop && yyt->verify+yysvec == yystate){
+					if(yyt->advance+yysvec == YYLERR)	/* error transitions */
+						{unput(*--yylastch);break;}
+					*lsp++ = yystate = yyt->advance+yysvec;
+					goto contin;
+					}
+				}
+# ifdef YYOPTIM
+			else if(yyt < yycrank) {		/* r < yycrank */
+				yyt = yyr = yycrank+(yycrank-yyt);
+# ifdef LEXDEBUG
+				if(debug)fprintf(yyout,"compressed state\n");
+# endif
+				yyt = yyt + yych;
+				if(yyt <= yytop && yyt->verify+yysvec == yystate){
+					if(yyt->advance+yysvec == YYLERR)	/* error transitions */
+						{unput(*--yylastch);break;}
+					*lsp++ = yystate = yyt->advance+yysvec;
+					goto contin;
+					}
+				yyt = yyr + YYU(yymatch[yych]);
+# ifdef LEXDEBUG
+				if(debug){
+					fprintf(yyout,"try fall back character ");
+					allprint(YYU(yymatch[yych]));
+					putchar('\n');
+					}
+# endif
+				if(yyt <= yytop && yyt->verify+yysvec == yystate){
+					if(yyt->advance+yysvec == YYLERR)	/* error transition */
+						{unput(*--yylastch);break;}
+					*lsp++ = yystate = yyt->advance+yysvec;
+					goto contin;
+					}
+				}
+			if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
+# ifdef LEXDEBUG
+				if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
+# endif
+				goto tryagain;
+				}
+# endif
+			else
+				{unput(*--yylastch);break;}
+		contin:
+# ifdef LEXDEBUG
+			if(debug){
+				fprintf(yyout,"state %d char ",yystate-yysvec-1);
+				allprint(yych);
+				putchar('\n');
+				}
+# endif
+			;
+			}
+# ifdef LEXDEBUG
+		if(debug){
+			fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
+			allprint(yych);
+			putchar('\n');
+			}
+# endif
+		while (lsp-- > yylstate){
+			*yylastch-- = 0;
+			if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
+				yyolsp = lsp;
+				if(yyextra[*yyfnd]){		/* must backup */
+					while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
+						lsp--;
+						unput(*yylastch--);
+						}
+					}
+				yyprevious = YYU(*yylastch);
+				yylsp = lsp;
+				yyleng = yylastch-yytext+1;
+				yytext[yyleng] = 0;
+# ifdef LEXDEBUG
+				if(debug){
+					fprintf(yyout,"\nmatch ");
+					sprint(yytext);
+					fprintf(yyout," action %d\n",*yyfnd);
+					}
+# endif
+				return(*yyfnd++);
+				}
+			unput(*yylastch);
+			}
+		if (yytext[0] == 0  /* && feof(yyin) */)
+			{
+			yysptr=yysbuf;
+			return(0);
+			}
+		yyprevious = yytext[0] = input();
+		if (yyprevious>0)
+			output(yyprevious);
+		yylastch=yytext;
+# ifdef LEXDEBUG
+		if(debug)putchar('\n');
+# endif
+		}
+	}
+yyback(p, m)
+	int *p;
+{
+if (p==0) return(0);
+while (*p)
+	{
+	if (*p++ == m)
+		return(1);
+	}
+return(0);
+}
+	/* the following are only used in the lex library */
+yyinput(){
+	return(input());
+	}
+yyoutput(c)
+  int c; {
+	output(c);
+	}
+yyunput(c)
+   int c; {
+	unput(c);
+	}
+
+main() {
+        yyparse();
+	return 0;
+}
+
+/* yyerror - issue error message */
+yyerror(s) char *s; {
+        printf("%s\n", s);
+}
+short yyexca[] ={
+-1, 1,
+	0, -1,
+	-2, 0,
+	};
+# define YYNPROD 15
+# define YYLAST 249
+short yyact[]={
+
+  12,   2,   9,   8,  17,  11,  25,  17,  15,  18,
+  16,  10,  18,  17,  15,   7,  16,  13,  18,   5,
+   3,   1,   0,  19,  20,   0,   0,  21,  22,  23,
+  24,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   6,  14,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   4,   6 };
+short yypact[]={
+
+-1000,  -9,-1000,   5,  -7, -59,-1000,-1000,-1000, -40,
+ -29, -40, -40,-1000,-1000, -40, -40, -40, -40, -38,
+ -35, -38, -38,-1000,-1000,-1000 };
+short yypgo[]={
+
+   0,  21,  20,  17,  11 };
+short yyr1[]={
+
+   0,   1,   1,   1,   1,   2,   4,   4,   4,   4,
+   4,   4,   4,   4,   3 };
+short yyr2[]={
+
+   0,   0,   2,   3,   3,   3,   3,   3,   3,   3,
+   2,   3,   1,   1,   1 };
+short yychk[]={
+
+-1000,  -1,  10,  -2, 256,  -3, 257,  10,  10,  61,
+  -4,  45,  40,  -3, 258,  43,  45,  42,  47,  -4,
+  -4,  -4,  -4,  -4,  -4,  41 };
+short yydef[]={
+
+   1,  -2,   2,   0,   0,   0,  14,   3,   4,   0,
+   5,   0,   0,  12,  13,   0,   0,   0,   0,  10,
+   0,   6,   7,   8,   9,  11 };
+#ifndef lint
+#endif
+
+# define YYFLAG -1000
+# define YYERROR goto yyerrlab
+# define YYACCEPT return(0)
+# define YYABORT return(1)
+
+/*	parser for yacc output	*/
+
+#ifdef YYDEBUG
+int yydebug = 0; /* 1 for debugging */
+#endif
+YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
+int yychar = -1; /* current input token number */
+int yynerrs = 0;  /* number of errors */
+short yyerrflag = 0;  /* error recovery flag */
+
+yyparse() {
+
+	short yys[YYMAXDEPTH];
+	short yyj, yym;
+	register YYSTYPE *yypvt;
+	register short yystate, *yyps, yyn;
+	register YYSTYPE *yypv;
+	register short *yyxi;
+
+	yystate = 0;
+	yychar = -1;
+	yynerrs = 0;
+	yyerrflag = 0;
+	yyps= &yys[-1];
+	yypv= &yyv[-1];
+
+ yystack:    /* put a state and value onto the stack */
+
+#ifdef YYDEBUG
+	if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
+#endif
+		if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
+		*yyps = yystate;
+		++yypv;
+		*yypv = yyval;
+
+ yynewstate:
+
+	yyn = yypact[yystate];
+
+	if( yyn<= YYFLAG ) goto yydefault; /* simple state */
+
+	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
+	if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
+
+	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
+		yychar = -1;
+		yyval = yylval;
+		yystate = yyn;
+		if( yyerrflag > 0 ) --yyerrflag;
+		goto yystack;
+		}
+
+ yydefault:
+	/* default state action */
+
+	if( (yyn=yydef[yystate]) == -2 ) {
+		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
+		/* look through exception table */
+
+		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
+
+		while( *(yyxi+=2) >= 0 ){
+			if( *yyxi == yychar ) break;
+			}
+		if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
+		}
+
+	if( yyn == 0 ){ /* error */
+		/* error ... attempt to resume parsing */
+
+		switch( yyerrflag ){
+
+		case 0:   /* brand new error */
+
+			yyerror( "syntax error" );
+		yyerrlab:
+			++yynerrs;
+
+		case 1:
+		case 2: /* incompletely recovered error ... try again */
+
+			yyerrflag = 3;
+
+			/* find a state where "error" is a legal shift action */
+
+			while ( yyps >= yys ) {
+			   yyn = yypact[*yyps] + YYERRCODE;
+			   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
+			      yystate = yyact[yyn];  /* simulate a shift of "error" */
+			      goto yystack;
+			      }
+			   yyn = yypact[*yyps];
+
+			   /* the current yyps has no shift onn "error", pop stack */
+
+#ifdef YYDEBUG
+			   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
+#endif
+			   --yyps;
+			   --yypv;
+			   }
+
+			/* there is no state on the stack with an error shift ... abort */
+
+	yyabort:
+			return(1);
+
+
+		case 3:  /* no shift yet; clobber input char */
+
+#ifdef YYDEBUG
+			if( yydebug ) printf( "error recovery discards char %d\n", yychar );
+#endif
+
+			if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
+			yychar = -1;
+			goto yynewstate;   /* try again in the same state */
+
+			}
+
+		}
+
+	/* reduction by production yyn */
+
+#ifdef YYDEBUG
+		if( yydebug ) printf("reduce %d\n",yyn);
+#endif
+		yyps -= yyr2[yyn];
+		yypvt = yypv;
+		yypv -= yyr2[yyn];
+		yyval = yypv[1];
+		yym=yyn;
+			/* consult goto table to find next state */
+		yyn = yyr1[yyn];
+		yyj = yypgo[yyn] + *yyps + 1;
+		if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
+		switch(yym){
+			
+case 4:
+{ yyerrok; } break;
+case 5:
+{ printf("store\n"); } break;
+case 6:
+{ printf("add\n"); } break;
+case 7:
+{ printf("negate\nadd\n"); } break;
+case 8:
+{ printf("multiply\n"); } break;
+case 9:
+{ printf("divide\n"); } break;
+case 10:
+{ printf("negate\n"); } break;
+case 12:
+{ printf("load\n"); } break;
+case 13:
+{ printf("push %s\n", yytext); } break;
+case 14:
+{ printf("%s\n", yytext); } break;
+		}
+		goto yystack;  /* stack new state and value */
+
+	}
+int yywrap() { return 1; }