const char *snl;
          extern int  rem(int p, int q);
          extern void readsymbol(int typeof_P, void  *p);
          extern real  float(int n);
          extern char * tostring(int p);
          extern char * substring(char *s, int f, int t);
          extern int  freespace();
          extern void svc(int n, struct (null) *r);
          extern int  addr(int typeof_P, void  *p);
          extern int  *integer(int n);
          extern short  *shortinteger(int n);
          extern char  *byteinteger(int n);
          extern char * *string(int n);
          extern struct (null) record ;
(/*should not get here any more*/          int n;
/*or here*/)
          extern real  *real(int n);
          extern long real  *longreal(int n);
          extern char  *length(char *s);
          extern char  *charno(char *s, int n);
          extern int  int(real x);
          extern int  intpt(real x);
          extern void iocp(int n);
          extern int  typeof(int typeof_N, void  *n);
          extern int  sizeof(int typeof_N, void  *n);
          extern real  fracpt(real x);
          extern void prompt(char *s);
          extern int  nextsymbol();
          extern void skipsymbol();
          extern void printsymbol(int sym);
          extern void printstring(char *s);
          extern void write(int v, int p);
          extern void selectinput(int n);
          extern void selectoutput(int n);
          extern void openinput(int n, char *fd);
          extern void openoutput(int n, char *fd);
          extern void closeinput();
          extern void closeoutput();
          extern void resetinput();
          extern void resetoutput();
          extern char * time();
          extern char * date();
          extern int  cputime();
          extern int  *comreg(int n);
          extern void read(int typeof_X, void  *x);
          extern void print(real val, int before, int after);
          extern void printfl(real val, int places);
          extern void space();
          extern void spaces(int n);
          extern void newline();
          extern void newlines(int n);
          typedef struct FILEFM{int unit; int owner; int n1; int n2;} filefm;
          typedef struct EVENTFM{int event; int sub; int extra; char *message; int pc; int x;} eventfm;
          extern struct EVENTFM event;
          typedef struct IMPCOMFM{int statements; int flags; int code; int gla; int diags; int perm; char *file; char *option;} impcomfm;
          extern struct IMPCOMFM impcom;
int main(int argc, char **argv) {
          const char *programep;
          const char *systemprefix;
          const char *traceroutine;
          const char *readsymfn;
          // bounds [0 : 24]
          // do it now: const char  {*,2}actual {NO INIT}
          // bounds [-1 : 5]
          // do it now: const char  {*,2}breg {NO INIT}
          // bounds [1 : 8]
          // do it now: const char  {*,2}genmap {NO INIT}
          // bounds [1 : 3]
          // do it now: const char  {*,2}setops {NO INIT}
          // bounds [1 : 40]
          // do it now: const short  {*,2}opindex {NO INIT}
          // bounds [1 : 124]
          // do it now: const short  {*,2}opcode {NO INIT}
          // bounds [16 : 21]
          // do it now: const char  {*,2}inverted {NO INIT}
          typedef struct VARFM{int disp; short format; short extra; short length; short header; ; ; short xform; ; ; char flag; char form; ; ; char base; char type;} varfm;
          // ON DIM DO: struct VARFM {*,0}var
          // bounds [0 : 800]
          DIM 0x0001 0x0001
          struct VARFM *decvar;
          struct VARFM *fp;
          struct VARFM *ap;
          static struct VARFM begin;
          typedef struct STACKFM{int disp; short format; short extra; short length; short header; short rt; short varno; short type; ; ; short xform; ; ; char flag; char form; ; ; ; ; short xbase; ; ; char index; char base; ; ; char dim; char oper; struct STACKFM *link;} stackfm;
          // ON DIM DO: struct STACKFM {*,0}stak
          // bounds [0 : 25]
          DIM 0x0001 0x0001
          struct STACKFM *descasl;
          typedef struct SPTFM{struct STACKFM *v;} sptfm;
          // ON DIM DO: struct SPTFM {*,0}stacked
          // bounds [1 : 16]
          DIM 0x0001 0x0001
          typedef struct DFM{struct STACKFM *d; struct DFM *link;} dfm;
          // ON DIM DO: struct DFM {*,0}dlist
          // bounds [0 : 25]
          DIM 0x0001 0x0001
          struct DFM *dasl;
          struct DFM using;
          typedef struct CYCLEFM{int cvdisp; int fvdisp; short lab; short shadow; short initial; short cvform; char reg; char cvtype; char cvbase; char fvbase; char tempbase;} cyclefm;
          // ON DIM DO: struct CYCLEFM {*,0}forstk
          // bounds [0 : 30]
          DIM 0x0001 0x0001
          struct CYCLEFM *for;
          static int forstp;
          // ON DIM DO: short  {*,0}temps
          // bounds [1 : 60]
          DIM 0x0001 0x0001
          static int tempbase;
          static int nexttemp;
          static int newtemp;
          const struct (null) *null;
          typedef struct LABELFM{short id; short tag;} labelfm;
          // ON DIM DO: struct LABELFM {*,0}labels
          // bounds [1 : 80]
          DIM 0x0001 0x0001
          // bounds [0 : 24]
          // do it now: static int  {*,1}activity {NO INIT}
          static int claimed;
          static short control;
          static short diagnose;
          static int level;
          static int mainep;
          static int unassignedrtn;
          int j;
          int k;
          int len;
          int n;
          int val;
          int aparm;
          int opr;
          static int ca;
          static int ga;
          static int lita;
          static int litmax;
          static int diag1;
          static int diag2;
          static int ccca;
          static int ccreg;
          int sym;
          int next;
          int vlb;
          int vub;
          int allocate;
          int falign;
          static int currentline;
          static int lastline;
          static int stp;
          int datasize;
          static int frame;
          static int extraframe;
          int parms;
          int local;
          static int invert;
          static int swopped;
          static int uncondjump;
          static int gtype;
          static int gmode;
          int decl;
          static short languagemask;
          int cheapreg;
          int otype;
          int owntype;
          int ownform;
          int spec;
          int frozen;
          int potype;
          int diagtype;
          diagtype = 0;
          int diagform;
          diagform = 0;
          int diagsize;
          diagsize = 0;
          long real rvalue;
          static int ownval;
          static int mantissa;
          int oarea;
          int dim;
          int dv;
          int wdisp;
          int pdisp;
          int gdisp;
          static int blockno;
          static int defns;
          static int specs;
          static int relocations;
          static int vardiags;
          static int totalca;
          static int lastca;
          static int traceflag;
          int jtag;
          static char *externalid;
          static char *alias;
          static char *blockname;
          static char *internalid;
          static int faulty;
          static int nullstring;
          char  *cslen;
          // ON DIM DO: char  {*,0}currentstring
          // bounds [0 : 255]
          DIM 0x0001 0x0001
          static int lastgpr;
          static int lastfpr;
          static int lasteo;
          typedef struct KFM{struct KFM *link; struct KFM *array; int disp; short reg; char type; char form; char base; char ktype;} kfm;
          // ON DIM DO: struct KFM {*,0}knowledge
          // bounds [1 : 120]
          DIM 0x0001 0x0001
          static struct KFM *klist;
          static struct KFM *kasl;
          int knownregs;
          knownregs = 0;
          int inuse;
          inuse = 0;
          typedef struct ENVFM{int label; int inuse; int known; struct KFM *link;} envfm;
          // ON DIM DO: struct ENVFM {*,0}envir
          // bounds [1 : 5]
          DIM 0x0001 0x0001
          static int envp;
          void rr(int op, int r1, int r2);
          void rx(int op, int r1, int base, int disp);
          void rxi(int op, int r1, int base, int disp);
          void rxd(int op, int r1, struct STACKFM *v);
          void setline();
          goto L_0001;
          void show(struct STACKFM *v)
{
          write(v->varno, 2);
          printsymbol(58);
          write(v->type, 3);
          write(v->form, 2);
          write(v->flag, 2);
          write(v->sptfm, 3);
          write(v->disp, 5);
          write(v->length, 3);
          write(v->extra, 3);
          write(v->format, 3);
          write(v->header, 3);
          write(v->v, 3);
          if (v->oper == 0) goto L_0002;
          write(v->oper, 2);
          newline();
          printstring("         +");
          show(v->link);
          goto L_0003;
L_0002:
          newline();
L_0003:
          return(0);
}
L_0001:
          goto L_0004;
          void abort(int code)
{
          struct DFM *dd;
          int j;
          selectoutput(0);
          printstring("*Compiler error '");
          for (j = 24; j += (-8); j != 0) {
          printsymbol(((code >> j) & 255));
          }
L_0008:
          printstring("' at line");
          write(currentline, 1);
          newline();
          printstring("Please seek assistance!!");
          newline();
          if (stp == 0) goto L_0009;
          printstring("STACK:");
          newline();
          for (j = 1; j += 1; j != stp) {
          show(stacked[j].v);
          }
L_000d:
L_0009:
          if (&using.link == null) goto L_000e;
          printstring("USING:");
          newline();
          dd = &using.link;
          for (;;) {
L_000f:
          show(dd->d);
          dd = &dd->link;
          if (dd != null) goto L_0010;
          goto L_0011;
L_0010:
          }
L_0011:
L_000e:
          selectoutput(2);
//           EVENT 0x000f
L_0004:
          goto L_0012;
          void warn(int n)
{
          // bounds [1 : 8]
          /*todo: gcc jump table extension*/ void **w;
          selectoutput(0);
          printstring("*WARNING: line");
          write(currentline, 1);
          printstring(": ");
          goto *w[n];
w_1:
          printstring("division by zero");
          goto U_00c1;
w_2:
          printstring("Illegal FOR");
          goto U_00c1;
w_3:
          printstring("Non-local control variable?");
          goto U_00c1;
w_4:
          printstring("Invalid parameter for READ SYMBOL");
          goto U_00c1;
w_5:
          printstring("String constant too long");
          goto U_00c1;
w_6:
          printstring("No. of shifts outwith 0..31");
          goto U_00c1;
w_7:
          printstring("Illegal constant exponent");
          goto U_00c1;
w_8:
          printstring("Numerical constant too big");
          goto U_00c1;
U_00c1:
          newline();
          selectoutput(2);
L_0012:
          goto L_0013;
          void monitor(struct STACKFM *v, char *text)
{
          selectoutput(0);
          printstring(text);
          printsymbol(58);
          spaces((9 - *length(text)));
          show(*v);
          selectoutput(2);
L_0013:
          goto L_0014;
          int floating(struct STACKFM *v)
{
          if (v->type < 7) goto L_0015;
          if (v->type != 255) goto L_0016;
L_0015:
          if (v->oper == 0) goto L_0017;
          if (v->link.type < 7) goto L_0017;
L_0016:
L_0017:
          if (v->oper < 16) goto L_0018;
L_0018:
L_0014:
          goto L_0019;
          int zero(struct STACKFM *v)
{
          if (v->disp != 0) goto L_001a;
          if (v->sptfm != 0) goto L_001a;
          if (0 == v->form) goto L_001b;
          if (v->form == 5) goto L_001b;
L_001a:
L_001b:
          if (v->oper == 0) goto L_001c;
L_001c:
L_0019:
          goto L_001d;
          int const(struct STACKFM *v)
{
          if (v->form != 0) goto L_001e;
          if (v->oper == 0) goto L_001f;
L_001e:
L_001f:
          if (v->type <= 3) goto L_0020;
L_0020:
L_001d:
          goto L_0021;
          int  minrecordsize(struct STACKFM *a, struct STACKFM *b)
{
          int n;
          int m;
          n = a->format;
          if (n == 0) goto L_0022;
          n = (var[n].length & 65535);
L_0022:
          m = b->format;
          if (m == 0) goto L_0023;
          m = (var[m].length & 65535);
L_0023:
          if (n == 0) goto L_0024;
          if (m == 0) goto L_0025;
          if (m >= n) goto L_0025;
L_0024:
          n = m;
L_0025:
          if (n <= 0) goto L_0026;
          return(n);
L_0026:
          abort(1382376240);
L_0021:
          goto L_0027;
          int  power(int n)
{
          int j;
          int ref;
          ref = 1;
          for (j = 1; j += 1; j != 14) {
          ref = (ref << 1);
          if (ref < n) goto L_002c;
          if (ref != n) goto L_002d;
          return(j);
L_002d:
          return((-1));
L_002c:
          }
L_002b:
          return((-1));
L_0027:
          goto L_002e;
          int same(struct STACKFM *v, struct STACKFM *w)
{
          if (v->disp != w->disp) goto L_002f;
          if (v->sptfm != w->sptfm) goto L_002f;
          if (v->type != w->type) goto L_002f;
          if (v->form != w->form) goto L_002f;
          if (v->extra != w->extra) goto L_002f;
L_002f:
L_002e:
          goto L_0030;
          int infreereg(struct STACKFM *v)
{
          if (v->form != 1) goto L_0031;
          if (activity[v->sptfm] <= 1) goto L_0032;
L_0031:
L_0032:
L_0030:
          goto L_0033;
          int  temp()
{
          int t;
          if (nexttemp != newtemp) goto L_0034;
          t = ((frame + 3) & (\3));
          frame = (t + 4);
          if (newtemp != 60) goto L_0035;
          return(t);
L_0035:
          newtemp = (newtemp + 1);
          temps[newtemp] = t;
L_0034:
          nexttemp = (nexttemp + 1);
          return((temps[nexttemp] & 65535));
L_0033:
          goto L_0036;
          int  tag()
{
          int s1;
          int s2;
          s1 = next;
          readsymbol(s2);
          readsymbol(next);
          return(((s1 << 8) | s2));
L_0036:
          goto L_0037;
          void getd()
{
          long real p;
          int i;
          int n;
          real ten;
          real one;
          n = 10;
          rvalue = n;
          n = 1;
          one = n;
          n = tag();
          readsymbol(next);
U_00cf:
          ten = rvalue;
          rvalue = 0;
          for (;;) {
L_0038:
          sym = next;
          readsymbol(next);
          if (sym != 46) goto L_0039;
          goto L_003a;
L_0039:
          n = (n - 1);
          if (sym != 64) goto L_003b;
          goto U_00d0;
L_003b:
          if (sym != 95) goto L_003c;
          goto U_00cf;
L_003c:
          if (sym < 65) goto L_003d;
          sym = (((sym - 65) + 48) + 10);
L_003d:
          rvalue = ((rvalue * ten) + (sym - 48));
          if (n != 0) goto L_003e;
          goto U_00d1;
L_003e:
          }
L_003a:
          p = one;
          for (;;) {
L_003f:
          n = (n - 1);
          if (n != 0) goto L_0040;
          goto U_00d1;
L_0040:
          sym = next;
          readsymbol(next);
          if (sym != 64) goto L_0041;
          goto U_00d0;
L_0041:
          if (sym < 65) goto L_0042;
          sym = (((sym - 65) + 48) + 10);
L_0042:
          p = (p / ten);
          rvalue = (rvalue + ((sym - 48) * p));
          }
U_00d0:
          n = tag();
          if ((n & 32768) == 0) goto L_0043;
          n = (n | -65536);
L_0043:
          rvalue = (rvalue * imp_real_exp(ten, n));
U_00d1:
          if (next != 85) goto L_0044;
          readsymbol(next);
          rvalue = (-rvalue);
L_0044:
L_0037:
          goto L_0045;
          void release(int reg)
{
          if (reg <= 24) goto L_0046;
          abort(1380273201);
L_0046:
          if (reg == 0) goto L_0047;
          if (activity[reg] >= 0) goto L_0048;
L_0047:
          return;
L_0048:
          activity[reg] = (activity[reg] - 1);
          if (activity[reg] >= 0) goto L_0049;
          abort(1380273202);
L_0049:
          claimed = (claimed - 1);
L_0045:
          goto L_004a;
          void claim(int reg)
{
          if (reg <= 24) goto L_004b;
          abort(1129073969);
L_004b:
          if (reg == 0) goto L_004c;
          if (activity[reg] >= 0) goto L_004d;
L_004c:
          return;
L_004d:
          activity[reg] = (activity[reg] + 1);
          claimed = (claimed + 1);
L_004a:
          void forgetreg(int mask);
          void forgetall();
          void forgetvar(struct STACKFM *v);
          goto L_004e;
          void hazard(int reg)
{
          int n;
          int t;
          int tot;
          struct DFM *p;
          struct STACKFM u;
          goto L_004e;
          void mod(struct STACKFM *v)
{
          // bounds [0 : 9]
          /*todo: gcc jump table extension*/ void **sw;
          v->sptfm = local;
          n = (n - 1);
          goto *sw[v->form];
sw_9:
sw_8:
sw_7:
          if (tot != 1) goto L_004f;
          claim(reg);
          rx(1, reg, reg, v->extra);
          u.type = 1;
          v->extra = t;
          goto U_00d9;
L_004f:
sw_0:
          abort(1212242481);
sw_4:
          if (v->disp != 0) goto L_0050;
          v->disp = t;
          v->form = 6;
          goto U_00da;
L_0050:
sw_6:
sw_5:
          v->form = (v->form + 3);
          v->extra = t;
          goto U_00da;
sw_1:
          v->form = 4;
          v->disp = t;
          v->type = u.type;
U_00da:
          v->flag = (v->flag | 8);
U_00d9:
L_004e:
          n = activity[reg];
          if (n > 0) goto L_0051;
          return;
L_0051:
          tot = n;
          claimed = (claimed - n);
          activity[reg] = 0;
          t = temp();
          u.type = 1;
          if (17 > reg) goto L_0052;
          if (reg > 24) goto L_0052;
          u.type = 7;
L_0052:
          p = &using.link;
          for (;;) {
L_0053:
          if (p != null) goto L_0054;
          goto L_0055;
L_0054:
          if (p->d.cyclefm != reg) goto L_0056;
          mod(p->d);
L_0056:
          p = &p->link;
          }
L_0055:
          u.closeoutput = local;
          u.disp = t;
          u.xform = (4 | (8 << 8));
          rxd(2, reg, u);
          forgetvar(u);
          if (n == 0) goto L_0057;
          abort(1212242482);
L_0057:
          for (;;) {
L_0058:
          goto L_0058;
          void hazardall()
{
          int j;
          forgetreg((-1));
          if (claimed == 0) goto L_0059;
          for (j = 1; j += 1; j != 24) {
          hazard(j);
          }
L_005d:
L_0059:
L_0058:
          goto L_005e;
          void resetoptimisationdata()
{
          int j;
          lastgpr = 1;
          lastfpr = 17;
          lasteo = 1;
          envp = 0;
          knownregs = (-1);
          inuse = 0;
          kasl = null;
          klist = null;
          for (j = 1; j += 1; j != 120) {
          knowledge[j].link = kasl;
          kasl = &knowledge[j];
          }
L_0062:
          for (j = 1; j += 1; j != 5) {
          envir[j].label = 0;
          envir[j].link = null;
          }
L_0066:
L_005e:
          goto L_0067;
          void dumpoptlist()
{
          struct KFM *p;
          selectoutput(0);
          p = klist;
          if (p != null) goto L_0068;
          printstring("*opt list empty");
          newline();
          goto L_0069;
L_0068:
          for (;;) {
L_006a:
          write(p->type, 1);
          write(p->form, 1);
          write(p->disp, 3);
          printsymbol(40);
          write(p->base, (-1));
          printstring(") =");
          write(p->reg, 1);
          newline();
          p = &p->link;
          if (p == null) goto L_006b;
          }
L_006b:
L_0069:
          selectoutput(2);
L_0067:
          goto L_006c;
          struct KFM kentry (struct STACKFM *v, int fuzz)
{
          struct KFM *p;
          struct KFM *q;
          fuzz = (\fuzz);
          p = klist;
          q = null;
          for (;;) {
L_006d:
          if (p == null) goto L_006e;
          if (((p->disp ^ v->disp) & fuzz) != 0) goto L_006f;
          if (p->base != v->sptfm) goto L_006f;
          goto U_00d8;
L_006f:
          q = p;
          p = &p->link;
          }
L_006e:
          return(null);
U_00d8:
          if (q == null) goto L_0070;
          q->link = &p->link;
          p->link = klist;
          klist = p;
L_0070:
          return(klist);
L_006c:
          goto L_0071;
          struct KFM newkcell ()
{
          struct KFM *p;
          struct KFM *q;
          int n;
          if (kasl == null) goto L_0072;
          if (inuse < 20) goto L_0073;
L_0072:
          p = klist;
          q = null;
          n = 20;
          for (;;) {
L_0074:
          n = (n - 1);
          if (&p->link != null) goto L_0075;
          goto L_0076;
L_0075:
          q = p;
          p = &p->link;
          }
L_0076:
          if (n == 0) goto L_0077;
          abort(1330664497);
L_0077:
          q->link = null;
          p->link = kasl;
          kasl = p;
          inuse = (inuse - 1);
L_0073:
          p = kasl;
          kasl = &kasl->link;
          inuse = (inuse + 1);
          if (inuse <= 20) goto L_0078;
          abort(1332769843);
L_0078:
          memset(*p,0,sizeof struct KFM);
          return(p);
L_0071:
          goto L_0079;
          void associate(struct STACKFM *v, int reg)
{
          struct KFM *p;
          if (reg == 1) goto L_007a;
          if (v->sptfm != reg) goto L_007b;
L_007a:
          return;
L_007b:
          p = &*kentry(*v, 0);
          if (p != null) goto L_007c;
          p = &*newkcell();
          p->link = klist;
          klist = p;
          goto L_007d;
L_007c:
          forgetreg((1 << p->reg));
L_007d:
          p->reg = reg;
          p->base = v->sptfm;
          p->disp = v->disp;
          p->type = v->type;
          p->form = v->form;
          p->ktype = 1;
          knownregs = (knownregs | (1 << reg));
          if (activity[p->base] < 0) goto L_007e;
          knownregs = (knownregs | (1 << p->base));
L_007e:
L_0079:
          goto L_007f;
          void cheapen(struct STACKFM *v, int mode)
{
          struct KFM *p;
          int reg;
          int form;
          int type;
          form = v->form;
          type = v->type;
          p = &*kentry(*v, 0);
          if (p != null) goto L_0080;
          return;
L_0080:
          if (p->form != 4) goto L_0081;
          v->flag = (v->flag | 8);
L_0081:
          if (p->reg != 0) goto L_0082;
          return;
L_0082:
          if (form == 6) goto L_0083;
          if (p->type != type) goto L_0083;
          cheapreg = p->reg;
L_0083:
          if (mode >= 0) goto L_0084;
          if (form != 4) goto L_0084;
          return;
L_0084:
          reg = p->reg;
          if (form != 6) goto L_0085;
          if (p->type != 1) goto L_0085;
          if (p->form != 4) goto L_0085;
          release(v->sptfm);
          claim(reg);
          v->sptfm = reg;
          v->disp = 0;
          v->xform = 4;
          cheapen(*v, mode);
          goto L_0086;
L_0085:
          if (p->type != type) goto L_0087;
          if (p->form == form) goto L_0088;
L_0087:
          return;
L_0088:
          release(v->sptfm);
          claim(reg);
          v->sptfm = reg;
          v->disp = 0;
          v->xform = 1;
L_0086:
          if (diagnose >= 0) goto L_0089;
          monitor(*v, "CHEAPENED");
          if ((diagnose & 16) == 0) goto L_008a;
          dumpoptlist();
L_008a:
L_0089:
L_007f:
          goto L_008b;
          void forgetvar(struct STACKFM *v)
{
          struct KFM *p;
          for (;;) {
L_008c:
          p = &*kentry(*v, 3);
          if (p != null) goto L_008d;
          return;
L_008d:
          p->base = (26 + 1);
          }
L_008b:
          goto L_008e;
          void forgetreg(int regmask)
{
          struct KFM *p;
          if ((knownregs & regmask) != 0) goto L_008f;
          return;
L_008f:
          regmask = (regmask & (\1));
          knownregs = (knownregs & (\regmask));
          p = klist;
          if (regmask >= 0) goto L_0090;
          for (;;) {
L_0091:
          if (p == null) goto L_0092;
          if ((regmask & (1 << p->base)) == 0) goto L_0093;
          p->base = (26 + 1);
L_0093:
          p->reg = 0;
          p = &p->link;
          }
L_0092:
          goto L_0094;
L_0090:
          for (;;) {
L_0095:
          if (p == null) goto L_0096;
          if ((regmask & (1 << p->base)) == 0) goto L_0097;
          p->base = (26 + 1);
L_0097:
          if ((regmask & (1 << p->reg)) == 0) goto L_0098;
          p->reg = 0;
L_0098:
          p = &p->link;
          }
L_0096:
L_0094:
          for (;;) {
L_0099:
          if (klist == null) goto L_009a;
          if (klist->base != (26 + 1)) goto L_009a;
          p = klist;
          klist = &klist->link;
          p->link = kasl;
          kasl = p;
          inuse = (inuse - 1);
          }
L_009a:
          if (inuse >= 0) goto L_009b;
          abort(1433625919);
L_009b:
L_008e:
          goto L_009c;
          void forgetall()
{
          struct KFM *p;
          if (klist == null) goto L_009d;
          p = klist;
          for (;;) {
L_009e:
          inuse = (inuse - 1);
          if (&p->link != null) goto L_009f;
          goto L_00a0;
L_009f:
          p = &p->link;
          }
L_00a0:
          p->link = kasl;
          kasl = klist;
          klist = null;
L_009d:
          if (inuse == 0) goto L_00a1;
          abort(1180789868);
L_00a1:
          knownregs = 0;
L_009c:
          goto L_00a2;
          struct ENVFM environment (int label)
{
          struct ENVFM *e;
          int j;
          if (label <= 0) goto L_00a3;
          for (j = 1; j += 1; j != 5) {
          e = &envir[j];
          if (e->label != label) goto L_00a8;
          return(e);
L_00a8:
          }
L_00a7:
L_00a3:
          return(null);
L_00a2:
          goto L_00a9;
          struct ENVFM newenv (struct ENVFM *e)
{
          struct KFM *k;
          if (e != null) goto L_00aa;
          envp = (envp + 1);
          if (envp <= 5) goto L_00ab;
          envp = 1;
L_00ab:
          e = &envir[envp];
L_00aa:
          k = &e->link;
          if (k == null) goto L_00ac;
          for (;;) {
L_00ad:
          if (&k->link == null) goto L_00ae;
          k = &k->link;
          }
L_00ae:
          k->link = kasl;
          kasl = &e->link;
L_00ac:
          e->inuse = 0;
          e->label = 0;
          e->link = null;
          return(e);
L_00a9:
          goto L_00af;
          struct KFM ecopy (struct KFM *l)
{
          struct KFM *k;
          if (l != null) goto L_00b0;
          return(null);
L_00b0:
          if (kasl != null) goto L_00b1;
          abort(1164144496);
L_00b1:
          k = kasl;
          kasl = &k->link;
          memcpy(*k,*l,sizeof struct KFM);
          k->link = &*ecopy(l->link);
          return(k);
L_00af:
          goto L_00b2;
          void restoreenvironment(int label)
{
          struct ENVFM *e;
          struct ENVFM temp;
          temp.link = klist;
          e = &*newenv(temp);
          e = &*environment(label);
          if (e != null) goto L_00b3;
          klist = null;
          knownregs = 0;
          inuse = 0;
          goto L_00b4;
L_00b3:
          klist = &*ecopy(e->link);
          knownregs = e->known;
          inuse = e->inuse;
L_00b4:
L_00b2:
          goto L_00b5;
          void rememberenvironment(int label)
{
          struct ENVFM *e;
          if (label > 0) goto L_00b6;
          return;
L_00b6:
          e = &*environment(label);
          e = &*newenv(*e);
          e->label = label;
          e->known = knownregs;
          e->inuse = inuse;
          e->link = &*ecopy(*klist);
L_00b5:
          goto L_00b7;
          void mergeenvironment(int label)
{
          struct ENVFM *e;
          struct KFM *k;
          struct KFM *end;
          struct KFM *x;
          struct KFM khead;
          goto L_00b7;
          void merge(struct KFM *k)
{
          struct KFM *p;
          p = klist;
          for (;;) {
L_00b8:
          if (p == null) goto L_00b9;
          if (p->disp != k->disp) goto L_00ba;
          if (p->reg != k->reg) goto L_00ba;
          if (p->base != k->base) goto L_00ba;
          if (p->form != k->form) goto L_00ba;
          if (p->type != k->type) goto L_00ba;
          if (p->ktype != k->ktype) goto L_00ba;
          end->link = k;
          end = k;
          e->known = ((e->known | (1 << p->reg)) | (1 << p->base));
          e->inuse = (e->inuse + 1);
          return;
L_00ba:
          p = &p->link;
          }
L_00b9:
          k->link = kasl;
          kasl = k;
L_00b7:
          e = &*environment(label);
          if (e == null) goto L_00bb;
          k = &e->link;
          e->link = null;
          e->inuse = 0;
          e->known = 0;
          khead.link = null;
          end = &khead;
          for (;;) {
L_00bc:
          if (k == null) goto L_00bd;
          x = &k->link;
          merge(*k);
          k = x;
          }
L_00bd:
          end->link = null;
          e->link = &khead.link;
L_00bb:
          for (;;) {
L_00be:
          goto L_00be;
          int  gpr()
{
          // bounds [1 : 8]
          // do it now: const char  {*,2}pref {NO INIT}
          int r;
          int j;
          int mask;
          mask = knownregs;
          for (;;) {
L_00bf:
          for (j = 1; j += 1; j != 8) {
          lastgpr = (lastgpr - 1);
          if (lastgpr != 0) goto L_00c4;
          lastgpr = 8;
L_00c4:
          r = pref[lastgpr];
          if (activity[r] != 0) goto L_00c5;
          if ((mask & (1 << r)) != 0) goto L_00c5;
          return(r);
L_00c5:
          }
L_00c3:
          if (mask != 0) goto L_00c6;
          goto L_00c7;
L_00c6:
          mask = 0;
          }
L_00c7:
          hazard(5);
          return(5);
L_00be:
          goto L_00c8;
          int  evenoddpair()
{
          // bounds [1 : 3]
          // do it now: const char  {*,2}even {NO INIT}
          int j;
          int r;
          int mask;
          mask = knownregs;
          for (;;) {
L_00c9:
          for (j = 1; j += 1; j != 3) {
          lasteo = (lasteo - 1);
          if (lasteo != 0) goto L_00ce;
          lasteo = 3;
L_00ce:
          r = even[lasteo];
          if (activity[r] != 0) goto L_00cf;
          if (activity[(r + 1)] != 0) goto L_00cf;
          if ((mask & (3 << r)) != 0) goto L_00cf;
          return((r + 1));
L_00cf:
          }
L_00cd:
          if (mask != 0) goto L_00d0;
          goto L_00d1;
L_00d0:
          mask = 0;
          }
L_00d1:
          hazard(3);
          hazard(4);
          return(4);
L_00c8:
          goto L_00d2;
          int  fpr()
{
          int j;
          int mask;
          mask = knownregs;
          for (;;) {
L_00d3:
          for (j = 17; j += 1; j != 24) {
          lastfpr = (lastfpr - 1);
          if (lastfpr != (17 - 1)) goto L_00d8;
          lastfpr = 24;
L_00d8:
          if (activity[lastfpr] != 0) goto L_00d9;
          return(lastfpr);
L_00d9:
          }
L_00d7:
          if (mask != 0) goto L_00da;
          goto L_00db;
L_00da:
          mask = 0;
          }
L_00db:
          hazard(17);
          return(17);
L_00d2:
          goto L_00dc;
          void put(int n)
{
          printsymbol((n >> 8));
          printsymbol((n & 255));
L_00dc:
          goto L_00dd;
          void selectliteralarea()
{
          int k;
          printsymbol(13);
          if (ca >= 0) goto L_00de;
          abort(1145917489);
L_00de:
          k = lita;
          lita = ca;
          ca = k;
L_00dd:
          goto L_00df;
          void selectcodearea()
{
          int k;
          if (ca <= 0) goto L_00e0;
          abort(1145917490);
L_00e0:
          k = lita;
          lita = ca;
          ca = k;
          printsymbol(12);
L_00df:
          goto L_00e1;
          void phex(int n)
{
          int j;
          int k;
          spaces(2);
          for (j = 12; j += (-4); j != 0) {
          k = ((n >> j) & 15);
          if (k > 9) goto L_00e6;
          k = (k + 48);
          goto L_00e7;
L_00e6:
          k = ((k - 10) + 65);
L_00e7:
          printsymbol(k);
          }
L_00e5:
L_00e1:
          goto L_00e8;
          void dumptag(int tag, int type)
{
          // bounds [1 : 6]
          // do it now: const char * {*,2}s {NO INIT}
          selectoutput(0);
          printsymbol(42);
          write(ca, (-3));
          printstring(s[type]);
          write(tag, 1);
          newline();
          selectoutput(2);
L_00e8:
          goto L_00e9;
          void dump(int p, int val)
{
          int k;
          selectoutput(0);
          if (p != 17217) goto L_00ea;
          printstring("CA ");
          k = ca;
          goto L_00eb;
L_00ea:
          printstring("GA ");
          k = ga;
L_00eb:
          write((k - 2), (-3));
          printsymbol(58);
          phex(val);
          newline();
          selectoutput(2);
L_00e9:
          goto L_00ec;
          void cput(int n)
{
          printsymbol(7);
          printsymbol((n >> 8));
          printsymbol((n & 255));
          ca = (ca + 2);
          if (diagnose >= 0) goto L_00ed;
          dump(17217, n);
L_00ed:
L_00ec:
          goto L_00ee;
          void gput(int n)
{
          printsymbol(8);
          printsymbol((n >> 8));
          printsymbol((n & 255));
          ga = (ga + 2);
          if (diagnose >= 0) goto L_00ef;
          dump(18241, n);
L_00ef:
L_00ee:
          goto L_00f0;
          void cword(int n)
{
          cput((n >> 16));
          cput(n);
L_00f0:
          goto L_00f1;
          void litbyte(int n)
{
          static int v;
          static int f;
          f = (\f);
          if (f != 0) goto L_00f2;
          ca = (ca + 1);
          cput(((v << 8) + (n & 255)));
          goto L_00f3;
L_00f2:
          v = n;
          ca = (ca - 1);
L_00f3:
          if (ca <= 0) goto L_00f4;
          abort(1145917491);
L_00f4:
L_00f1:
          goto L_00f5;
          void gword(int n)
{
          gput((n >> 16));
          gput((n & 65535));
L_00f5:
          goto L_00f6;
          void gwordrel(int n)
{
          gput((n >> 16));
          gput((n & 65535));
          printsymbol(20);
          relocations = (relocations + 1);
L_00f6:
          goto L_00f7;
          void gwordcrel(int n)
{
          gput((n >> 16));
          gput((n & 65535));
          printsymbol(19);
          relocations = (relocations + 1);
L_00f7:
          goto L_00f8;
          void gbyte(int n)
{
          static int v;
          static int f;
          f = (\f);
          if (f != 0) goto L_00f9;
          ga = (ga - 1);
          gput(((v << 8) + (n & 255)));
          goto L_00fa;
L_00f9:
          v = n;
          ga = (ga + 1);
L_00fa:
L_00f8:
          goto L_00fb;
          void gfix(int align)
{
          for (;;) {
L_00fc:
          if ((ga & align) == 0) goto L_00fd;
          gbyte(0);
          }
L_00fd:
L_00fb:
          goto L_00fe;
          void definetag(int ref)
{
          int k;
          selectoutput(1);
          printsymbol(1);
          printsymbol((ref >> 8));
          printsymbol((ref & 255));
          k = (ca >> 1);
          printsymbol((k >> 8));
          printsymbol((k & 255));
          selectoutput(2);
          if (diagnose >= 0) goto L_00ff;
          dumptag(ref, 1);
L_00ff:
L_00fe:
          goto L_0100;
          void definereference(int ref, int type)
{
          int k;
          if (currentline == lastline) goto L_0101;
          setline();
L_0101:
          selectoutput(1);
          printsymbol(type);
          printsymbol((ref >> 8));
          printsymbol((ref & 255));
          k = (ca >> 1);
          printsymbol((k >> 8));
          printsymbol((k & 255));
          selectoutput(2);
          if (diagnose >= 0) goto L_0102;
          dumptag(ref, type);
L_0102:
          printsymbol(type);
          if (type != 2) goto L_0103;
          printsymbol((ref >> 8));
          printsymbol((ref & 255));
L_0103:
L_0100:
          goto L_0104;
          void claimliteral(int size, int align)
{
          int k;
          if (ca < 0) goto L_0105;
          if (litmax <= 0) goto L_0106;
L_0105:
          abort(1145917492);
L_0106:
          if ((lita & 1) == 0) goto L_0107;
          selectliteralarea();
          litbyte(0);
          selectcodearea();
L_0107:
          litmax = (-((((-litmax) + size) + align) & (\align)));
          lita = litmax;
          k = ((-lita) >> 1);
          printsymbol(14);
          put(k);
L_0104:
          goto L_0108;
          void setline()
{
          int flag;
          if (ca >= 0) goto L_0109;
          return;
L_0109:
          if ((currentline - lastline) == 1) goto L_010a;
          flag = 10;
          goto L_010b;
L_010a:
          flag = 9;
L_010b:
          selectoutput(1);
          printsymbol(flag);
          if (flag != 10) goto L_010c;
          put(currentline);
L_010c:
          if (diagnose >= 0) goto L_010d;
          selectoutput(0);
          printstring("-->line");
          write(currentline, 1);
          newline();
L_010d:
          selectoutput(2);
          printsymbol(flag);
          if (flag != 10) goto L_010e;
          put(currentline);
L_010e:
          lastline = currentline;
          lastca = ca;
L_0108:
          goto L_010f;
          void describe(int base, int disp, char * *xsym)
{
          int size;
          int type;
          int j;
          int k;
          // bounds [0 : 13]
          // do it now: const char  {*,2}compressedtype {NO INIT}
          if (*length(xsym) <= 12) goto L_0110;
          *length(xsym) = 12;
L_0110:
          printsymbol(*length(xsym));
          for (j = 1; j += 1; j != *length(xsym)) {
          printsymbol(*charno(xsym, j));
          }
L_0114:
          if (base >= 0) goto L_0115;
          return;
L_0115:
          size = diagsize;
          type = diagtype;
          if (diagtype >= 3) goto L_0116;
          if (diagform > 2) goto L_0116;
          if (size != 0) goto L_0117;
L_0116:
          size = 1;
L_0117:
          if (diagtype > 0) goto L_0118;
          type = 1;
L_0118:
          k = (((size - 1) << 2) + (type - 1));
          j = 0;
          if (otype == 0) goto L_0119;
          if (spec == 0) goto L_0119;
          j = 128;
L_0119:
          printsymbol(otype);
          printsymbol((((compressedtype[k] << 4) | diagform) | j));
          j = ((actual[base] << 20) + (disp & 1048575));
          printsymbol((j >> 16));
          printsymbol((j >> 8));
          printsymbol(j);
L_010f:
          goto L_011a;
          void setdiag(int base, int disp)
{
          vardiags = (vardiags + 4);
          if (*length(internalid) <= 6) goto L_011b;
          vardiags = (vardiags + 2);
L_011b:
          printsymbol(11);
          describe(base, disp, internalid);
L_011a:
          goto L_011c;
          void externallink(int reftype, int datasize, int addr)
{
          int k;
          if (4 > reftype) goto L_011d;
          if (reftype <= 7) goto L_011e;
L_011d:
          abort(1145917493);
L_011e:
          if ((reftype & 1) == 0) goto L_011f;
          defns = (defns + 1);
          goto L_0120;
L_011f:
          specs = (specs + 1);
L_0120:
          printsymbol(21);
          printsymbol(reftype);
          put((datasize / 2));
          k = 14;
          if (reftype != 7) goto L_0121;
          k = 15;
L_0121:
          describe(k, (addr / 2), externalid);
          if ((reftype & 1) != 0) goto L_0122;
          gword(0);
          gword(0);
          if (reftype != 6) goto L_0123;
          gword(0);
          goto L_0124;
L_0123:
          gword((-1));
L_0124:
L_0122:
L_011c:
          goto L_0125;
          void closefiles()
{
          selectoutput(1);
          printsymbol(18);
          put((totalca >> 1));
          put(((-litmax) >> 1));
          put((ga >> 1));
          put(defns);
          put(specs);
          put(relocations);
          printsymbol(0);
          closeoutput();
          selectoutput(2);
          printsymbol(18);
          closeoutput();
L_0125:
          goto L_0126;
          void rxd(int op, int r1, struct STACKFM *v)
{
          int index;
          int mask;
          int code;
          int format;
          int type;
          int form;
          int base;
          int disp;
          int x;
          int k;
          int oldca;
          struct STACKFM u;
          // bounds [1 : 8]
          // do it now: const char  {*,2}typeindex {NO INIT}
          oldca = ca;
          type = v->type;
          form = v->form;
          base = v->sptfm;
          disp = v->disp;
          x = v->rem;
          if (r1 < 17) goto L_0127;
          op = (op + 13);
L_0127:
          mask = opindex[op];
          index = (mask & 255);
          if (lastline == currentline) goto L_0128;
          setline();
L_0128:
          if (form == 0) goto L_0129;
          if (form != 5) goto L_012a;
L_0129:
          if (x == 0) goto L_012b;
          abort(1381516408);
L_012b:
          if (disp != 0) goto L_012c;
          if (base == 0) goto L_012c;
          if (11 == op) goto L_012c;
          if (op == 12) goto L_012c;
          if (op == 29) goto L_012c;
          if (r1 != base) goto L_012d;
          if (op == 1) goto L_012e;
L_012d:
          u.closeoutput = base;
          u.disp = 0;
          u.form = 1;
          rxd(op, r1, u);
          return;
L_012e:
          code = 16;
          goto L_012f;
L_012c:
          if (op != 1) goto L_0130;
          if (r1 != base) goto L_0130;
          if (15 < disp) goto L_0130;
          if (disp < (-15)) goto L_0130;
          op = 3;
          if (disp >= 0) goto L_0131;
          op = 4;
          disp = (-disp);
L_0131:
          u.form = 0;
          u.closeoutput = 0;
          u.disp = disp;
          rxd(op, r1, u);
          release(base);
          return;
L_0130:
          if (op != 11) goto L_0132;
          if (disp != 1) goto L_0132;
          if (base != 0) goto L_0132;
          claim(r1);
          u.closeoutput = r1;
          u.disp = 0;
          u.form = 1;
          rxd(3, r1, u);
          return;
L_0132:
          if ((mask & 2048) != 0) goto L_0133;
          if (11 == op) goto L_0133;
          if (op == 12) goto L_0133;
          if (op == 29) goto L_0133;
          abort(1381516337);
L_0133:
          index = (index + 3);
          format = 0;
          if (15 < disp) goto L_0134;
          if (disp < (-15)) goto L_0134;
          if (base != 0) goto L_0134;
          if (((8192 + 16384) & mask) == 0) goto L_0134;
          if (disp < 0) goto L_0135;
          format = 2;
          goto L_0136;
L_0135:
          format = 3;
          disp = (-disp);
L_0136:
          goto L_0137;
L_0134:
          if (32767 < disp) goto L_0138;
          if (disp < (-32768)) goto L_0138;
          format = 1;
L_0138:
L_0137:
          code = opcode[(index + format)];
          if (format < 2) goto L_0139;
          cput((((code & 65280) + (actual[r1] << 4)) + disp));
          goto L_013a;
L_0139:
          cput((((code & 65280) + (actual[r1] << 4)) + actual[base]));
          if (format != 0) goto L_013b;
          cput((disp >> 16));
L_013b:
          cput(disp);
L_013a:
L_012f:
          goto L_013c;
L_012a:
          if (form != 1) goto L_013d;
          if (r1 == 0) goto L_013e;
          if (base == 0) goto L_013e;
          if (x == 0) goto L_013f;
L_013e:
          abort(1381516338);
L_013f:
          code = opcode[index];
          if ((code & 32) == 0) goto L_0140;
          k = r1;
          r1 = base;
          base = k;
L_0140:
          cput((((code & 65280) + (actual[r1] << 4)) + actual[base]));
          goto L_013c;
L_013d:
          if (r1 == 0) goto L_0141;
          if (base != 1) goto L_0142;
L_0141:
          abort(1381516339);
L_0142:
          format = typeindex[type];
          if (format != 0) goto L_0143;
          abort(1381516340);
L_0143:
          code = opcode[(index + format)];
          if (((code & 15) & disp) == 0) goto L_0144;
          abort(1381516341);
L_0144:
          cput((((code & 65280) + (actual[r1] << 4)) + actual[base]));
          if (0 > disp) goto L_0145;
          if (disp > 16383) goto L_0145;
          if (x == 0) goto L_0146;
L_0145:
          cput(((16384 + (actual[x] << 8)) + ((disp >> 16) & 255)));
L_0146:
          cput(disp);
L_013c:
          if (base <= 0) goto L_0147;
          release(base);
L_0147:
          if (x == 0) goto L_0148;
          release(x);
L_0148:
          if ((code & 64) == 0) goto L_0149;
          ccca = ((ccca + ca) - oldca);
          goto L_014a;
L_0149:
          if ((code & 16) != 0) goto L_014b;
          ccca = ca;
          ccreg = r1;
L_014b:
L_014a:
L_0126:
          goto L_014c;
          void rr(int op, int r1, int r2)
{
          struct STACKFM v;
          v.closeoutput = r2;
          v.disp = 0;
          v.type = 1;
          if (r1 < 17) goto L_014d;
          v.type = 7;
L_014d:
          v.form = 1;
          rxd(op, r1, v);
L_014c:
          goto L_014e;
          void rxi(int op, int r1, int base, int disp)
{
          struct STACKFM v;
          v.closeoutput = base;
          v.disp = disp;
          v.type = 1;
          v.form = 0;
          rxd(op, r1, v);
L_014e:
          goto L_014f;
          void rx(int op, int r1, int base, int disp)
{
          struct STACKFM v;
          v.closeoutput = base;
          v.disp = disp;
          v.type = 1;
          if (r1 < 17) goto L_0150;
          v.type = 7;
L_0150:
          v.form = 4;
          rxd(op, r1, v);
L_014f:
          goto L_0151;
          void skip(int halfwords, int condition)
{
          // bounds [0 : 5]
          // do it now: const short  {*,2}jump {NO INIT}
          if ((condition & 16) == 0) goto L_0152;
          condition = inverted[condition];
L_0152:
          if (0 >= halfwords) goto L_0153;
          if (halfwords > 14) goto L_0153;
          if (0 > condition) goto L_0153;
          if (condition <= 5) goto L_0154;
L_0153:
          abort(1397444657);
L_0154:
          cput((jump[condition] | (halfwords + 1)));
L_0151:
          goto L_0155;
          void machinecode()
{
          // bounds [1 : 204]
          // do it now: const int  {*,2}mcop {NO INIT}
          // bounds [1 : 204]
          // do it now: const short  {*,2}opflags {NO INIT}
          char *opcode;
          struct VARFM *v;
          int op;
          int base;
          int disp;
          int index;
          int flags;
          int p;
          int n;
          int reg;
          goto L_0155;
          void mcerror(char *s)
{
          selectoutput(0);
          printsymbol(42);
          write(currentline, 3);
          space();
          printstring(opcode);
          printstring(": ");
          printstring(s);
          newline();
          selectoutput(2);
          for (;;) {
L_0156:
          if (sym == 59) goto L_0157;
          sym = next;
          readsymbol(next);
          }
L_0157:
L_0155:
          goto L_0158;
          void getopcode()
{
          strncpy(opcode,"",7+1);
          op = 0;
          for (;;) {
L_0159:
          sym = next;
          readsymbol(next);
          if (sym != 95) goto L_015a;
          goto L_015b;
L_015a:
          if (*length(opcode) == 6) goto L_015c;
          op = ((op << 6) ^ sym);
          strncpy(opcode,opcode,7+1);
L_015c:
          }
L_015b:
          sym = next;
          readsymbol(next);
L_0158:
          goto L_015d;
          int  findopcode()
{
          int high;
          int low;
          int p;
          high = 204;
          low = 1;
          for (;;) {
L_015e:
          if (high < low) goto L_015f;
          p = ((high + low) >> 1);
          if (mcop[p] != op) goto L_0160;
          return(p);
L_0160:
          if (mcop[p] <= op) goto L_0161;
          high = (p - 1);
          goto L_0162;
L_0161:
          low = (p + 1);
L_0162:
          }
L_015f:
          mcerror("unknown operation");
          return(0);
L_015d:
          goto L_0163;
          int value(int  *n)
{
          *n = 0;
          if (48 > sym) goto L_0164;
          if (sym <= 55) goto L_0165;
L_0164:
L_0165:
          for (;;) {
L_0166:
          *n = ((*n << 3) | (sym - 48));
          sym = next;
          readsymbol(next);
          if (48 > sym) goto L_0167;
          if (sym <= 55) goto L_0168;
L_0167:
L_0168:
          }
L_0163:
          goto L_0169;
          int register(int  *r)
{
          if (value(*r)) goto L_016a;
L_016a:
          if (0 > *r) goto L_016b;
          if (*r <= 15) goto L_016c;
L_016b:
L_016c:
L_0169:
          goto L_016d;
          int dealwithplusminus()
{
          int sign;
          int n;
          if (sym == 43) goto L_016e;
          if (sym == 45) goto L_016e;
L_016e:
          sign = sym;
          sym = next;
          readsymbol(next);
          if (value(n)) goto L_016f;
          mcerror("invalid offset");
L_016f:
          if (sign != 45) goto L_0170;
          n = (-n);
L_0170:
          disp = (disp + n);
L_016d:
          base = (-1);
          index = (-1);
          disp = 0;
          getopcode();
          p = findopcode();
          if (p != 0) goto L_0171;
          return;
L_0171:
          flags = opflags[p];
          if ((flags & 1) == 0) goto L_0172;
          reg = ((flags >> 4) & 15);
          goto L_0173;
L_0172:
          if (register(reg)) goto L_0174;
          mcerror("register 1?");
          return;
L_0174:
          if (sym == 44) goto L_0175;
          mcerror("comma missing");
          return;
L_0175:
          sym = next;
          readsymbol(next);
L_0173:
          if ((flags & 2) == 0) goto L_0176;
          if (register(base)) goto L_0177;
          mcerror("register 2?");
          return;
L_0177:
          goto L_0178;
L_0176:
          if (sym != 32) goto L_0179;
          n = tag();
          sym = next;
          readsymbol(next);
          v = &var[n];
          disp = v->disp;
          if (v->form != 14) goto L_017a;
          definereference((disp & 4095), 2);
          disp = 0;
          base = 15;
          if (dealwithplusminus()) goto L_017b;
          return;
L_017b:
          goto L_017c;
L_017a:
          if (v->base == 0) goto L_017d;
          base = actual[v->base];
L_017d:
          if (dealwithplusminus()) goto L_017e;
          return;
L_017e:
          if (sym != 40) goto L_017f;
          if (base <= 0) goto L_0180;
          goto U_010a;
L_0180:
          goto U_010b;
L_017f:
L_017c:
          goto L_0178;
L_0179:
          if (sym != 45) goto L_0181;
          if (!(dealwithplusminus())) goto L_0181;
          goto L_0182;
L_0181:
          if (value(disp)) goto L_0183;
          mcerror("displacement?");
          return;
L_0183:
L_0182:
          if (dealwithplusminus()) goto L_0184;
          return;
L_0184:
          if (sym != 40) goto L_0185;
U_010b:
          sym = next;
          readsymbol(next);
          if (register(base)) goto L_0186;
          mcerror("base register?");
          return;
L_0186:
          if (sym != 44) goto L_0187;
U_010a:
          sym = next;
          readsymbol(next);
          if ((flags & 4) != 0) goto L_0188;
          mcerror("no double indexed form");
          return;
L_0188:
          if (register(index)) goto L_0189;
          mcerror("index register?");
          return;
L_0189:
L_0187:
          if (sym == 41) goto L_018a;
          mcerror(") missing");
          return;
L_018a:
          sym = next;
          readsymbol(next);
L_0185:
L_0178:
          if (sym == 59) goto L_018b;
          mcerror("form?");
          return;
L_018b:
          if (base >= 0) goto L_018c;
          base = 0;
L_018c:
          if (index >= 0) goto L_018d;
          index = 0;
L_018d:
          if (base != 0) goto L_018e;
          if (index == 0) goto L_018e;
          base = index;
          index = 0;
L_018e:
          cput((((flags & 65280) + (reg << 4)) + base));
          if ((flags & 8) == 0) goto L_018f;
          cput((disp & 65535));
          goto L_0190;
L_018f:
          if ((flags & 16) == 0) goto L_0191;
          if ((flags & 1) != 0) goto L_0191;
          cput((disp >> 16));
          cput((disp & 65535));
          goto L_0190;
L_0191:
          if ((flags & 2) != 0) goto L_0192;
          if ((disp >> 14) != 0) goto L_0193;
          if (index <= 0) goto L_0194;
L_0193:
          if ((flags & 4) != 0) goto L_0195;
          mcerror("no RX3 form");
          return;
L_0195:
          cput(((16384 + (index << 8)) + ((disp >> 16) & 255)));
L_0194:
          cput((disp & 65535));
L_0192:
L_0190:
          for (;;) {
L_0196:
          goto L_0196;
          void setdopevector()
{
          int t;
          t = ((vub - vlb) + 1);
          claimliteral((4 * 4), 3);
          selectliteralarea();
          dv = ca;
          cword(1);
          cword(vlb);
          cword(vub);
          cword(datasize);
          selectcodearea();
          vub = (t * datasize);
          vlb = (vlb * datasize);
L_0196:
          goto L_0197;
          void perm(int n)
{
          // bounds [0 : 8]
          // do it now: const short  {*,2}rmap {NO INIT}
          int k;
          int r;
          int h;
          // bounds [1 : 50]
          // do it now: const short  {*,2}hazardreg {NO INIT}
          h = hazardreg[n];
          if (claimed == 0) goto L_0198;
          k = (h & 32767);
          r = 0;
          for (;;) {
L_0199:
          if (k == 0) goto L_019a;
          if ((k & 1) == 0) goto L_019b;
          hazard(rmap[r]);
L_019b:
          k = (k >> 1);
          r = (r + 1);
          }
L_019a:
L_0198:
          r = ((((h & (128 + 256)) << (17 - 7)) | (h & 127)) << 1);
          forgetreg(r);
          if (h >= 0) goto L_019c;
          if (wdisp == 0) goto L_019c;
          rxi(3, 8, 0, wdisp);
L_019c:
          definereference((n & 255), 3);
          rx(22, 16, 15, (n & 255));
          if (h >= 0) goto L_019d;
          if (wdisp == 0) goto L_019e;
          rxi(4, 8, 0, wdisp);
L_019e:
          wdisp = ((wdisp + 44) + 256);
L_019d:
L_0197:
          goto L_019f;
          void dumptrace()
{
          if (currentline == lastline) goto L_01a0;
          traceflag = 0;
          perm(50);
          cput(currentline);
L_01a0:
L_019f:
          goto L_01a1;
          void assemble(int amode, int labs, int names)
{
          // bounds [33 : 127]
          /*todo: gcc jump table extension*/ void **c;
          // bounds [65 : 90]
          /*todo: gcc jump table extension*/ void **pc;
          typedef struct EVFM{int low; int high; int events; int label;} evfm;
          struct EVFM event;
          memset(event,0,sizeof struct EVFM);
          struct VARFM *v;
          struct VARFM *gvar;
          struct STACKFM *lhs;
          struct STACKFM *rhs;
          struct STACKFM *x;
          int oldframe;
          int oldextraframe;
          int oldjump;
          int oldtempbase;
          int oldnexttemp;
          int trueframebase;
          int putativeframebase;
          int maxframe;
          int altfirst;
          int altalign;
          altalign = 0;
          int oldvardiags;
          int gstart;
          int labelstart;
          static int freetag;
          int maxlocal;
          maxlocal = 0;
          int maxparm;
          maxparm = 0;
          int minparm;
          minparm = 0;
          int markassigned;
          markassigned = 1;
          int closed;
          closed = 8;
          int returnlabel;
          returnlabel = 0;
          int px;
          px = 0;
          int procca;
          procca = ca;
          int swlist;
          swlist = 0;
          int lasta;
          lasta = (-1);
          int linesize;
          linesize = 0;
          int blockindex;
          int j;
          int k;
          int t;
          void compiletostring(struct STACKFM *v);
          void poplhs();
          void lrd(struct STACKFM *v, int reg);
          void load(struct STACKFM *v, int reg);
          void assign(int assop);
          void arrayref(int mode);
          void operate(int n);
          void compare(struct STACKFM *l, struct STACKFM *r, int next);
          void testzero(struct STACKFM *v);
          void header(struct VARFM *v);
          void blockmark(int mark);
          int  newtag();
          oldjump = uncondjump;
          uncondjump = (-1);
          oldvardiags = vardiags;
          vardiags = 0;
          labelstart = labs;
          oldframe = frame;
          oldextraframe = extraframe;
          extraframe = 0;
          oldtempbase = tempbase;
          oldnexttemp = nexttemp;
          tempbase = newtemp;
          nexttemp = newtemp;
U_0131:
          pdisp = 0;
          wdisp = 0;
          gdisp = (-1);
          event.events = 0;
          if (gdisp == (-1)) goto L_01a2;
          abort(758194239);
L_01a2:
          gvar = decvar;
          gstart = names;
          if (amode < 0) goto L_01a3;
          frame = 44;
          ca = 0;
          level = (level + 1);
          if (level <= 5) goto L_01a4;
          if (spec != 0) goto L_01a4;
          abort(1095577648);
L_01a4:
          local = breg[level];
          activity[local] = (-1);
          gdisp = ((7 - 6) * 4);
          if (spec != 0) goto L_01a5;
          resetoptimisationdata();
L_01a5:
          if (amode != 0) goto L_01a6;
          blockno = (blockno + 1);
          blockindex = blockno;
          blockmark(16);
          if (sym != 72) goto L_01a7;
          gdisp = (-1);
          if (level != 1) goto L_01a8;
          strncpy(externalid,programep,19+1);
          otype = 3;
          potype = otype;
L_01a8:
          header(*gvar);
L_01a7:
L_01a6:
          goto L_01a9;
L_01a3:
          if (amode != (-1)) goto L_01aa;
          gvar->extra = parms;
          frame = 0;
L_01aa:
          trueframebase = frame;
          putativeframebase = ((frame + 3) & (\3));
          frame = putativeframebase;
          maxframe = frame;
          altfirst = (parms - 1);
L_01a9:
          goto L_01a1;
          void blockmark(int mark)
{
          int k;
          int limit;
          k = 1;
          for (;;) {
L_01ab:
          selectoutput(k);
          printsymbol(mark);
          if (mark != 16) goto L_01ac;
          printsymbol(blockindex);
          if (k != 2) goto L_01ad;
          put(currentline);
          lastline = (-15);
          describe((-1), 0, blockname);
L_01ad:
          goto L_01ae;
L_01ac:
          if (k != 1) goto L_01af;
          if (freetag <= 32767) goto L_01b0;
          abort(1413564223);
L_01b0:
          put((ca >> 1));
          put(vardiags);
          frame = ((frame + 3) & (\3));
          k = (frame + extraframe);
          if ((control & 32) != 0) goto L_01b1;
          k = (k >> 2);
          limit = 65535;
          goto L_01b2;
L_01b1:
          limit = 32767;
L_01b2:
          if (0 >= k) goto L_01b3;
          if (k <= limit) goto L_01b4;
L_01b3:
          abort(1179798847);
L_01b4:
          put(k);
          printsymbol(actual[local]);
          put(event.events);
          put(event.label);
          put(event.low);
          totalca = (totalca + ca);
L_01af:
L_01ae:
          if (k != 2) goto L_01b5;
          goto L_01b6;
L_01b5:
          k = 2;
          }
L_01b6:
          lastca = (-1);
L_01a1:
          goto L_01b7;
          void setframepatch()
{
          if (diagnose >= 0) goto L_01b8;
          selectoutput(0);
          printstring("  Block index");
          write(blockindex, 1);
          newline();
          selectoutput(2);
L_01b8:
          printsymbol(15);
L_01b7:
          goto L_01b9;
          void definevar()
{
          int type;
          int form;
          int tf;
          int size;
          int format;
          int s;
          int new;
          int round;
          int dimension;
          int ignore;
          struct STACKFM temp;
          int k;
          // bounds [0 : 18]
          // do it now: const short  {*,2}fmap {NO INIT}
          // bounds [0 : 8]
          // do it now: const char  {*,2}vsize {NO INIT}
          static int primno;
          ignore = 0;
          if (amode < 0) goto L_01ba;
          if (amode != 1) goto L_01bb;
L_01ba:
          ignore = 1;
L_01bb:
          strncpy(internalid,"",19+1);
          new = 0;
          round = 3;
          decl = tag();
          if (decl != 0) goto L_01bc;
          parms = (parms - 1);
          if (parms > names) goto L_01bd;
          abort(1145460273);
L_01bd:
          decvar = &var[parms];
          memset(*decvar,0,sizeof struct VARFM);
          goto L_01be;
L_01bc:
          if (decl < parms) goto L_01bf;
          abort(1145460274);
L_01bf:
          decvar = &var[decl];
          if (decl <= names) goto L_01c0;
          names = decl;
          new = 1;
          memset(*decvar,0,sizeof struct VARFM);
L_01c0:
L_01be:
          for (;;) {
L_01c1:
          sym = next;
          readsymbol(next);
          if (sym != 44) goto L_01c2;
          goto L_01c3;
L_01c2:
          if (*length(internalid) == 12) goto L_01c4;
          strncpy(internalid,internalid,19+1);
L_01c4:
          }
L_01c3:
          if (internalid != "") goto L_01c5;
          ignore = 1;
L_01c5:
          tf = tag();
          readsymbol(next);
          type = (tf >> 4);
          form = (tf & 15);
          size = tag();
          readsymbol(next);
          diagtype = type;
          diagform = form;
          diagsize = size;
          if (type != 1) goto L_01c6;
          if (size == 1) goto L_01c6;
          if (size != 2) goto L_01c7;
          type = 3;
          round = 0;
L_01c7:
          if (size != 3) goto L_01c8;
          type = 2;
          round = 1;
L_01c8:
          size = vsize[type];
          goto L_01c9;
L_01c6:
          if (type != 2) goto L_01ca;
          type = 7;
          size = vsize[type];
          goto L_01c9;
L_01ca:
          if (type != 4) goto L_01cb;
          type = 6;
          format = size;
          decvar->format = format;
          if (format > names) goto L_01cc;
          size = (var[format].length & 65535);
L_01cc:
          goto L_01c9;
L_01cb:
          if (type != 3) goto L_01cd;
          type = 5;
          round = 0;
          decvar->length = size;
          size = (size + 1);
          goto L_01c9;
L_01cd:
          size = vsize[type];
L_01c9:
          if (type == 5) goto L_01ce;
          decvar->length = size;
L_01ce:
          decvar->type = type;
          decvar->xform = fmap[form];
          otype = tag();
          spec = ((otype >> 3) & 1);
          dimension = ((otype >> 8) & 255);
          otype = (otype & 7);
          if (otype == 0) goto L_01cf;
          if (otype < 3) goto L_01d0;
          if (alias == "") goto L_01d1;
          strncpy(externalid,alias,19+1);
          goto L_01d2;
L_01d1:
          if (otype != 4) goto L_01d3;
          strncpy(externalid,systemprefix,19+1);
          goto L_01d2;
L_01d3:
          strncpy(externalid,internalid,19+1);
L_01d2:
          if (otype > 5) goto L_01d4;
          otype = 3;
L_01d4:
L_01d0:
L_01cf:
          strncpy(alias,"",19+1);
          if (7 > form) goto L_01d5;
          if (form > 10) goto L_01d5;
          gtype = spec;
          if (otype == 0) goto L_01d6;
          if (spec == 0) goto L_01d6;
          if (otype != 6) goto L_01d7;
          primno = (primno + 1);
          decvar->flag = (decvar->flag | 4);
          decvar->header = primno;
          if (primno == 2) goto L_01d8;
          return;
L_01d8:
          otype = 3;
          strncpy(externalid,readsymfn,19+1);
L_01d7:
          gfix(3);
          decvar->disp = ga;
          decvar->base = 14;
          externallink(6, 0, ga);
          return;
L_01d6:
          if (gmode != 0) goto L_01d9;
          potype = otype;
          if (new == 0) goto L_01da;
          decvar->disp = newtag();
L_01da:
          if (spec != 0) goto L_01db;
          strncpy(blockname,internalid,19+1);
L_01db:
          return;
L_01d9:
          ignore = 1;
          otype = 0;
          size = 4;
          datasize = 4;
          goto L_01dc;
L_01d5:
          datasize = size;
          if (form == 1) goto L_01dd;
          round = 3;
          if (type != 0) goto L_01de;
          ignore = 1;
          decvar->extra = gmode;
          type = 4;
          size = 8;
          decvar->type = 4;
          goto L_01df;
L_01de:
          if (form == 11) goto L_01e0;
          if (form != 13) goto L_01e1;
L_01e0:
          ignore = 1;
          size = 0;
          if (form != 13) goto L_01e2;
          datasize = 4;
L_01e2:
          goto L_01df;
L_01e1:
          if (form == 12) goto L_01e3;
          if (form != 14) goto L_01e4;
L_01e3:
          ignore = 1;
          size = (2 * 4);
          round = 3;
          decvar->header = (-1);
          if (0 >= dimension) goto L_01e5;
          if (dimension <= 7) goto L_01e6;
L_01e5:
          abort(1145460275);
L_01e6:
          decvar->flag = (decvar->flag | dimension);
          goto L_01df;
L_01e4:
          size = 4;
L_01df:
L_01dd:
L_01dc:
          if (otype == 0) goto L_01e7;
          if (otype != 2) goto L_01e8;
          if (type != 5) goto L_01e9;
          if (form != 1) goto L_01e9;
          datasize = 0;
L_01e9:
          if (form == 2) goto L_01ea;
          if (form == 12) goto L_01ea;
          if (form != 14) goto L_01eb;
L_01ea:
          otype = 0;
          goto L_01ec;
L_01eb:
          ignore = 1;
L_01ec:
          goto L_01ed;
L_01e8:
          gfix(round);
          if (ignore == 1) goto L_01ee;
          setdiag(14, ga);
L_01ee:
L_01ed:
          owntype = type;
          ownform = form;
          if (form != 2) goto L_01ef;
          owntype = 1;
          datasize = 4;
L_01ef:
          decvar->header = (-1);
          if (spec != 0) goto L_01f0;
          if (form == 11) goto L_01f1;
          if (form != 13) goto L_01f2;
L_01f1:
          ownform = 11;
          decvar->flag = ((decvar->flag & (\96)) | (64 | 1));
          if (0 >= decvar->length) goto L_01f3;
          if (decvar->length > 32767) goto L_01f3;
          if ((-32768) > vlb) goto L_01f3;
          if (vub > 32767) goto L_01f3;
          decvar->flag = (decvar->flag | 32);
L_01f3:
          gfix(3);
          setdopevector();
          if (otype == 2) goto L_01f4;
          decvar->disp = ga;
          decvar->base = 14;
          gwordrel(((ga + 8) - vlb));
          gwordcrel(dv);
          goto L_01f5;
L_01f4:
          claimliteral(vub, 3);
          selectliteralarea();
          decvar->disp = ga;
          decvar->base = 14;
          gwordcrel((ca - vlb));
          gwordcrel(dv);
          selectcodearea();
L_01f5:
          if (otype != 3) goto L_01f6;
          externallink(5, 0, (ga - 8));
L_01f6:
L_01f2:
          goto L_01f7;
L_01f0:
          decvar->xform = ((decvar->xform + 3) | (8 << 8));
          if (form < 11) goto L_01f8;
          decvar->xform = (decvar->xform | (1 << 8));
L_01f8:
          decvar->base = 14;
          decvar->disp = 0;
          decvar->extra = (ga + 8);
          externallink(4, 0, ga);
L_01f7:
          return;
L_01e7:
          if (form != 3) goto L_01f9;
          decvar->disp = newtag();
          return;
L_01f9:
          if (form != 6) goto L_01fa;
          decvar->extra = vlb;
          decvar->length = ((vub - vlb) + 1);
          decvar->format = (freetag + 1);
          claimliteral(((((vub - vlb) + 1) + 2) * 2), 1);
          decvar->base = 15;
          decvar->disp = litmax;
          selectliteralarea();
          cput(vlb);
          cput(vub);
          for (s = vlb; s += 1; s != vub) {
          freetag = (freetag + 1);
          definereference(freetag, 4);
          cput(freetag);
          }
L_01fe:
          selectcodearea();
          return;
L_01fa:
          if (form != 4) goto L_01ff;
          if (gmode == 0) goto L_0200;
          if (decvar->length <= frame) goto L_0201;
          frame = decvar->length;
L_0201:
          goto L_0202;
L_0200:
          gtype = (-1);
          spec = (-1);
L_0202:
          return;
L_01ff:
          decvar->base = local;
          if (gdisp < 0) goto L_0203;
          if ((decvar->flag & 96) != 0) goto L_0203;
          if (decvar->form != 6) goto L_0204;
          if (decvar->type != 4) goto L_0205;
L_0204:
          if (decvar->form != 4) goto L_0203;
          if (decvar->type > 3) goto L_0203;
L_0205:
          decvar->disp = gdisp;
          gdisp = (gdisp - 4);
          if (decvar->form != 4) goto L_0206;
          if (2 > decvar->type) goto L_0206;
          if (decvar->type > 3) goto L_0206;
          decvar->disp = (decvar->disp + decvar->type);
L_0206:
          decvar->flag = (decvar->flag | 2);
          minparm = (minparm + 1);
          if ((control & 128) != 0) goto L_0207;
          temp.form = decvar->form;
          temp.type = decvar->type;
          temp.closeoutput = decvar->base;
          temp.disp = decvar->disp;
          if (temp.form != 6) goto L_0208;
          temp.form = 4;
          temp.type = 1;
L_0208:
          associate(temp, (7 - (minparm - 1)));
L_0207:
          goto L_0209;
L_0203:
          frame = ((frame + round) & (\round));
          maxlocal = frame;
          decvar->disp = frame;
          frame = (frame + size);
          altalign = (altalign | round);
L_0209:
          if (ignore != 0) goto L_020a;
          setdiag(local, decvar->disp);
L_020a:
L_01b9:
          goto L_020b;
          int checkable(struct STACKFM *v)
{
          if (v->form == 0) goto L_020c;
          if (v->form != 5) goto L_020d;
L_020c:
L_020d:
          if ((v->flag & 8) == 0) goto L_020e;
L_020e:
          if (v->type == 1) goto L_020f;
          if (v->type == 5) goto L_020f;
          if (v->type < 7) goto L_0210;
L_020f:
L_0210:
L_020b:
          goto L_0211;
          struct STACKFM descriptor ()
{
          struct DFM *d;
          struct STACKFM *v;
          stp = (stp + 1);
          if (stp <= 16) goto L_0212;
          abort(1146307377);
L_0212:
          v = descasl;
          if (v != null) goto L_0213;
          abort(1146307378);
L_0213:
          d = dasl;
          if (d != null) goto L_0214;
          abort(1146307379);
L_0214:
          descasl = &v->link;
          memset(*v,0,sizeof struct STACKFM);
          dasl = &d->link;
          d->link = &using.link;
          using.link = d;
          d->d = v;
          return(v);
L_0211:
          goto L_0215;
          void drop(struct STACKFM *descriptor)
{
          struct DFM *p;
          struct DFM *q;
          p = &using;
          for (;;) {
L_0216:
          q = &p->link;
          if (q != null) goto L_0217;
          abort(1146244944);
L_0217:
          if (&q->d != descriptor) goto L_0218;
          goto L_0219;
L_0218:
          p = q;
          }
L_0219:
          p->link = &q->link;
          q->link = dasl;
          dasl = q;
          descriptor->link = descasl;
          descasl = descriptor;
L_0215:
          goto L_021a;
          void vstack(int varno)
{
          struct VARFM *w;
          if (0 > varno) goto L_021b;
          if (varno <= 800) goto L_021c;
L_021b:
          abort(1448301643);
L_021c:
          w = &var[varno];
          lhs = &*descriptor();
          stacked[stp].v = lhs;
          lhs->sptfm = w->base;
          lhs->disp = w->disp;
          lhs->format = w->format;
          lhs->extra = w->extra;
          lhs->type = w->type;
          lhs->length = w->length;
          lhs->header = w->header;
          lhs->link = null;
          lhs->type = w->type;
          lhs->xform = w->xform;
          lhs->v = (w->flag & 7);
          lhs->varno = varno;
          if ((diagnose & 1) == 0) goto L_021d;
          monitor(*lhs, "V stack");
L_021d:
L_021a:
          goto L_021e;
          void sstack(struct STACKFM *v)
{
          struct STACKFM *t;
          t = &*descriptor();
          memcpy(*t,*v,sizeof struct STACKFM);
          stacked[stp].v = t;
          if ((diagnose & 1) == 0) goto L_021f;
          monitor(*t, "S STACK");
L_021f:
L_021e:
          goto L_0220;
          void cstack(int n)
{
          rhs = &*descriptor();
          rhs->sptfm = 0;
          rhs->disp = n;
          rhs->type = 1;
          rhs->form = 0;
          stacked[stp].v = rhs;
          if ((diagnose & 1) == 0) goto L_0221;
          monitor(*rhs, "C stack");
L_0221:
L_0220:
          goto L_0222;
          void cload(int value, int reg)
{
          cstack(value);
          poplhs();
          lrd(*lhs, reg);
L_0222:
          goto L_0223;
          void sset(int base, int disp, int xform, int extra)
{
          rhs = &*descriptor();
          rhs->sptfm = base;
          rhs->disp = disp;
          rhs->type = 1;
          rhs->xform = xform;
          rhs->extra = extra;
          rhs->link = null;
          stacked[stp].v = rhs;
          if ((diagnose & 1) == 0) goto L_0224;
          monitor(*rhs, "SSET");
L_0224:
L_0223:
          goto L_0225;
          void setlhs()
{
          lhs = &stacked[stp].v;
          if ((diagnose & 1) == 0) goto L_0226;
          monitor(*lhs, "SET LHS");
L_0226:
L_0225:
          goto L_0227;
          void setboth()
{
          if (stp > 1) goto L_0228;
          abort(1397052482);
L_0228:
          lhs = &stacked[(stp - 1)].v;
          rhs = &stacked[stp].v;
          if ((diagnose & 1) == 0) goto L_0229;
          monitor(*lhs, "BOTH LHS");
          monitor(*rhs, "BOTH RHS");
L_0229:
L_0227:
          goto L_022a;
          void poplhs()
{
          if (stp > 0) goto L_022b;
          abort(1347375180);
L_022b:
          lhs = &stacked[stp].v;
          stp = (stp - 1);
          if ((diagnose & 1) == 0) goto L_022c;
          monitor(*lhs, "POP LHS");
L_022c:
L_022a:
          goto L_022d;
          void popdrop()
{
          poplhs();
          if ((diagnose & 1) == 0) goto L_022e;
          monitor(*lhs, "POP DROP");
L_022e:
          drop(*lhs);
L_022d:
          goto L_022f;
          void dumpstring(int max)
{
          int j;
          if (max != 0) goto L_0230;
          max = (*cslen + 1);
          goto L_0231;
L_0230:
          if ((*cslen + 1) <= max) goto L_0232;
          if (*cslen != 128) goto L_0233;
          if (currentstring[1] == 128) goto L_0234;
L_0233:
          warn(5);
          currentstring[0] = (max - 1);
L_0234:
L_0232:
L_0231:
          if (otype != 2) goto L_0235;
          selectliteralarea();
          for (j = 0; j += 1; j != (max - 1)) {
          litbyte(currentstring[j]);
          }
L_0239:
          selectcodearea();
          goto L_023a;
L_0235:
          for (j = 0; j += 1; j != (max - 1)) {
          gbyte(currentstring[j]);
          }
L_023e:
L_023a:
L_022f:
          goto L_023f;
          void getstring()
{
          int l;
          l = next;
          *cslen = 0;
          for (;;) {
L_0240:
          if (l <= 0) goto L_0241;
          l = (l - 1);
          readsymbol(next);
          *cslen = ((*cslen + 1) & 255);
          currentstring[*cslen] = next;
          }
L_0241:
          readsymbol(next);
          if (next == 65) goto L_0242;
          if (next == 36) goto L_0242;
          if (next != 46) goto L_0243;
          if (*cslen != 1) goto L_0243;
          if ((control & (1 | 2)) != 0) goto L_0243;
          cstack(currentstring[1]);
          rhs->flag = (rhs->flag | 1);
          return;
L_0243:
          cstack(0);
          rhs->type = 5;
          otype = 2;
          rhs->sptfm = 15;
          rhs->xform = (4 | (8 << 8));
          rhs->format = (*cslen + 1);
          if (*cslen != 0) goto L_0244;
          if (nullstring != 0) goto L_0245;
L_0244:
          claimliteral((*cslen + 1), 1);
          rhs->disp = lita;
          dumpstring(0);
          if (nullstring != 0) goto L_0246;
          if (0 != *cslen) goto L_0246;
          nullstring = rhs->disp;
L_0246:
          goto L_0247;
L_0245:
          rhs->disp = nullstring;
L_0247:
          goto L_0248;
L_0242:
          cstack(0);
L_0248:
L_023f:
          goto L_0249;
          int  realconstant(int force)
{
          static int last;
          static int next;
          int j;
          int k;
          // bounds [0 : 31]
          // do it now: static int  {*,1}val {NO INIT}
          // bounds [0 : 31]
          // do it now: static short  {*,1}index {NO INIT}
          k = *integer(addr(rvalue));
          if (otype == 2) goto L_024a;
          gfix(3);
          gword(k);
          return((ga - 4));
L_024a:
          if (force != 0) goto L_024b;
          j = last;
          for (;;) {
L_024c:
          if (val[last] != k) goto L_024d;
          goto U_0149;
L_024d:
          last = ((last + 1) & 31);
          if (last != j) goto L_024e;
          goto L_024f;
L_024e:
          }
L_024f:
          claimliteral(4, (4 - 1));
L_024b:
          next = ((next + 1) & 31);
          last = next;
          selectliteralarea();
          val[last] = k;
          index[last] = ca;
          cword(k);
          selectcodearea();
U_0149:
          return(index[last]);
L_0249:
          goto L_0250;
          int  newtag()
{
          freetag = (freetag + 1);
          return(freetag);
L_0250:
          goto L_0251;
          struct LABELFM newlabel ()
{
          labs = (labs + 1);
          if (labs <= 80) goto L_0252;
          abort(1313620556);
L_0252:
          return(&labels[labs]);
L_0251:
          goto L_0253;
          struct LABELFM find (int label)
{
          int lp;
          struct LABELFM *l;
          lp = labs;
          for (;;) {
L_0254:
          if (lp == labelstart) goto L_0255;
          l = &labels[lp];
          if (l->id != label) goto L_0256;
          return(l);
L_0256:
          lp = (lp - 1);
          }
L_0255:
          return(null);
L_0253:
          goto L_0257;
          void definelabel(int label)
{
          int ltag;
          int new;
          struct LABELFM *l;
          struct ENVFM *e;
          ccca = 0;
          new = 0;
          if (label != 0) goto L_0258;
          return;
L_0258:
          if (label >= 0) goto L_0259;
          ltag = (-label);
          new = 1;
          goto L_025a;
L_0259:
          l = &*find(label);
          if (l != null) goto L_025b;
          l = &*newlabel();
          l->id = label;
          l->tag = newtag();
          new = 1;
          goto L_025c;
L_025b:
          if (l->tag >= 0) goto L_025d;
          if (label < 0) goto L_025d;
          l->tag = newtag();
          new = 1;
L_025d:
L_025c:
          l->tag = (l->tag | -32768);
          ltag = l->tag;
L_025a:
          if (new == 0) goto L_025e;
          e = &*environment(label);
          if (e == null) goto L_025f;
          e->label = 0;
L_025f:
L_025e:
          definetag((ltag & 32767));
          if (uncondjump == ca) goto L_0260;
          mergeenvironment(label);
L_0260:
          restoreenvironment(label);
          if (traceflag == 0) goto L_0261;
          if (next == 58) goto L_0262;
          if (next == 76) goto L_0262;
          dumptrace();
L_0262:
L_0261:
          uncondjump = 0;
          markassigned = 0;
L_0257:
          goto L_0263;
          void jumpto(int label, int cond, int def)
{
          struct LABELFM *lab;
          int ref;
          invert = 0;
          if ((cond & 16) == 0) goto L_0264;
          cond = inverted[cond];
L_0264:
          if (def < 0) goto L_0265;
          if (label != 0) goto L_0266;
          return;
L_0266:
          if (label >= 0) goto L_0267;
          jtag = (-label);
          goto L_0268;
L_0267:
          lab = &*find(label);
          if (lab != null) goto L_0269;
          lab = &*newlabel();
          lab->id = label;
          lab->tag = newtag();
          rememberenvironment(label);
          goto L_026a;
L_0269:
          if (lab->tag >= 0) goto L_026b;
          if (def != 1) goto L_026b;
          lab->tag = newtag();
          rememberenvironment(label);
          goto L_026a;
L_026b:
          if (lab->tag <= 0) goto L_026c;
          mergeenvironment(label);
L_026c:
L_026a:
          jtag = (lab->tag & 32767);
L_0268:
          goto L_026d;
L_0265:
          jtag = label;
L_026d:
          if (cond != 12) goto L_026e;
          ref = 5;
          goto L_026f;
L_026e:
          ref = 6;
L_026f:
          definereference(jtag, ref);
          cput(((jtag << 4) + (cond & 15)));
          ccca = (ccca + 2);
          if (cond != 12) goto L_0270;
          uncondjump = ca;
          if (next != 58) goto L_0271;
          traceflag = (control & 64);
L_0271:
          goto L_0272;
L_0270:
          traceflag = (control & 64);
L_0272:
          markassigned = 0;
L_0263:
          goto L_0273;
          void float(struct STACKFM *v, int r)
{
          int k;
          if (r != 26) goto L_0274;
          r = fpr();
L_0274:
          if (!(const(*v))) goto L_0275;
          if (v->disp != 0) goto L_0276;
          hazard(r);
          claim(r);
          rr(4, r, r);
          claim(r);
          v->type = 7;
          v->form = 1;
          v->sptfm = r;
          goto L_0277;
L_0276:
          rvalue = v->disp;
          otype = 2;
          k = realconstant(0);
          v->xform = ((8 << 8) | 4);
          v->type = 7;
          v->sptfm = 15;
          v->disp = k;
L_0277:
          goto L_0278;
L_0275:
          load(*v, 25);
          rr(13, r, v->sptfm);
          claim(r);
          v->form = 1;
          v->type = 7;
          v->sptfm = r;
L_0278:
L_0273:
          goto L_0279;
          void lrd(struct STACKFM *v, int reg)
{
          load(*v, reg);
          release(v->sptfm);
          drop(*v);
L_0279:
          goto L_027a;
          void quickload(int reg, int form, int base, int disp)
{
          struct STACKFM v;
          memset(v,0,sizeof struct STACKFM);
          v.type = 1;
          v.form = form;
          v.sptfm = base;
          v.disp = disp;
          load(v, reg);
L_027a:
          goto L_027b;
          void reduce(struct STACKFM *v)
{
          int type;
          int xform;
          int disp;
          int base;
          xform = (v->xform - 3);
          type = v->type;
          disp = v->disp;
          base = v->sptfm;
          v->disp = v->extra;
          v->type = 1;
          v->form = 4;
          load(*v, 25);
          v->type = type;
          v->xform = (xform & (\(8 << 8)));
          v->disp = disp;
L_027b:
          goto L_027c;
          void amap(struct STACKFM *v)
{
          int f;
          // bounds [0 : 15]
          // do it now: const short  {*,2}map {NO INIT}
          f = map[v->form];
          if (f >= 0) goto L_027d;
          if (v->form == 14) goto L_027e;
          abort(1095582032);
L_027e:
          f = gpr();
          forgetreg((1 << f));
          definereference((v->disp & 4095), 2);
          rx(23, f, 15, 0);
          v->type = 1;
          v->xform = 1;
          v->sptfm = f;
          v->disp = 0;
          claim(f);
          return;
L_027d:
          if (f == 7) goto L_027f;
          if (f != 8) goto L_0280;
L_027f:
          if (v->disp != 0) goto L_0280;
          if (f != 7) goto L_0281;
          f = 6;
          goto L_0282;
L_0281:
          f = 4;
L_0282:
          v->disp = v->extra;
L_0280:
          v->type = 1;
          v->form = f;
L_027c:
          goto L_0283;
          void amaps(struct STACKFM *v)
{
          int t;
          int l;
          t = v->type;
          l = v->length;
          amap(*v);
          if (t == 5) goto L_0284;
          return;
L_0284:
          if (v->form < 7) goto L_0285;
          reduce(*v);
L_0285:
          if (v->form == 4) goto L_0286;
          if (v->form != 6) goto L_0287;
L_0286:
          load(*v, 25);
L_0287:
          v->disp = (v->disp + (l << 24));
          v->form = 5;
L_0283:
          goto L_0288;
          void vmap(struct STACKFM *v)
{
          int mod;
          int f;
          int t;
          // bounds [0 : 8]
          // do it now: const short  {*,2}map {NO INIT}
          mod = 0;
          if (v->oper == 0) goto L_0289;
          if (v->oper == 3) goto L_028a;
          if (v->oper != 4) goto L_028b;
L_028a:
          if (!(const(v->link))) goto L_028b;
          mod = v->link.disp;
          if (v->oper != 4) goto L_028c;
          mod = (-mod);
L_028c:
          v->oper = 0;
          drop(v->link);
L_028b:
          load(*v, 25);
          goto L_028d;
L_0289:
          if (v->form == 6) goto L_028e;
          if (v->form != 9) goto L_028f;
L_028e:
          t = v->type;
          amap(*v);
          load(*v, 25);
          v->type = t;
          v->form = 4;
L_028f:
L_028d:
          f = map[v->form];
          if (f >= 0) goto L_0290;
          abort(1447903568);
L_0290:
          v->form = f;
          v->disp = (v->disp + mod);
L_0288:
          goto L_0291;
          void address(struct STACKFM *v, int mode)
{
          int type;
          int form;
          int reg;
          int d;
          int cr;
          static struct STACKFM *last;
          if ((diagnose & 2) == 0) goto L_0292;
          monitor(*v, "ADDRESS");
L_0292:
          reg = mode;
          if (reg > 0) goto L_0293;
          reg = 25;
          if (v->type >= 7) goto L_0294;
          if (v->oper == 0) goto L_0295;
          if (!(floating(*v))) goto L_0295;
L_0294:
          reg = 26;
L_0295:
L_0293:
          cr = reg;
          if (v->oper == 0) goto L_0296;
          if (v->oper != 3) goto L_0297;
          if (!(const(v->link))) goto L_0297;
          if (v->type > 3) goto L_0297;
          d = v->link.disp;
          drop(v->link);
          v->oper = 0;
          load(*v, reg);
          v->disp = d;
          v->form = 5;
          goto L_0298;
L_0297:
          load(*v, reg);
L_0298:
          goto U_0155;
L_0296:
          form = v->form;
          type = v->type;
          if (form < 7) goto L_0299;
          reduce(*v);
          form = v->form;
L_0299:
          if ((control & 128) != 0) goto L_029a;
          cheapreg = cr;
          cheapen(*v, mode);
          cr = cheapreg;
          form = v->form;
L_029a:
          if (form == 1) goto L_029b;
          if (form != 0) goto L_029c;
L_029b:
          goto U_0155;
L_029c:
          if (form != 5) goto L_029d;
          if (v->sptfm != 0) goto L_029e;
          v->form = 0;
          goto L_029f;
L_029e:
          if (v->disp != 0) goto L_02a0;
          v->form = 1;
L_02a0:
L_029f:
          goto U_0155;
L_029d:
          if (form != 6) goto L_02a1;
          v->form = 4;
          v->type = 1;
          load(*v, 25);
          v->type = type;
          v->xform = (((v->flag & (\8)) << 8) | 4);
          v->disp = 0;
          form = 4;
L_02a1:
          if (last == v) goto L_02a2;
          last = v;
          if (mode < 0) goto L_02a3;
          if ((control & 2) == 0) goto L_02a4;
          if (v->type == 5) goto L_02a4;
          if (checkable(*v)) goto L_02a5;
L_02a4:
          if (v->type != 3) goto L_02a3;
L_02a5:
          load(*v, reg);
L_02a3:
          last = null;
L_02a2:
U_0155:
          cheapreg = cr;
L_0291:
          goto L_02a6;
          void load(struct STACKFM *v, int r)
{
          struct STACKFM *w;
          // bounds [0 : 9]
          /*todo: gcc jump table extension*/ void **f;
          // bounds [1 : 17]
          /*todo: gcc jump table extension*/ void **iop;
          // bounds [1 : 17]
          /*todo: gcc jump table extension*/ void **rop;
          struct STACKFM z;
          struct STACKFM *temprhs;
          int op;
          int d;
          int type;
          int temp;
          int n;
          int uflag;
          // bounds [1 : 16]
          // do it now: const char  {*,2}twin {NO INIT}
          goto L_02a6;
          void pickup(struct STACKFM *v)
{
          int old;
          load(*v, r);
          if (r == 25) goto L_02a7;
          if (r != 26) goto L_02a8;
L_02a7:
          old = r;
          r = v->sptfm;
          if (activity[r] == 1) goto L_02a9;
          if (activity[r] != 2) goto L_02aa;
          if (w->sptfm != r) goto L_02aa;
L_02a9:
          return;
L_02aa:
          if (old != 25) goto L_02ab;
          r = gpr();
          goto L_02ac;
L_02ab:
          r = fpr();
L_02ac:
          load(*v, r);
          goto L_02ad;
L_02a8:
          if (activity[r] == 1) goto L_02ae;
          abort(1349084011);
L_02ae:
L_02ad:
L_02a6:
          if ((diagnose & 2) == 0) goto L_02af;
          monitor(*v, "LOAD");
L_02af:
          if (floating(*v)) goto L_02b0;
          if (17 > r) goto L_02b1;
          if (r <= 24) goto L_02b0;
L_02b1:
          if (r != 26) goto L_02b2;
L_02b0:
          goto U_015d;
L_02b2:
          op = v->oper;
          v->oper = 0;
          if (op == 0) goto L_02b3;
          w = &v->link;
          if (w->sptfm != r) goto L_02b4;
          if (r == v->sptfm) goto L_02b4;
          load(*w, 25);
L_02b4:
          goto *iop[op];
L_02b3:
          if (v->type == 0) goto L_02b5;
          if (v->type == 5) goto L_02b5;
          if (v->type != 6) goto L_02b6;
L_02b5:
          amap(*v);
L_02b6:
          address(*v, r);
          if (r != 25) goto L_02b7;
          if (v->form != 1) goto L_02b8;
          return;
L_02b8:
          if (v->form != 5) goto L_02b9;
          if (activity[v->sptfm] != 1) goto L_02b9;
          if ((-15) > v->disp) goto L_02b9;
          if (v->disp > 15) goto L_02b9;
          r = v->sptfm;
          goto L_02ba;
L_02b9:
          r = gpr();
L_02ba:
          goto L_02bb;
L_02b7:
          if (v->sptfm != r) goto L_02bc;
          if (activity[r] <= 1) goto L_02bd;
          release(r);
          v->sptfm = 0;
          hazard(r);
          claim(r);
          v->sptfm = r;
L_02bd:
          goto L_02be;
L_02bc:
          hazard(r);
L_02be:
L_02bb:
          goto *f[v->form];
f_8:
f_9:
f_7:
f_6:
          abort(4998193);
f_5:
f_0:
          if (v->type < 7) goto L_02bf;
          abort(4998194);
L_02bf:
          rxi(1, r, v->sptfm, v->disp);
          forgetreg((1 << r));
          if (r == v->sptfm) goto L_02c0;
          associate(*v, r);
L_02c0:
U_015e:
          v->type = 1;
U_015f:
          v->form = 1;
          v->sptfm = r;
          v->disp = 0;
          claim(r);
          return;
f_1:
          if (v->sptfm != r) goto L_02c1;
          return;
L_02c1:
          rr(1, r, v->sptfm);
          forgetreg((1 << r));
          v->sptfm = r;
          claim(r);
          return;
f_4:
          uflag = (control & 2);
          if (1 >= v->type) goto L_02c2;
          if (v->type >= 7) goto L_02c2;
          if (2 == v->type) goto L_02c3;
          if (v->type == 3) goto L_02c3;
          abort(4998195);
L_02c3:
          uflag = 0;
          goto L_02c4;
L_02c2:
          if ((v->flag & 8) != 0) goto L_02c5;
          if (!(checkable(*v))) goto L_02c5;
          if (v->type != 255) goto L_02c6;
L_02c5:
          uflag = 0;
L_02c6:
L_02c4:
          if (v->type != 255) goto L_02c7;
          v->type = 2;
          rxd(37, r, *v);
          forgetreg((1 << r));
          goto L_02c8;
L_02c7:
          rxd(1, r, *v);
          forgetreg((1 << r));
          associate(*v, r);
L_02c8:
          if (uflag == 0) goto L_02c9;
          if (v->type >= 7) goto L_02ca;
          v->type = 1;
          if (level == 5) goto L_02cb;
          rr(28, r, 13);
          goto L_02cc;
L_02cb:
          rx(28, r, 15, 12);
L_02cc:
          goto L_02cd;
L_02ca:
          v->type = 7;
          rx(7, r, 15, 12);
L_02cd:
          rr(22, 16, 15);
          v->flag = (v->flag & (\8));
L_02c9:
          goto U_015f;
iop_8:
          if ((control & 2) != 0) goto L_02ce;
          if (w->form != 0) goto L_02ce;
          address(*v, r);
          if (w->disp != 65535) goto L_02cf;
          if (v->form != 4) goto L_02d0;
          if (v->type == 1) goto L_02d1;
          if (v->type != 2) goto L_02d0;
L_02d1:
          if (v->type != 1) goto L_02d2;
          v->disp = (v->disp + 2);
L_02d2:
U_0160:
          v->type = 255;
          drop(*w);
          load(*v, r);
          return;
L_02d0:
          goto L_02d3;
L_02cf:
          if (w->disp != 255) goto L_02d4;
          drop(*w);
          if (v->form != 1) goto L_02d5;
          if (r != 25) goto L_02d6;
          r = gpr();
L_02d6:
          rr(31, r, v->sptfm);
          goto U_015e;
L_02d5:
          if (v->type != 1) goto L_02d7;
          v->disp = (v->disp + 3);
          goto L_02d8;
L_02d7:
          if (v->type != 2) goto L_02d9;
          v->disp = (v->disp + 1);
L_02d9:
L_02d8:
          v->type = 3;
          load(*v, r);
          return;
L_02d4:
L_02d3:
L_02ce:
iop_3:
iop_4:
iop_9:
iop_10:
          pickup(*v);
          address(*w, 0);
          rxd(op, r, *w);
          goto U_0161;
iop_12:
          if ((control & 2) != 0) goto L_02da;
          if (w->form != 0) goto L_02da;
          if (w->disp != 16) goto L_02da;
          address(*v, r);
          if (v->form != 4) goto L_02db;
          if (v->type != 1) goto L_02db;
          goto U_0160;
L_02db:
L_02da:
iop_11:
          if (w->form == 0) goto L_02dc;
          if ((control & 1) == 0) goto L_02dc;
          load(*w, 3);
          perm(29);
L_02dc:
          pickup(*v);
          if (w->form != 0) goto L_02dd;
          if (0 > w->disp) goto L_02de;
          if (w->disp <= ((8 * 4) - 1)) goto L_02df;
L_02de:
          warn(6);
L_02df:
          goto L_02e0;
L_02dd:
          if (w->form == 1) goto L_02e1;
          load(*w, 25);
L_02e1:
          w->disp = 0;
L_02e0:
          rxi(op, v->sptfm, w->sptfm, w->disp);
          goto U_0161;
iop_1:
iop_2:
          abort(4998196);
iop_6:
          if (w->form != 0) goto L_02e2;
          n = power(w->disp);
          if (n <= 0) goto L_02e3;
          pickup(*v);
          testzero(*v);
          r = v->sptfm;
          claim(r);
          d = 1;
          if (n <= 4) goto L_02e4;
          d = 2;
L_02e4:
          skip(d, 5);
          rxi(3, v->sptfm, 0, (\((-1) << n)));
          rxi(29, v->sptfm, 0, n);
          goto U_0161;
L_02e3:
L_02e2:
iop_5:
iop_14:
          if (r != 25) goto L_02e5;
          n = 0;
          if (op != 5) goto L_02e6;
          n = 1;
L_02e6:
          if (!(infreereg(*v))) goto L_02e7;
          if ((actual[v->sptfm] & 1) != n) goto L_02e7;
          if (activity[twin[v->sptfm]] != 0) goto L_02e7;
          temp = v->sptfm;
          if (op == 5) goto L_02e8;
          temp = twin[temp];
L_02e8:
          goto L_02e9;
L_02e7:
          temp = evenoddpair();
L_02e9:
          goto L_02ea;
L_02e5:
          if ((actual[r] & 1) == 0) goto L_02eb;
          if (activity[twin[r]] != 0) goto L_02eb;
          temp = r;
          goto L_02ec;
L_02eb:
          temp = evenoddpair();
L_02ec:
L_02ea:
          n = twin[temp];
          claim(n);
          load(*v, temp);
          release(n);
          hazard(n);
          claim(n);
          d = op;
          if (op == 5) goto L_02ed;
          rr(1, n, temp);
          claim(temp);
          rxi(29, n, 0, 31);
          d = 6;
L_02ed:
          forgetreg(((2 + 1) << n));
          address(*w, 0);
          if (w->form == 0) goto L_02ee;
          if (w->form == 5) goto L_02ee;
          if (w->type == 1) goto L_02ef;
L_02ee:
          load(*w, 25);
L_02ef:
          rxd(d, n, *w);
          release(n);
          if (op != 5) goto L_02f0;
          if ((control & 1) == 0) goto L_02f1;
          if (n == 1) goto L_02f2;
          claim(n);
          rr(1, 1, n);
L_02f2:
          perm(21);
L_02f1:
          goto L_02f3;
L_02f0:
          if (op != 14) goto L_02f4;
          claim(n);
          release(temp);
          d = temp;
          temp = n;
          n = d;
L_02f4:
L_02f3:
          v->sptfm = temp;
          v->disp = 0;
          v->form = 1;
          if (temp == r) goto L_02f5;
          load(*v, r);
L_02f5:
          goto U_0161;
iop_13:
          if (r == v->sptfm) goto L_02f6;
          if (v->type != 3) goto L_02f7;
L_02f6:
          load(*v, 25);
          goto L_02f8;
L_02f7:
          address(*v, 0);
          if (v->form == 4) goto L_02f9;
          if (v->form == 1) goto L_02f9;
          if (v->form == 0) goto L_02f9;
          load(*v, 25);
L_02f9:
L_02f8:
          if (v->type != 1) goto L_02fa;
          v->disp = (v->disp + (4 / 2));
L_02fa:
          pickup(*w);
          rxd(13, r, *v);
          v->sptfm = r;
          v->disp = 0;
          v->xform = 1;
          goto U_0161;
iop_15:
          load(*v, 4);
          load(*w, 3);
          release(4);
          release(3);
          perm(2);
          claim(2);
          v->sptfm = 2;
          goto U_0161;
iop_7:
          address(*v, r);
          if (v->type == 0) goto L_02fb;
          if (pdisp != 0) goto L_02fc;
          pdisp = 44;
L_02fc:
          temprhs = rhs;
          sset(8, pdisp, 4, 0);
          rhs->type = 5;
          rhs->length = 255;
          rhs = temprhs;
          sstack(*v);
          v->sptfm = 0;
          assign(1);
          claim(3);
          v->type = 5;
          v->form = 4;
          v->sptfm = 3;
          v->disp = 0;
          v->length = 255;
          pdisp = (pdisp + 256);
L_02fb:
          if ((w->flag & 1) == 0) goto L_02fd;
          memcpy(z,*v,sizeof struct STACKFM);
          claim(z.sptfm);
          z.type = 3;
          load(z, 25);
          rxi(1, z.sptfm, z.sptfm, 1);
          claim(z.sptfm);
          load(*w, 25);
          v->rem = z.sptfm;
          v->type = 3;
          v->form = 4;
          rxd(2, w->sptfm, *v);
          release(w->sptfm);
          claim(v->sptfm);
          v->rem = 0;
          rxd(2, z.sptfm, *v);
          goto L_02fe;
L_02fd:
          load(*v, 3);
          load(*w, 2);
          release(2);
          release(3);
          n = v->length;
          if (n != 0) goto L_02ff;
          n = 255;
L_02ff:
          perm(6);
          cput(n);
          v->form = 4;
L_02fe:
          claim(v->sptfm);
          v->type = 0;
          if (r == 25) goto L_0300;
          if (r == 0) goto L_0300;
          load(*v, r);
          v->type = 0;
          v->form = 4;
L_0300:
          drop(*w);
          return;
U_015d:
          if (r != 25) goto L_0301;
          abort(4998197);
L_0301:
          op = v->oper;
          v->oper = 0;
          if (op == 0) goto L_0302;
          w = &v->link;
          goto *rop[op];
rop_1:
rop_11:
rop_12:
rop_8:
rop_9:
rop_10:
rop_7:
rop_13:
          abort(4998198);
rop_17:
          op = 6;
rop_6:
rop_3:
rop_4:
rop_5:
          if (w->type >= 7) goto L_0303;
          float(*w, 26);
          if (w->form != 1) goto L_0304;
          if (1 == v->form) goto L_0304;
          if (v->type < 7) goto L_0304;
          if (op == 3) goto L_0305;
          if (op != 5) goto L_0304;
L_0305:
          memcpy(z,*v,sizeof struct STACKFM);
          memcpy(*v,*w,sizeof struct STACKFM);
          memcpy(*w,z,sizeof struct STACKFM);
L_0304:
L_0303:
          pickup(*v);
          r = v->sptfm;
          address(*w, 0);
          rxd(op, r, *w);
          goto U_0161;
rop_2:
          abort(4998199);
L_0302:
          if (v->type >= 7) goto L_0306;
          float(*v, r);
L_0306:
          address(*v, r);
          if (v->form != 1) goto L_0307;
          if (r == 26) goto L_0308;
          if (v->sptfm != r) goto L_0309;
L_0308:
          return;
L_0309:
          hazard(r);
          rr(1, r, v->sptfm);
          v->sptfm = r;
          claim(r);
          return;
L_0307:
          if (r != 26) goto L_030a;
          r = fpr();
          goto L_030b;
L_030a:
          if (r == v->sptfm) goto L_030c;
          hazard(r);
L_030c:
L_030b:
          if (17 > r) goto L_030d;
          if (r <= 24) goto L_030e;
L_030d:
          abort(4998200);
L_030e:
          goto *f[v->form];
rop_16:
          if (w->type < 7) goto L_030f;
          abort(4998201);
L_030f:
          load(*v, 18);
          load(*w, 2);
          release(18);
          release(2);
          perm(3);
          claim(17);
          v->sptfm = 17;
U_0161:
          if (v->type > 3) goto L_0310;
          v->type = 1;
L_0310:
          forgetreg((1 << v->sptfm));
          drop(*w);
          for (;;) {
L_0311:
          goto L_0311;
          void cop(int op, struct STACKFM *lh, struct STACKFM *rh)
{
          int l;
          int r;
          // bounds [1 : 17]
          /*todo: gcc jump table extension*/ void **s;
          goto L_0311;
          int  p10(int n)
{
          int value;
          int power;
          value = 1;
          power = 0;
          for (;;) {
L_0312:
          if (value < n) goto L_0313;
          return(power);
L_0313:
          value = (value * 10);
          power = (power + 1);
          if (power <= 100) goto L_0314;
          abort(1129271345);
L_0314:
          }
L_0311:
          l = lh->disp;
          r = rh->disp;
          goto *s[op];
s_2:
s_1:
s_7:
          abort(1129271346);
s_3:
          l = (l + r);
          goto U_0155;
s_4:
          l = (l - r);
          goto U_0155;
s_9:
          l = (l | r);
          goto U_0155;
s_8:
          l = (l & r);
          goto U_0155;
s_10:
          l = (l ^ r);
          goto U_0155;
s_11:
          l = (l << r);
          goto U_0155;
s_5:
          l = (l * r);
          goto U_0155;
s_13:
          l = (l * r);
          goto U_0155;
s_12:
          l = (l >> r);
          goto U_0155;
s_15:
          l = imp_int_exp(l, r);
          goto U_0155;
s_6:
          if (r != 0) goto L_0315;
          warn(1);
          r = 1;
L_0315:
          l = (l / r);
          goto U_0155;
s_14:
          if (r != 0) goto L_0316;
          warn(1);
          r = 1;
L_0316:
          l = (l - ((l / r) * r));
          goto U_0155;
s_16:
          if ((p10(abs(l)) * r) <= 70) goto L_0317;
          warn(7);
          r = 0;
L_0317:
          rvalue = imp_real_exp(l, r);
          goto U_0156;
s_17:
          if (r != 0) goto L_0318;
          warn(1);
          r = 1;
L_0318:
          rvalue = (l / r);
U_0156:
          otype = 2;
          l = realconstant(0);
          lh->sptfm = 15;
          lh->type = 7;
          lh->form = 4;
U_0155:
          lh->disp = l;
          for (;;) {
L_0319:
          goto L_0319;
          void operate(int oper)
{
          struct STACKFM *lh;
          struct STACKFM *rh;
          struct STACKFM *with;
          int key;
          int lcon;
          int rcon;
          int wcon;
          int lop;
          // bounds [3 : 17]
          // do it now: const char  {*,2}transitive {NO INIT}
          // bounds [3 : 17]
          // do it now: const char  {*,2}commutative {NO INIT}
          // bounds [3 : 17]
          // do it now: const short  {*,2}nopvalue {NO INIT}
          goto L_0319;
          void pickup(struct STACKFM *v)
{
          if (!(floating(*v))) goto L_031a;
          load(*v, 26);
          goto L_031b;
L_031a:
          load(*v, 25);
L_031b:
L_0319:
          stp = (stp - 1);
          lcon = 0;
          rcon = 0;
          wcon = 0;
          lh = &stacked[stp].v;
          if (!(const(*lh))) goto L_031c;
          lcon = 1;
          goto L_031d;
L_031c:
          if (lh->type == 5) goto L_031e;
          if (lh->type == 0) goto L_031e;
          if (lh->oper != 0) goto L_031f;
          address(*lh, 0);
L_031f:
L_031e:
L_031d:
          rh = &stacked[(stp + 1)].v;
          if (!(const(*rh))) goto L_0320;
          rcon = 1;
          if (oper != 4) goto L_0321;
          oper = 3;
          rh->disp = (-rh->disp);
L_0321:
L_0320:
          if (lh->oper == 0) goto L_0322;
          lop = lh->oper;
          with = &lh->link;
          if (!(const(*with))) goto L_0323;
          wcon = 1;
L_0323:
          if ((wcon & rcon) == 0) goto L_0324;
          key = (transitive[oper] | transitive[lop]);
          if (key == 0) goto L_0325;
          if (key != 1) goto L_0326;
          if (oper != lop) goto L_0326;
L_0325:
          if (lop != 4) goto L_0327;
          with->disp = (-with->disp);
          lop = 3;
L_0327:
          cop(oper, *rh, *with);
          drop(*with);
          lh->link = rh;
          lh->oper = lop;
          goto U_015b;
L_0326:
L_0324:
          pickup(*lh);
L_0322:
          if (rcon == 0) goto L_0328;
          if (lcon != 0) goto L_0329;
          if (oper != 3) goto L_032a;
          if (lh->type != 1) goto L_032a;
          if (lh->form == 1) goto L_0329;
          if (lh->form != 5) goto L_032a;
L_0329:
          if (lh->form != 1) goto L_032b;
          lh->form = 5;
L_032b:
          cop(oper, *lh, *rh);
          drop(*rh);
          return;
L_032a:
L_0328:
          if (rh->oper == 0) goto L_032c;
          pickup(*rh);
          goto L_032d;
L_032c:
          if (rcon == 0) goto L_032e;
          if (rh->disp != 2) goto L_032e;
          if (oper == 5) goto L_032f;
          if (oper == 15) goto L_032f;
          if (oper != 16) goto L_0330;
L_032f:
          if (oper != 5) goto L_0331;
          oper = 3;
          goto L_0332;
L_0331:
          oper = 5;
L_0332:
          memcpy(*rh,*lh,sizeof struct STACKFM);
          rcon = 0;
          claim(rh->sptfm);
L_0330:
L_032e:
L_032d:
          if (commutative[oper] == 0) goto L_0333;
          if (lcon != 0) goto L_0334;
          if (lh->form == 1) goto L_0333;
          if (rh->form != 1) goto L_0333;
          if (activity[rh->sptfm] < 0) goto L_0333;
L_0334:
          rh->link = lh;
          stacked[stp].v = rh;
          rh->oper = oper;
          with = rh;
          rh = lh;
          lh = with;
          rcon = lcon;
          goto L_0335;
L_0333:
          lh->oper = oper;
          lh->link = rh;
L_0335:
U_015b:
          if (rcon == 0) goto L_0336;
          if (rh->disp != nopvalue[oper]) goto L_0337;
          lh->oper = 0;
          drop(*rh);
          goto L_0338;
L_0337:
          if (oper != 5) goto L_0339;
          if ((control & 1) != 0) goto L_0339;
          key = power(rh->disp);
          if (key <= 0) goto L_033a;
          lh->oper = 11;
          rh->disp = key;
L_033a:
L_0339:
L_0338:
L_0336:
          for (;;) {
L_033b:
          goto L_033b;
          void assign(int assop)
{
          // bounds [-1 : 3]
          // do it now: const char  {*,2}stringmove {NO INIT}
          struct STACKFM *lh;
          struct STACKFM *rh;
          struct STACKFM *x;
          struct STACKFM temp;
          int n;
          int p;
          int t;
          int op;
          int insert;
          int form;
          int lhdisp;
          insert = 0;
          if (stp >= 2) goto L_033c;
          abort(1095979825);
L_033c:
          rh = &stacked[stp].v;
          lh = &stacked[(stp - 1)].v;
          form = lh->form;
          if ((diagnose & 4) == 0) goto L_033d;
          monitor(*lh, "ASS LH");
          monitor(*rh, "ASS RH");
L_033d:
          if (assop >= 0) goto L_033e;
          if ((lh->flag & 4) == 0) goto L_033f;
          memcpy(temp,*lh,sizeof struct STACKFM);
          memcpy(*lh,*rh,sizeof struct STACKFM);
          memcpy(*rh,temp,sizeof struct STACKFM);
          pdisp = 0;
          return;
L_033f:
          lh->extra = (lh->extra - 1);
          vstack(lh->extra);
          lh = &stacked[stp].v;
          form = lh->form;
          lhdisp = lh->disp;
          if (lh->form == 4) goto L_0340;
          assop = 0;
L_0340:
          if ((lh->flag & 2) != 0) goto L_0341;
          pdisp = (lh->disp + lh->length);
          if (lh->type != 5) goto L_0342;
          if (form != 4) goto L_0342;
          pdisp = (pdisp + 1);
L_0342:
          lh->disp = (lh->disp + wdisp);
L_0341:
          if ((lh->flag & 16) == 0) goto L_0343;
          assop = 1;
          lh->type = 1;
          lh->form = 4;
          rh->type = 1;
          rh->form = 5;
          if (rh->sptfm == 0) goto L_0344;
          if (rh->sptfm == 14) goto L_0344;
          rh->form = 4;
          goto L_0345;
L_0344:
          if (rh->sptfm != 14) goto L_0346;
          rh->disp = (rh->disp - (5 * 4));
          goto L_0345;
L_0346:
          p = ((frame + 3) & (\3));
          frame = (p + (8 * 4));
          t = rh->disp;
          rh->disp = p;
          rh->sptfm = local;
          definereference(t, 2);
          rx(23, 16, 15, 0);
          rx(25, 9, local, p);
L_0345:
L_0343:
L_033e:
          stp = (stp - 2);
          if ((rh->flag & 96) == 0) goto L_0347;
          pdisp = (lh->disp + (2 * 4));
          hazard(1);
          address(*lh, (-1));
          address(*rh, (-1));
          if (rh->header != (-1)) goto L_0348;
          rx(1, 1, rh->sptfm, rh->disp);
          goto L_0349;
L_0348:
          rxi(1, 1, rh->sptfm, rh->disp);
          rx(3, 1, 14, rh->header);
          rh->disp = rh->header;
          rh->sptfm = 14;
L_0349:
          if (lh->type != 5) goto L_034a;
          if (lh->length != 0) goto L_034a;
          rxi(3, 1, 0, (rh->length << 24));
L_034a:
          forgetreg((1 << 1));
          rx(2, 1, lh->sptfm, lh->disp);
          claim(rh->sptfm);
          rx(1, 1, rh->sptfm, (rh->disp + 4));
          claim(lh->sptfm);
          rx(2, 1, lh->sptfm, (lh->disp + 4));
          drop(*lh);
          drop(*rh);
          return;
L_0347:
          if (lh->type != 4) goto L_034b;
          if (assop == 0) goto L_034c;
          abort(1095979826);
L_034c:
          if (rh->type != 4) goto L_034d;
          amap(*lh);
          address(*lh, (-1));
          amap(*rh);
          address(*rh, (-1));
          hazard(1);
          rx(1, 1, rh->sptfm, rh->disp);
          rx(2, 1, lh->sptfm, lh->disp);
          claim(lh->sptfm);
          claim(rh->sptfm);
          rx(1, 1, rh->sptfm, (rh->disp + 4));
          rx(2, 1, lh->sptfm, (lh->disp + 4));
          drop(*lh);
          drop(*rh);
          return;
L_034d:
          t = rh->type;
          rh->flag = (rh->flag | 8);
          n = rh->length;
          if (t != 5) goto L_034e;
          n = (n + 1);
L_034e:
          amaps(*rh);
          lrd(*rh, 25);
          p = rh->sptfm;
          rx(2, p, lh->sptfm, lh->disp);
          claim(lh->sptfm);
          cload(((n << 4) + genmap[t]), p);
          rx(2, p, lh->sptfm, (lh->disp + 4));
          drop(*lh);
          return;
L_034b:
          if (assop != 0) goto L_034f;
          amap(*lh);
          if (lh->length != 0) goto L_0350;
          amaps(*rh);
          goto L_0351;
L_0350:
          amap(*rh);
L_0351:
L_034f:
          if (lh->type != 6) goto L_0352;
          n = minrecordsize(*lh, *rh);
          if (rh->form == 0) goto L_0353;
          lrd(*rh, 2);
          op = 27;
          goto L_0354;
L_0353:
          drop(*rh);
          op = 28;
L_0354:
          lrd(*lh, 3);
          cload((n >> 2), 4);
          perm(op);
          return;
L_0352:
          if (lh->type != 5) goto L_0355;
          if ((lh->flag & 2) != 0) goto L_0355;
          if (assop <= 0) goto L_0356;
          if (rh->format != 1) goto L_0356;
          drop(*rh);
          lh->type = 3;
          sstack(*lh);
          drop(*lh);
          cstack(0);
          assign(assop);
          return;
L_0356:
          p = lh->length;
          if (assop == 2) goto L_0357;
          if (!(same(*lh, *rh))) goto L_0357;
          if (rh->oper != 0) goto L_0358;
          drop(*lh);
          drop(*rh);
          goto L_0359;
L_0358:
          rh->length = p;
          release(lh->sptfm);
          drop(*lh);
          rh->type = 0;
          lrd(*rh, 0);
L_0359:
          goto L_035a;
L_0357:
          if ((control & 32) == 0) goto L_035b;
          if (assop == 2) goto L_035b;
          if (rh->oper == 0) goto L_035b;
          if (same(*lh, *rh)) goto L_035b;
          if (same(*lh, rh->link)) goto L_035b;
          x = &rh->link;
          rh->oper = 0;
          load(*lh, 3);
          lrd(*rh, 2);
          perm(stringmove[3]);
          lh->form = 4;
          lh->type = 0;
          lh->oper = 7;
          lh->link = x;
          lrd(*lh, 0);
          goto L_035a;
L_035b:
          rh->flag = (rh->flag & (\1));
          if (assop == 2) goto L_035c;
          if ((control & 32) != 0) goto L_035d;
          if (p < rh->length) goto L_035e;
          if ((control & 2) == 0) goto L_035d;
          if (checkable(*rh)) goto L_035e;
L_035d:
          assop = 3;
L_035e:
L_035c:
          if (rh->oper != 0) goto L_035f;
          lrd(*lh, 3);
          lrd(*rh, 2);
          goto L_0360;
L_035f:
          lrd(*rh, 2);
          lrd(*lh, 3);
L_0360:
          perm(stringmove[assop]);
          if (assop == 3) goto L_0361;
          cput(p);
L_0361:
L_035a:
          return;
L_0355:
          if ((lh->flag & 2) == 0) goto L_0362;
          p = 7;
          if (lhdisp >= 4) goto L_0363;
          p = 6;
L_0363:
          if (lh->type != 5) goto L_0364;
          p = 2;
L_0364:
          if (rh->oper == 0) goto L_0365;
          load(*rh, p);
L_0365:
          drop(*lh);
          lh = &stacked[stp].v;
          rh->oper = p;
          rh->link = &lh->link;
          lh->link = rh;
          address(*lh, (-1));
          goto L_0366;
L_0362:
          address(*lh, (-1));
          if ((control & 23) != 0) goto L_0367;
          if (rh->type > 2) goto L_0367;
          if (rh->oper == 0) goto L_0368;
          if (rh->oper != 3) goto L_0367;
L_0368:
          if (!(same(*lh, *rh))) goto L_0367;
          if (rh->oper != 0) goto L_0369;
          release(rh->sptfm);
          drop(*rh);
          release(lh->sptfm);
          drop(*lh);
          return;
L_0369:
          x = rh;
          rh = &rh->link;
          release(x->sptfm);
          drop(*x);
          load(*rh, 25);
          address(*lh, (-1));
          rxd(38, rh->sptfm, *lh);
          forgetvar(*lh);
          release(rh->sptfm);
          drop(*rh);
          drop(*lh);
          return;
L_0367:
          t = rh->type;
          if (rh->sptfm != 0) goto L_036a;
          if (rh->form != 0) goto L_036a;
          if (rh->oper != 0) goto L_036a;
          if ((-32768) > rh->disp) goto L_036b;
          if (rh->disp > 32767) goto L_036b;
          if ((rh->disp & (\255)) != 0) goto L_036c;
          t = 3;
          goto L_036d;
L_036c:
          t = 2;
L_036d:
L_036b:
L_036a:
          n = assop;
          if (lh->type > 3) goto L_036e;
          if (lh->type > t) goto L_036f;
L_036e:
          assop = 2;
L_036f:
          if (lh->form != 1) goto L_0370;
          load(*rh, lh->sptfm);
          assop = 2;
          goto L_0371;
L_0370:
          p = cheapreg;
          if (lh->type < 7) goto L_0372;
          if (floating(*rh)) goto L_0372;
          float(*rh, p);
L_0372:
          address(*rh, p);
          if (rh->form == 1) goto L_0373;
          load(*rh, p);
L_0373:
          p = rh->sptfm;
          if (lh->form == 4) goto L_0374;
          address(*lh, (-1));
L_0374:
          rxd(2, p, *lh);
          if ((control & 128) != 0) goto L_0375;
          t = activity[lh->sptfm];
          if (t < 0) goto L_0376;
          if ((control & 32) == 0) goto L_0377;
L_0376:
          forgetvar(*lh);
          if (markassigned == 0) goto L_0378;
          if (lh->sptfm != local) goto L_0378;
          var[lh->varno].flag = (var[lh->varno].flag | 8);
L_0378:
          goto L_0379;
L_0377:
          forgetall();
L_0379:
          lh->flag = (lh->flag | (rh->flag & 8));
          if (n == 2) goto L_037a;
          associate(*lh, p);
L_037a:
L_0375:
          release(p);
L_0371:
          drop(*lh);
          drop(*rh);
L_0366:
          if (assop != 1) goto L_037b;
          if ((control & 1) == 0) goto L_037b;
          if (lh->type != 2) goto L_037c;
          claim(p);
          rr(30, p, p);
          perm(22);
          goto L_037d;
L_037c:
          rxi(36, p, 0, (\255));
          perm(23);
L_037d:
L_037b:
L_033b:
          goto L_037e;
          void loadparams(struct STACKFM *v)
{
          int reg;
          struct STACKFM *next;
          if (v != null) goto L_037f;
          return;
L_037f:
          reg = v->oper;
          v->oper = 0;
          next = &v->link;
          load(*v, reg);
          loadparams(*next);
          release(reg);
          drop(*v);
L_037e:
          goto L_0380;
          void arrayref(int mode)
{
          int flags;
          int p;
          int type;
          int base;
          int assbit;
          int mult;
          int shift;
          struct STACKFM *temp;
          goto L_0380;
          int specialcase()
{
          shift = power(mult);
          if (shift >= 0) goto L_0381;
          if ((flags & 32) != 0) goto L_0381;
          if (base != 0) goto L_0382;
L_0381:
L_0382:
L_0380:
          goto L_0383;
          void uncheckedref()
{
          int header;
          int length;
          int format;
          int extra;
          header = lhs->header;
          length = lhs->length;
          format = lhs->format;
          extra = 0;
          if (rhs->oper == 3) goto L_0384;
          if (rhs->oper != 0) goto L_0385;
          if (rhs->form == 5) goto L_0384;
          if (rhs->form != 0) goto L_0385;
L_0384:
          if (rhs->oper != 3) goto L_0386;
          if (rhs->link.form == 0) goto L_0387;
          if (rhs->link.form != 5) goto L_0388;
L_0387:
          extra = rhs->link.disp;
          if (rhs->link.form != 5) goto L_0389;
          rhs->link.form = 1;
          rhs->link.disp = 0;
          goto L_038a;
L_0389:
          rhs->oper = 0;
          drop(rhs->link);
L_038a:
L_0388:
          goto L_038b;
L_0386:
          extra = rhs->disp;
          rhs->disp = 0;
          if (rhs->form != 5) goto L_038c;
          rhs->form = 1;
L_038c:
L_038b:
          extra = (extra * mult);
L_0385:
          if (shift < 0) goto L_038d;
          cstack(shift);
          operate(11);
          goto L_038e;
L_038d:
          cstack(mult);
          operate(13);
L_038e:
          lhs->type = 1;
          if (lhs->header < 0) goto L_038f;
          amap(*lhs);
          sset(14, lhs->header, 4, 0);
          operate(3);
L_038f:
          operate(3);
          setlhs();
          if (extra == 0) goto L_0390;
          cstack(extra);
          operate(3);
          setlhs();
L_0390:
          vmap(*lhs);
          if ((flags & 128) == 0) goto L_0391;
          vmap(*lhs);
L_0391:
          lhs->type = type;
          lhs->format = format;
          lhs->length = length;
          lhs->xform = (lhs->form | assbit);
L_0383:
          if (mode == 0) goto L_0392;
          setboth();
          stp = (stp - 1);
          if (rhs->oper == 0) goto L_0393;
          load(*rhs, 25);
L_0393:
          rhs->link = &lhs->link;
          lhs->link = rhs;
          lhs->oper = (lhs->oper + 1);
          return;
L_0392:
          setboth();
          if ((lhs->oper + 1) == lhs->v) goto L_0394;
          abort(1095910961);
L_0394:
          flags = lhs->flag;
          lhs->flag = (lhs->flag & (\(128 + 96)));
          base = lhs->sptfm;
          type = lhs->type;
          assbit = (lhs->xform & (8 << 8));
          if ((control & 4) != 0) goto L_0395;
          if (lhs->oper == 0) goto L_0396;
L_0395:
          if (base != 0) goto L_0397;
L_0396:
          mult = lhs->length;
          if (lhs->type != 5) goto L_0398;
          mult = (mult + 1);
L_0398:
          if ((flags & 128) == 0) goto L_0399;
          mult = 4;
L_0399:
          if (!(specialcase())) goto L_039a;
          uncheckedref();
          return;
L_039a:
L_0397:
          stp = (stp - 1);
          if (lhs->oper != 0) goto L_039b;
          load(*rhs, 2);
          drop(*rhs);
          p = 13;
          goto L_039c;
L_039b:
          if (lhs->oper != 1) goto L_039d;
          load(lhs->link, 2);
          drop(lhs->link);
          load(*rhs, 3);
          drop(*rhs);
          p = 14;
          if ((control & 4) != 0) goto L_039e;
          p = 16;
L_039e:
          goto L_039c;
L_039d:
          if (rhs->oper == 0) goto L_039f;
          load(*rhs, 25);
L_039f:
          rhs->link = &lhs->link;
          for (p = pdisp; p += 4; p != (pdisp + ((lhs->oper - 1) * 4))) {
          temp = &rhs->link;
          lrd(*rhs, 25);
          rx(2, rhs->sptfm, 8, p);
          rhs = temp;
          }
L_03a3:
          load(*rhs, 2);
          rhs->form = 5;
          rhs->sptfm = 8;
          rhs->disp = pdisp;
          load(*rhs, 3);
          drop(*rhs);
          p = 15;
L_039c:
          lhs->oper = 0;
          amap(*lhs);
          if (lhs->header < 0) goto L_03a4;
          sset(14, lhs->header, 5, 0);
          load(*rhs, 4);
          drop(*rhs);
          stp = (stp - 1);
          goto L_03a5;
L_03a4:
          load(*lhs, 4);
L_03a5:
          release(2);
          release(4);
          if (p == 13) goto L_03a6;
          release(3);
L_03a6:
          perm(p);
          claim(2);
          if (lhs->header < 0) goto L_03a7;
          sset(lhs->sptfm, lhs->disp, lhs->form, lhs->extra);
          lhs->sptfm = 2;
          lhs->disp = 0;
          lhs->form = 1;
          lhs->type = 1;
          operate(3);
          goto L_03a8;
L_03a7:
          lhs->sptfm = 2;
          lhs->disp = 0;
L_03a8:
          vmap(*lhs);
          lhs->type = type;
          lhs->xform = (assbit | 4);
          if ((flags & 128) == 0) goto L_03a9;
          lhs->form = 6;
L_03a9:
          for (;;) {
L_03aa:
          goto L_03aa;
          void testzero(struct STACKFM *v)
{
          struct STACKFM *w;
          int cr;
          cr = 25;
          if (!(floating(*v))) goto L_03ab;
          cr = 26;
L_03ab:
          if (v->oper != 8) goto L_03ac;
          if (sym != 63) goto L_03ac;
          if (!(const(v->link))) goto L_03ac;
          w = &v->link;
          v->oper = 0;
          load(*v, cr);
          rxd(36, v->sptfm, *w);
          drop(*w);
          release(v->sptfm);
          goto L_03ad;
L_03ac:
          load(*v, cr);
          if (ca != ccca) goto L_03ae;
          if (ccreg == v->sptfm) goto L_03af;
L_03ae:
          rr(1, v->sptfm, v->sptfm);
          goto L_03b0;
L_03af:
          release(v->sptfm);
L_03b0:
L_03ad:
L_03aa:
          goto L_03b1;
          void comparerecords(struct STACKFM *l, struct STACKFM *r, int n)
{
          amap(*l);
          load(*l, 2);
          amap(*r);
          load(*r, 3);
          cload(n, 4);
          setboth();
          release(2);
          release(3);
          perm(34);
L_03b1:
          goto L_03b2;
          void comparereals(struct STACKFM *l, struct STACKFM *r)
{
          load(*l, 26);
          address(*r, 0);
          if (floating(*r)) goto L_03b3;
          float(*r, 26);
L_03b3:
          rxd(7, l->sptfm, *r);
          release(l->sptfm);
L_03b2:
          goto L_03b4;
          void comparestrings(struct STACKFM *l, struct STACKFM *r)
{
          struct STACKFM *temp;
          if (l->sptfm != 15) goto L_03b5;
          if (l->disp != nullstring) goto L_03b5;
          temp = r;
          r = l;
          l = temp;
          invert = (invert ^ 16);
L_03b5:
          if (r->sptfm != 15) goto L_03b6;
          if (r->disp != nullstring) goto L_03b6;
          if (l->oper == 0) goto L_03b7;
          load(*l, 25);
L_03b7:
          l->type = 3;
          testzero(*l);
          goto L_03b8;
L_03b6:
          if (r->oper == 0) goto L_03b9;
          load(*r, 3);
L_03b9:
          load(*l, 2);
          load(*r, 3);
          release(2);
          release(3);
          perm(9);
L_03b8:
          l->type = 5;
          l->form = 4;
          pdisp = 0;
L_03b4:
          goto L_03ba;
          void compare(struct STACKFM *l, struct STACKFM *r, int next)
{
          swopped = 0;
          if (l->type == 0) goto L_03bb;
          if (l->type != 5) goto L_03bc;
L_03bb:
          comparestrings(*l, *r);
          return;
L_03bc:
          if (!(zero(*r))) goto L_03bd;
          testzero(*l);
          return;
L_03bd:
          if (!(zero(*l))) goto L_03be;
          testzero(*r);
          invert = (invert ^ 16);
          return;
L_03be:
          if (floating(*l)) goto L_03bf;
          if (!(floating(*r))) goto L_03c0;
L_03bf:
          comparereals(*l, *r);
          return;
L_03c0:
          if (l->type != 6) goto L_03c1;
          comparerecords(*l, *r, minrecordsize(*l, *r));
          return;
L_03c1:
          address(*l, 0);
          load(*l, 25);
          address(*r, 0);
          if (61 == next) goto L_03c2;
          if (next == 35) goto L_03c2;
          rxd(7, l->sptfm, *r);
          goto L_03c3;
L_03c2:
          rxd(28, l->sptfm, *r);
L_03c3:
          release(l->sptfm);
L_03ba:
          goto L_03c4;
          void resolve(int flag)
{
          struct STACKFM *s;
          struct STACKFM *a;
          struct STACKFM *b;
          struct STACKFM *c;
          int p;
          int q;
          if ((flag & 1) != 0) goto L_03c5;
          cstack(0);
L_03c5:
          poplhs();
          c = lhs;
          poplhs();
          b = lhs;
          if ((flag & 2) != 0) goto L_03c6;
          cstack(0);
L_03c6:
          poplhs();
          a = lhs;
          poplhs();
          s = lhs;
          load(*s, 4);
          load(*a, 3);
          load(*b, 2);
          load(*c, 5);
          p = a->length;
          q = c->length;
          release(4);
          drop(*s);
          release(3);
          drop(*a);
          release(2);
          drop(*b);
          release(5);
          drop(*c);
          perm(7);
          cput(((p << 8) + (q & 255)));
          if ((flag & 4) != 0) goto L_03c7;
          perm(8);
L_03c7:
L_03c4:
          goto L_03c8;
          void header(struct VARFM *v)
{
          if (frame >= 44) goto L_03c9;
          frame = 44;
L_03c9:
          definetag((v->disp & 4095));
          rx(25, ((6 + 2) - minparm), 8, ((2 - minparm) * 4));
          if (potype < 3) goto L_03ca;
          externallink(7, 0, 0);
          rx(2, 16, 8, ((16 - 6) * 4));
          if ((control & 12) == 0) goto L_03cb;
          if (unassignedrtn != 0) goto L_03cb;
          unassignedrtn = 1;
          selectoutput(1);
          printsymbol(3);
          put(1);
          put(0);
          selectoutput(2);
L_03cb:
L_03ca:
          rr(1, local, 8);
          if (v->header == 0) goto L_03cc;
          if (v != &begin) goto L_03cd;
          abort(1212437041);
L_03cd:
          sset(local, v->header, 4, 0);
          rhs->type = 5;
          sset(2, 0, 1, 0);
          claim(2);
          assign(3);
          if ((control & 32) == 0) goto L_03ce;
          v->header = 0;
          goto L_03cf;
L_03ce:
          cput(2066);
L_03cf:
L_03cc:
          frame = ((frame + 3) & (\3));
          if ((control & 32) != 0) goto L_03d0;
          perm(26);
          cput(frame);
          cput(0);
          goto L_03d1;
L_03d0:
          rxi(3, 8, 0, 44);
L_03d1:
          setframepatch();
          if (level == 5) goto L_03d2;
          if ((control & 2) == 0) goto L_03d2;
          rx(1, 13, 15, 12);
          activity[13] = (-1);
L_03d2:
          if (v->header == 0) goto L_03d3;
          cput(2081);
          perm(4);
          cput(ap->length);
          v->header = 0;
L_03d3:
          if ((control & 64) == 0) goto L_03d4;
          if (v != &begin) goto L_03d5;
          if (potype < 3) goto L_03d5;
          strncpy(externalid,traceroutine,19+1);
          externallink(6, 0, ga);
          perm(50);
          cput(0);
L_03d5:
          traceflag = (control & 64);
L_03d4:
          memset(event,0,sizeof struct EVFM);
L_03c8:
          goto L_03d6;
          void return()
{
          if (uncondjump != ca) goto L_03d7;
          return;
L_03d7:
          if (returnlabel == 0) goto L_03d8;
          jumpto(returnlabel, 12, 0);
          goto L_03d9;
L_03d8:
          returnlabel = 28673;
          definelabel(returnlabel);
          rx(24, 8, local, ((8 - 6) * 4));
          rr(21, 1, 16);
L_03d9:
          uncondjump = ca;
          closed = 0;
L_03d6:
          goto L_03da;
          void compiletostring(struct STACKFM *v)
{
          if (next != 46) goto L_03db;
          if ((control & (1 | 2)) != 0) goto L_03db;
          v->flag = (v->flag | 1);
          return;
L_03db:
          if (!(const(*v))) goto L_03dc;
          currentstring[0] = 1;
          currentstring[1] = (v->disp & 255);
          claimliteral(2, 0);
          otype = 2;
          dumpstring(0);
          v->sptfm = 15;
          v->disp = litmax;
          goto L_03dd;
L_03dc:
          load(*v, 25);
          frame = ((frame + 1) & (\1));
          rr(31, 1, v->sptfm);
          rxi(3, 1, 0, (1 << 8));
          rx(32, 1, local, frame);
          v->sptfm = local;
          v->disp = frame;
          frame = (frame + 2);
L_03dd:
          v->type = 5;
          v->xform = (4 | (8 << 8));
          v->length = 1;
L_03da:
          goto L_03de;
          void call(struct STACKFM *v)
{
          // bounds [1 : 23]
          /*todo: gcc jump table extension*/ void **b;
          // bounds [9 : 17]
          // do it now: const char  {*,2}newtype {NO INIT}
          // bounds [1 : 7]
          // do it now: const char  {*,2}newsize {NO INIT}
          int t;
          int l;
          int p;
          if ((v->flag & 4) == 0) goto L_03df;
          l = 0;
          t = v->header;
          sym = 0;
          if (t != 2) goto L_03e0;
          v->flag = (v->flag & (\4));
          v->header = 0;
          goto L_03e1;
L_03e0:
          drop(*v);
L_03e1:
          setlhs();
          goto *b[t];
b_1:
          operate(14);
          return;
b_2:
          call(*v);
          sset(2, 0, 1, 0);
          if (lhs->type == 6) goto L_03e2;
          if (lhs->type != 4) goto L_03e3;
L_03e2:
          warn(4);
          cload(5, 1);
          cload(5, 2);
          perm(20);
          setlhs();
          lhs->type = 3;
L_03e3:
          claim(rhs->sptfm);
          if (lhs->type != 5) goto L_03e4;
          compiletostring(*rhs);
L_03e4:
          assign(1);
          return;
b_3:
          float(*lhs, 26);
          return;
b_4:
          compiletostring(*lhs);
          return;
b_8:
          t = lhs->type;
          amap(*lhs);
          if (t != 5) goto L_03e5;
          if (lhs->form == 5) goto L_03e5;
          if (lhs->form == 8) goto L_03e5;
          load(*lhs, 25);
          lhs->form = 4;
          forgetreg((1 << lhs->sptfm));
          rxd(23, lhs->sptfm, *lhs);
          claim(lhs->sptfm);
          lhs->form = 1;
L_03e5:
          return;
b_16:
          cstack(0);
b_17:
          setboth();
          amap(*lhs);
          if ((control & 4) == 0) goto L_03e6;
          if (!(const(*rhs))) goto L_03e7;
          if ((t - 16) > rhs->disp) goto L_03e7;
          if (rhs->disp > lhs->length) goto L_03e7;
L_03e6:
          operate(3);
          setlhs();
          goto L_03e8;
L_03e7:
          load(*lhs, 2);
          load(*rhs, 3);
          drop(*rhs);
          stp = (stp - 1);
          release(2);
          release(3);
          perm(31);
          cput((lhs->length & 255));
          claim(2);
          setlhs();
          lhs->sptfm = 2;
          lhs->disp = 0;
          lhs->xform = 1;
L_03e8:
          goto U_015c;
b_12:
b_9:
b_10:
b_11:
b_13:
b_14:
b_15:
U_015c:
          vmap(*lhs);
          lhs->type = newtype[t];
          lhs->length = newsize[lhs->type];
          return;
b_19:
          load(*lhs, 26);
          p = gpr();
          hazard(p);
          rr(27, p, lhs->sptfm);
          claim(p);
          lhs->sptfm = p;
          lhs->type = 1;
          lhs->xform = 1;
          return;
b_18:
          p = 33;
          t = 1;
          l = 2;
          goto U_015d;
b_23:
          p = 10;
          t = 7;
          l = 18;
U_015d:
          load(*lhs, 18);
          release(18);
          perm(p);
          claim(l);
          setlhs();
          lhs->sptfm = l;
          lhs->xform = 1;
          lhs->type = t;
          return;
b_5:
          load(*lhs, 4);
          drop(*lhs);
          stp = (stp - 1);
          setboth();
          stp = (stp - 2);
          load(*lhs, 2);
          load(*rhs, 3);
          drop(*lhs);
          drop(*rhs);
          release(2);
          release(3);
          release(4);
          perm(12);
          claim(2);
          sset(2, 0, 4, 0);
          rhs->type = 5;
          return;
b_21:
b_22:
          if (lhs->type == 4) goto L_03e9;
          if (t != 21) goto L_03ea;
          p = genmap[lhs->type];
          goto L_03eb;
L_03ea:
          p = lhs->length;
          if (lhs->type != 5) goto L_03ec;
          p = (p + 1);
L_03ec:
L_03eb:
          release(lhs->sptfm);
          lhs->type = 1;
          lhs->form = 0;
          lhs->sptfm = 0;
          lhs->disp = p;
          goto L_03ed;
L_03e9:
          lhs->disp = (lhs->disp + 4);
          lhs->xform = ((8 << 8) | 4);
          lhs->type = 1;
          if (t != 21) goto L_03ee;
          cstack(15);
          operate(8);
          goto L_03ef;
L_03ee:
          cstack(4);
          operate(12);
L_03ef:
L_03ed:
          return;
b_6:
          perm(32);
          claim(2);
          sset(2, 0, 1, 0);
          return;
b_7:
          for (p = 17; p += 1; p != 24) {
          hazard(p);
          }
L_03f3:
          setboth();
          stp = (stp - 2);
          if (const(*lhs)) goto L_03f4;
          load(*lhs, 25);
L_03f4:
          address(*rhs, (-1));
          rx(21, 17, rhs->sptfm, rhs->disp);
          claim(rhs->sptfm);
          rx(33, 1, lhs->sptfm, lhs->disp);
          rx(22, 17, rhs->sptfm, rhs->disp);
          drop(*lhs);
          drop(*rhs);
          forgetreg((-1));
          return;
b_20:
          load(*lhs, 5);
          release(5);
          drop(*lhs);
          stp = (stp - 1);
          perm(49);
          return;
L_03df:
          wdisp = ((wdisp + 3) & (\3));
          if ((v->flag & 8) != 0) goto L_03f5;
          hazardall();
L_03f5:
          if (v->sptfm == 0) goto L_03f6;
          if (v->sptfm == 14) goto L_03f7;
          t = newtag();
          definereference(t, 2);
          rx(23, 16, 15, 0);
L_03f7:
          rx(25, 6, 8, wdisp);
          if (wdisp == 0) goto L_03f8;
          rxi(3, 8, 0, wdisp);
L_03f8:
          if (v->sptfm != 14) goto L_03f9;
          rx(24, 14, 14, v->disp);
          rr(22, 16, 16);
          goto L_03fa;
L_03f9:
          quickload(3, 4, v->sptfm, v->disp);
          forgetreg((1 << 3));
          rx(24, 9, 3, 0);
          rx(22, 16, 16, 4);
          definetag(t);
L_03fa:
          goto L_03fb;
L_03f6:
          if (wdisp == 0) goto L_03fc;
          rxi(3, 8, 0, wdisp);
L_03fc:
          definereference((v->disp & 4095), 2);
          rx(22, 16, 15, 0);
          if (wdisp == 0) goto L_03fd;
          rxi(4, 8, 0, wdisp);
L_03fd:
          if ((v->flag & 8) == 0) goto L_03fe;
          uncondjump = ca;
L_03fe:
L_03fb:
          wdisp = v->header;
          pdisp = v->rt;
          if (v->type != 0) goto L_03ff;
          drop(*v);
L_03ff:
L_03de:
          goto L_0400;
          void compilerop(int n)
{
          struct STACKFM *p;
          p = &*descriptor();
          stp = (stp - 1);
          p->flag = 4;
          p->header = n;
          if (0 >= n) goto L_0401;
          if (n <= 23) goto L_0402;
L_0401:
          abort(1129140048);
L_0402:
          call(*p);
L_0400:
          goto L_0403;
          void compilefor()
{
          struct STACKFM *cv;
          struct STACKFM *iv;
          struct STACKFM *inc;
          struct STACKFM *fv;
          int lab;
          int safe;
          int n;
          int reg;
          int shadow;
          goto L_0403;
          void stab(struct STACKFM *v, int type)
{
          int t;
          int r;
          if (!(const(*v))) goto L_0404;
          return;
L_0404:
          load(*v, 25);
          r = v->sptfm;
          t = temp();
          v->sptfm = local;
          v->disp = t;
          v->type = type;
          v->xform = ((8 << 8) | 4);
          rx(2, r, local, t);
          release(r);
          if ((control & 128) != 0) goto L_0405;
          associate(*v, r);
L_0405:
L_0403:
          goto L_0406;
          void set(struct STACKFM *v, int reg)
{
          struct STACKFM *r;
          sstack(*v);
          r = &stacked[stp].v;
          lrd(*r, reg);
          stp = (stp - 1);
L_0406:
          cv = &stacked[(stp - 3)].v;
          inc = &stacked[(stp - 2)].v;
          fv = &stacked[(stp - 1)].v;
          lab = tag();
          if (forstp != 30) goto L_0407;
          abort(1179603505);
L_0407:
          forstp = (forstp + 1);
          for = &forstk[forstp];
          n = nexttemp;
          shadow = (-1);
          if ((control & 4) == 0) goto L_0408;
          shadow = temp();
L_0408:
          stab(*fv, 1);
          stab(*inc, 1);
          for->tempbase = tempbase;
          if (n == nexttemp) goto L_0409;
          tempbase = newtemp;
L_0409:
          safe = 0;
          sstack(*inc);
          operate(4);
          iv = &stacked[stp].v;
          if (cv->form != 4) goto L_040a;
          if (activity[cv->sptfm] < 0) goto L_040b;
L_040a:
          n = cv->type;
          amap(*cv);
          stab(*cv, n);
          cv->form = 6;
L_040b:
          stp = (stp - 4);
          if (!(const(*fv))) goto L_040c;
          if (!(const(*iv))) goto L_040c;
          if (!(const(*inc))) goto L_040c;
          if (inc->disp == 0) goto L_040d;
          n = (fv->disp - iv->disp);
          if ((n ^ inc->disp) < 0) goto L_040e;
          if (((n / inc->disp) * inc->disp) != n) goto L_040e;
          safe = 1;
L_040e:
L_040d:
          if (safe != 0) goto L_040f;
          warn(2);
          goto L_0410;
L_040f:
          safe = (fv->disp - iv->disp);
L_0410:
L_040c:
          reg = iv->sptfm;
          if (reg > 3) goto L_0411;
          reg = gpr();
          goto L_0412;
L_0411:
          reg = 25;
L_0412:
          load(*iv, reg);
          reg = iv->sptfm;
          if (safe != 0) goto L_0413;
          if ((control & 4) == 0) goto L_0413;
          set(*iv, 1);
          claim(reg);
          set(*fv, 2);
          set(*inc, 3);
          perm(24);
L_0413:
          if (safe != 0) goto L_0414;
          sstack(*cv);
          sstack(*iv);
          assign(1);
          claim(reg);
          for->initial = (8000 + forstp);
          jumpto(for->initial, 12, 1);
L_0414:
          definelabel(lab);
          traceflag = (control & 64);
          sstack(*cv);
          sstack(*iv);
          sstack(*inc);
          operate(3);
          drop(*iv);
          drop(*inc);
          setlhs();
          load(*lhs, reg);
          assign(1);
          if (shadow < 0) goto L_0415;
          rx(2, reg, local, shadow);
L_0415:
          for->lab = lab;
          for->reg = reg;
          for->shadow = shadow;
          for->cvbase = cv->sptfm;
          for->cvdisp = cv->disp;
          for->cvtype = cv->type;
          for->cvform = cv->xform;
          for->fvbase = fv->sptfm;
          for->fvdisp = fv->disp;
          drop(*cv);
          drop(*fv);
          for (;;) {
L_0416:
          for (;;) {
L_0417:
          sym = next;
          readsymbol(next);
          goto *c[sym];
c_108:
          languagemask = tag();
          goto L_0418;
c_79:
          if (stp == 0) goto L_0419;
          abort(1398033215);
L_0419:
          if (&using.link == null) goto L_041a;
          abort(1431522887);
L_041a:
          if (claimed == 0) goto L_041b;
          abort(1129073988);
L_041b:
          if (ca >= 0) goto L_041c;
          abort(1279874111);
L_041c:
          wdisp = 0;
          pdisp = 0;
          nexttemp = tempbase;
          currentline = tag();
          if ((control & 64) == 0) goto L_041d;
          if (next == 58) goto L_041e;
          if (next != 76) goto L_041f;
L_041e:
          traceflag = 1;
          goto L_0420;
L_041f:
          if (traceflag == 0) goto L_0421;
          dumptrace();
L_0421:
L_0420:
L_041d:
          goto L_0418;
c_36:
          definevar();
          goto L_0418;
c_98:
          popdrop();
          vub = lhs->disp;
          popdrop();
          vlb = lhs->disp;
          goto L_0418;
          goto L_0416;
          void adump()
{
          // bounds [1 : 8]
          /*todo: gcc jump table extension*/ void **c;
          // bounds [1 : 8]
          /*todo: gcc jump table extension*/ void **g;
          // bounds [1 : 8]
          // do it now: const int  {*,2}low {NO INIT}
          // bounds [1 : 8]
          // do it now: const int  {*,2}high {NO INIT}
          int j;
          if (high[owntype] == 0) goto L_0422;
          if ((control & 1) == 0) goto L_0422;
          if (low[owntype] > ownval) goto L_0423;
          if (ownval <= high[owntype]) goto L_0424;
L_0423:
          warn(8);
L_0424:
L_0422:
          if (otype == 2) goto L_0425;
          goto *g[owntype];
L_0425:
          if (5 == owntype) goto L_0426;
          if (owntype >= 7) goto L_0426;
          selectliteralarea();
L_0426:
          goto *c[owntype];
g_1:
          gword(ownval);
          return;
c_1:
          cword(ownval);
          goto U_015d;
c_7:
c_8:
g_7:
g_8:
          j = realconstant(1);
          return;
g_3:
          gbyte(ownval);
          return;
c_3:
          litbyte(ownval);
          goto U_015d;
g_2:
          gput(ownval);
          return;
c_2:
          cput(ownval);
          goto U_015d;
c_5:
g_5:
          dumpstring(datasize);
          return;
g_6:
          for (j = 1; j += 1; j != (datasize >> 1)) {
          gput(0);
          }
L_042a:
          return;
c_6:
          abort(1094995280);
U_015d:
          selectcodearea();
L_0416:
c_65:
          aparm = tag();
          if (stp == 0) goto L_042b;
          decvar->flag = (decvar->flag | 8);
          popdrop();
          if (owntype < 7) goto L_042c;
          if (lhs->type >= 7) goto L_042d;
          rvalue = lhs->disp;
L_042d:
          ownval = *integer(addr(rvalue));
          mantissa = *integer((addr(rvalue) + 4));
          goto L_042e;
L_042c:
          ownval = lhs->disp;
L_042e:
          goto L_042f;
L_042b:
          if (owntype != 3) goto L_0430;
          ownval = 128;
          goto L_0431;
L_0430:
          if (owntype != 2) goto L_0432;
          ownval = -32640;
          goto L_0431;
L_0432:
          if (owntype == 5) goto L_0433;
          ownval = -2139062144;
          mantissa = -2139062144;
          goto L_0431;
L_0433:
          *cslen = 128;
          currentstring[1] = 128;
L_0431:
L_042f:
          if (ownform == 11) goto L_0434;
          if (ownform != 13) goto L_0435;
L_0434:
          for (j = 1; j += 1; j != aparm) {
          adump();
          }
L_0439:
          goto L_043a;
L_0435:
          if (otype != 0) goto L_043b;
          decvar->flag = (decvar->flag & (\8));
          decvar->disp = ownval;
          decvar->base = 0;
          if (decvar->form != 4) goto L_043c;
          decvar->form = 0;
          goto L_043d;
L_043c:
          if (decvar->form != 6) goto L_043e;
          setdiag(0, ownval);
L_043e:
          decvar->form = (decvar->form + (4 - 6));
L_043d:
          goto L_043f;
L_043b:
          decvar->base = 14;
          decvar->disp = ga;
          if (otype < 3) goto L_0440;
          decvar->flag = (decvar->flag & (\8));
          externallink(5, datasize, ga);
          goto L_0441;
L_0440:
          if (otype != 2) goto L_0442;
          if (decvar->type != 5) goto L_0443;
          claimliteral((*cslen + 1), 1);
          j = litmax;
          dumpstring(0);
          goto L_0444;
L_0443:
          if (decvar->type < 7) goto L_0445;
          j = realconstant(0);
          goto L_0444;
L_0445:
          abort(1095577649);
L_0444:
          decvar->base = 15;
          decvar->disp = j;
          goto L_0418;
L_0442:
L_0441:
          adump();
L_043f:
L_043a:
          goto L_0418;
c_39:
          getstring();
          goto L_0418;
c_71:
          getstring();
          strncpy(alias,"",19+1);
          for (j = 1; j += 1; j != *cslen) {
          strncpy(alias,alias,19+1);
          }
L_0449:
          popdrop();
          goto L_0418;
c_78:
          cstack(((tag() << 16) | tag()));
          goto L_0418;
c_68:
          getd();
          if (rvalue != 0) goto L_044a;
          cstack(0);
          goto L_0418;
L_044a:
          if (next != 65) goto L_044b;
          goto L_0418;
L_044b:
          otype = 2;
          j = realconstant(0);
          sset(15, j, 4, 0);
          rhs->type = 7;
          goto L_0418;
c_110:
          j = tag();
          setlhs();
          vstack((var[lhs->format].extra - j));
          setboth();
          stp = (stp - 1);
          if (rhs->form == 15) goto L_044c;
          if (lhs->form == 4) goto L_044d;
          if (lhs->form != 7) goto L_044e;
L_044d:
          rhs->disp = (lhs->disp + rhs->disp);
          lhs->xform = ((lhs->form - 4) + rhs->xform);
          goto L_044f;
L_044e:
          if (lhs->form != 9) goto L_0450;
          lhs->form = 7;
          lhs->type = 1;
          load(*lhs, 25);
          lhs->xform = rhs->xform;
          goto L_0451;
L_0450:
          if (lhs->form > 1) goto L_0452;
          lhs->xform = rhs->xform;
          goto L_0453;
L_0452:
          lhs->extra = lhs->disp;
          lhs->xform = (rhs->xform + 3);
L_0453:
L_0451:
L_044f:
          lhs->disp = rhs->disp;
          lhs->type = rhs->type;
          lhs->rt = rhs->rt;
          lhs->header = rhs->header;
L_044c:
          lhs->length = rhs->length;
          lhs->format = rhs->format;
          lhs->v = rhs->v;
          drop(*rhs);
          goto L_0418;
c_64:
          vstack(tag());
          if ((lhs->flag & 16) == 0) goto L_0454;
          if (next == 112) goto L_0454;
          if ((lhs->flag & 4) != 0) goto L_0454;
          lhs->rt = pdisp;
          lhs->header = wdisp;
          wdisp = ((pdisp + 3) & (\3));
          pdisp = 0;
L_0454:
          goto L_0418;
c_69:
          poplhs();
          x = lhs;
          loadparams(x->link);
          call(*x);
          if (x->type == 0) goto L_0455;
          if (sym == 0) goto L_0455;
          sstack(*x);
          drop(*x);
          setlhs();
          if (lhs->type < 7) goto L_0456;
          opr = 17;
          goto L_0457;
L_0456:
          opr = 2;
L_0457:
          lhs->sptfm = opr;
          lhs->disp = 0;
          claim(opr);
          if (lhs->form != 1) goto L_0458;
          if (lhs->type == 5) goto L_0459;
          if (lhs->type != 6) goto L_0458;
L_0459:
          lhs->sptfm = 2;
          lhs->form = 4;
          if (next == 83) goto L_045a;
          if (next == 112) goto L_045a;
          if (next == 63) goto L_045a;
          if (lhs->type != 5) goto L_045b;
          n = 256;
          lhs->length = 255;
          goto L_045c;
L_045b:
          n = var[lhs->format].length;
L_045c:
          if (pdisp != 0) goto L_045d;
          pdisp = 44;
L_045d:
          lhs->sptfm = 8;
          lhs->disp = pdisp;
          sstack(*lhs);
          sset(2, 0, 4, 0);
          if (lhs->type != 5) goto L_045e;
          rhs->type = 5;
          goto L_045f;
L_045e:
          rhs->type = 6;
          rhs->format = lhs->format;
L_045f:
          assign(1);
          pdisp = (pdisp + n);
          if (lhs->type != 5) goto L_0460;
          lhs->type = 0;
L_0460:
L_045a:
L_0458:
L_0455:
          goto L_0418;
c_77:
c_86:
          setlhs();
          opr = 2;
          if (sym != 86) goto L_0461;
          if (gvar->type < 7) goto L_0462;
          opr = 17;
          goto L_0463;
L_0462:
          if (gvar->type != 6) goto L_0464;
          if (!(zero(*lhs))) goto L_0464;
          lhs->type = 6;
          lhs->form = 4;
          lhs->sptfm = 8;
          lhs->disp = 0;
          lhs->format = gvar->format;
          sstack(*lhs);
          cstack(0);
          assign(1);
          setlhs();
L_0464:
L_0463:
          goto L_0465;
L_0461:
          amaps(*lhs);
L_0465:
          lrd(*lhs, opr);
          stp = (stp - 1);
          if (sym != 86) goto L_0466;
          if (gvar->type != 5) goto L_0467;
          if (gvar->length <= 0) goto L_0467;
          cload(gvar->length, 1);
          perm(11);
          goto L_0468;
L_0467:
          if ((control & 1) == 0) goto L_0469;
          if (gvar->type != 2) goto L_046a;
          claim(opr);
          rr(30, opr, opr);
          perm(22);
          goto L_046b;
L_046a:
          if (gvar->type != 3) goto L_046c;
          rxi(36, opr, 0, (\255));
          perm(23);
L_046c:
L_046b:
L_0469:
L_0468:
L_0466:
c_82:
          return();
          goto L_0418;
c_75:
          k = 0;
          goto U_0158;
c_84:
          k = (-1);
U_0158:
          cload(k, 2);
          return();
          goto L_0418;
c_97:
          arrayref(0);
          goto L_0418;
c_105:
          arrayref(1);
          goto L_0418;
c_46:
          operate(7);
          goto L_0418;
c_43:
          operate(3);
          goto L_0418;
c_92:
          k = (-1);
          goto U_0159;
c_85:
          k = 0;
U_0159:
          poplhs();
          cstack(k);
          sstack(*lhs);
          drop(*lhs);
c_45:
          operate(4);
          goto L_0418;
c_33:
          operate(9);
          goto L_0418;
c_37:
          operate(10);
          goto L_0418;
c_38:
          operate(8);
          goto L_0418;
c_91:
          operate(11);
          goto L_0418;
c_93:
          operate(12);
          goto L_0418;
c_42:
          operate(5);
          goto L_0418;
c_47:
          operate(6);
          goto L_0418;
c_81:
          operate(17);
          goto L_0418;
c_88:
          operate(15);
          goto L_0418;
c_120:
          operate(16);
          goto L_0418;
c_118:
          setlhs();
          if (!(floating(*lhs))) goto L_046d;
          load(*lhs, 26);
          opr = fpr();
          goto L_046e;
L_046d:
          load(*lhs, 25);
          opr = gpr();
L_046e:
          poplhs();
          k = lhs->sptfm;
          load(*lhs, opr);
          n = newtag();
          jumpto(n, 5, -1);
          cstack(0);
          sstack(*lhs);
          drop(*lhs);
          operate(4);
          setlhs();
          load(*lhs, k);
          definetag(n);
          goto L_0418;
c_106:
          assign(2);
          goto L_0418;
c_83:
          assign(1);
          goto L_0418;
c_90:
          assign(0);
          goto L_0418;
c_112:
          assign((-1));
          goto L_0418;
c_117:
c_113:
          if (sym != 117) goto L_046f;
          k = 3;
          goto L_0470;
L_046f:
          k = 4;
L_0470:
          setboth();
          t = lhs->type;
          j = lhs->length;
          if (t != 5) goto L_0471;
          j = (j + 1);
L_0471:
          amap(*lhs);
          if (j != 0) goto L_0472;
          abort(1095577653);
L_0472:
          if (j != 2) goto L_0473;
          cstack(1);
          j = 11;
          goto L_0474;
L_0473:
          if (j != 4) goto L_0475;
          cstack(2);
          j = 11;
          goto L_0474;
L_0475:
          cstack(j);
          j = 5;
L_0474:
          operate(j);
          operate(k);
          setlhs();
          vmap(*lhs);
          lhs->type = t;
          goto L_0418;
c_61:
c_107:
          opr = 0;
          goto U_015a;
c_35:
c_116:
          opr = 1;
          goto U_015a;
c_60:
          opr = 2;
          goto U_015a;
c_62:
          opr = 3;
          goto U_015a;
c_40:
          opr = 4;
          goto U_015a;
c_41:
          opr = 5;
          goto U_015a;
U_015a:
          val = tag();
          jumpto(val, (opr + invert), 1);
          invert = 0;
          goto L_0418;
c_67:
          setboth();
          t = lhs->type;
          amap(*lhs);
          amap(*rhs);
          if (t != 5) goto L_0476;
          if (lhs->form == 4) goto L_0477;
          if (lhs->form == 7) goto L_0477;
          if (rhs->form == 4) goto L_0477;
          if (rhs->form != 7) goto L_0476;
L_0477:
          operate(10);
          cstack(8);
          operate(11);
          cstack(0);
L_0476:
c_63:
          setboth();
          compare(*lhs, *rhs, next);
          stp = (stp - 2);
          drop(*lhs);
          drop(*rhs);
          goto L_0418;
c_34:
          setboth();
          invert = 16;
          compare(*rhs, *lhs, next);
          stp = (stp - 1);
          memcpy(*lhs,*rhs,sizeof struct STACKFM);
          drop(*rhs);
          claim(lhs->sptfm);
          goto L_0418;
c_114:
          resolve(tag());
          goto L_0418;
c_95:
          uncondjump = 0;
          markassigned = 0;
          forgetall();
          v = &var[tag()];
          popdrop();
          j = (lhs->disp - v->extra);
          if (0 > j) goto L_0478;
          if (j < v->length) goto L_0479;
L_0478:
          abort(1095577904);
L_0479:
          definetag(((v->format + j) | 32768));
          goto L_0418;
c_87:
          v = &var[tag()];
          if ((control & 32) != 0) goto L_047a;
          poplhs();
          lrd(*lhs, 2);
          rxi(1, 3, 15, v->disp);
          perm(19);
          goto L_047b;
L_047a:
          cstack(1);
          operate(11);
          poplhs();
          k = ((v->disp + (2 * 2)) - (v->extra * 2));
          if (!(const(*lhs))) goto L_047c;
          k = (k + lhs->disp);
          j = 0;
          goto L_047d;
L_047c:
          load(*lhs, 25);
          j = lhs->sptfm;
L_047d:
          lhs->sptfm = 15;
          lhs->rem = j;
          lhs->disp = k;
          lhs->type = 2;
          lhs->form = 4;
          rxd(37, 2, *lhs);
          claim(2);
          drop(*lhs);
          rr(3, 2, 2);
          claim(2);
          rr(3, 2, 15);
          rr(21, 1, 2);
L_047b:
          uncondjump = ca;
          goto L_0418;
c_66:
          val = tag();
          if (val == for->lab) goto L_047e;
          jumpto(val, 12, 0);
          goto L_047f;
L_047e:
          sset(for->cvbase, for->cvdisp, for->cvform, 0);
          hazard(for->reg);
          poplhs();
          lhs->type = for->cvtype;
          lhs->flag = (lhs->flag | 8);
          lrd(*lhs, for->reg);
          if (for->shadow < 0) goto L_0480;
          rx(28, for->reg, local, for->shadow);
          perm(25);
L_0480:
          if (for->initial == 0) goto L_0481;
          definelabel(for->initial);
          for->initial = 0;
L_0481:
          if (for->fvbase != 0) goto L_0482;
          if (for->fvdisp != 0) goto L_0483;
          claim(for->reg);
          rr(1, for->reg, for->reg);
          goto L_0484;
L_0483:
          rxi(28, for->reg, for->fvbase, for->fvdisp);
L_0484:
          goto L_0485;
L_0482:
          rx(28, for->reg, for->fvbase, for->fvdisp);
L_0485:
          jumpto(val, 1, 0);
          if (next == 58) goto L_0486;
          abort(1095577909);
L_0486:
          readsymbol(next);
          definelabel(tag());
          if (for->shadow < 0) goto L_0487;
          if (level == 5) goto L_0488;
          rx(2, 13, local, for->shadow);
          goto L_0489;
L_0488:
          rx(1, for->reg, 15, 12);
          rx(2, for->reg, local, for->shadow);
          forgetreg((1 << for->reg));
L_0489:
L_0487:
          tempbase = for->tempbase;
          forstp = (forstp - 1);
          if (forstp >= 0) goto L_048a;
          abort(1095578160);
L_048a:
          for = &forstk[forstp];
L_047f:
          goto L_0418;
c_70:
          val = tag();
          if (val < 8000) goto L_048b;
          abort(1095578165);
L_048b:
          jumpto(val, 12, 1);
          goto L_0418;
          goto L_048c;
          int  userlabel(int lab)
{
          struct VARFM *v;
          if (lab <= names) goto L_048d;
          names = lab;
          v = &var[lab];
          memset(*v,0,sizeof struct VARFM);
          v->form = 14;
          v->disp = newtag();
          return((-v->disp));
L_048d:
          return((-var[lab].disp));
L_048c:
c_74:
          jumpto(userlabel(tag()), 12, 0);
          goto L_0418;
c_76:
          definelabel(userlabel(tag()));
          goto L_0418;
c_58:
          j = tag();
          if (j < 8000) goto L_048e;
          abort(1095578416);
L_048e:
          definelabel(j);
          goto L_0418;
c_102:
          compilefor();
          goto L_0418;
c_119:
          markassigned = 0;
          machinecode();
          forgetreg((-1));
          goto L_0418;
c_80:
          popdrop();
          cput(lhs->disp);
          forgetreg((-1));
          goto L_0418;
c_121:
          j = tag();
          diagnose = 0;
          if (((j >> 14) & 3) != 2) goto L_048f;
          diagnose = (j & 16383);
          if ((diagnose & 4) == 0) goto L_0490;
          diagnose = (diagnose | ((-1) << 15));
L_0490:
          goto L_0491;
L_048f:
L_0491:
          goto L_0418;
c_122:
          control = tag();
          goto L_0418;
c_109:
          j = (-1);
          goto U_015c;
c_115:
          if ((control & 64) == 0) goto L_0492;
          perm(50);
          cput(0);
L_0492:
          j = 0;
          goto U_015c;
c_101:
          j = tag();
U_015c:
          for (;;) {
L_0493:
          if (stp >= 2) goto L_0494;
          cstack(0);
          }
L_0494:
          poplhs();
          lrd(*lhs, 3);
          poplhs();
          lrd(*lhs, 2);
          cload(j, 1);
          perm(20);
          uncondjump = ca;
          goto L_0418;
c_111:
          event.events = tag();
          readsymbol(next);
          k = tag();
          j = ((frame + 3) & (\3));
          frame = (j + 4);
          rx(2, 8, local, j);
          jumpto(k, 12, 1);
          event.low = jtag;
          forgetall();
          event.label = newtag();
          definetag(event.label);
          rx(1, 8, local, j);
          goto L_0418;
c_104:
          compilerop(tag());
          goto L_0418;
c_103:
c_100:
          allocate = (sym - 103);
          dim = tag();
          if (0 >= dim) goto L_0495;
          if (dim <= 7) goto L_0496;
L_0495:
          abort(1095578421);
L_0496:
          readsymbol(next);
          n = tag();
          if (gmode != 0) goto L_0497;
          names = (names - n);
          goto L_0498;
L_0497:
          parms = (parms + n);
L_0498:
          setboth();
          dv = 0;
          t = (-1);
          if ((control & 23) != 0) goto L_0499;
          if (dim != 1) goto L_0499;
          if (lhs->disp > (rhs->disp + 1)) goto L_0499;
          if (!(const(*rhs))) goto L_049a;
          if (!(const(*lhs))) goto L_049a;
          t = 0;
          if (0 >= datasize) goto L_049b;
          if (datasize > 32767) goto L_049b;
          if ((-32768) > lhs->disp) goto L_049b;
          if (lhs->disp > 32767) goto L_049b;
          if ((-32768) > rhs->disp) goto L_049b;
          if (rhs->disp > 32767) goto L_049b;
          dim = (dim | 32);
L_049b:
L_049a:
L_0499:
          if (gmode != 0) goto L_049c;
          if (t < 0) goto L_049d;
L_049c:
          vlb = lhs->disp;
          vub = rhs->disp;
          if (vlb <= (vub + 1)) goto L_049e;
          abort(1095578672);
L_049e:
          setdopevector();
          stp = (stp - 2);
          drop(*lhs);
          drop(*rhs);
          if (gmode != 0) goto L_049f;
          quickload(5, 5, 15, dv);
          release(5);
          vub = ((vub + 3) & (\3));
L_049f:
          goto L_04a0;
L_049d:
          frame = ((frame + 3) & (\3));
          k = frame;
          frame = (frame + 4);
          quickload(5, 5, local, k);
          release(5);
          stp = 0;
          for (j = 1; j += 1; j != (dim << 1)) {
          stp = (stp + 1);
          setlhs();
          claim(5);
          lrd(*lhs, 25);
          rx(2, lhs->sptfm, 5, (frame - k));
          frame = (frame + 4);
          if ((j & 1) != 0) goto L_04a5;
          frame = (frame + 4);
L_04a5:
          }
L_04a4:
          perm(17);
          cput(dim);
          cput(datasize);
          stp = 0;
L_04a0:
          if (dv != 0) goto L_04a6;
          quickload(3, 5, local, frame);
          release(3);
          forgetreg((1 << 3));
L_04a6:
          for (j = 1; j += 1; j != n) {
          if (gmode != 0) goto L_04ab;
          names = (names + 1);
          decvar = &var[names];
          goto L_04ac;
L_04ab:
          parms = (parms - 1);
          decvar = &var[parms];
L_04ac:
          decvar->disp = frame;
          decvar->flag = (decvar->flag | dim);
          if (gmode != 0) goto L_04ad;
          decvar->header = (-1);
          decvar->base = local;
          decvar->flag = (decvar->flag | 64);
          if (dv != 0) goto L_04ae;
          if (allocate == 0) goto L_04af;
          perm(18);
          goto L_04b0;
L_04af:
          rx(2, 5, local, (frame + 4));
          rx(2, 2, local, (frame + 0));
L_04b0:
          goto L_04b1;
L_04ae:
          rx(2, 5, local, (frame + 4));
          if (allocate == 0) goto L_04b2;
          rxi(1, 1, 8, (-vlb));
          rxi(3, 8, 0, vub);
          goto L_04b3;
L_04b2:
          rxi(1, 1, 0, (-vlb));
L_04b3:
          rx(2, 1, local, (frame + 0));
L_04b1:
          frame = (frame + (2 * 4));
          goto L_04b4;
L_04ad:
          gfix(3);
          decvar->header = ga;
          decvar->base = 0;
          gword((-vlb));
          gwordcrel(dv);
          if (allocate == 0) goto L_04b5;
          frame = (frame + vub);
L_04b5:
L_04b4:
          }
L_04aa:
          goto L_0418;
c_94:
          setlhs();
          lhs->type = 6;
          lhs->format = tag();
          goto L_0418;
          goto L_04b6;
          void tempset()
{
          frame = ((frame + 3) & (\3));
          sset(local, frame, 4, 0);
          rhs->type = 6;
          rhs->format = 800;
          frame = (frame + 32);
L_04b6:
c_73:
          sym = next;
          readsymbol(next);
          if (65 > sym) goto L_04b7;
          if (sym > 90) goto L_04b7;
          goto *pc[sym];
L_04b7:
          abort(((1226842175 - (32 << 8)) + (sym << 8)));
pc_65:
pc_68:
pc_75:
          cload(0, 7);
          claim(7);
          setboth();
          j = next;
          readsymbol(next);
          if (sym != 65) goto L_04b8;
          if (j > 1) goto L_04b9;
          k = 61;
          goto L_04ba;
L_04b9:
          k = 60;
L_04ba:
          compare(*lhs, *rhs, k);
          goto L_04bb;
L_04b8:
          if (sym != 75) goto L_04bc;
          load(*lhs, 25);
          address(*rhs, (-1));
          rhs->type = 1;
          rxd(39, lhs->sptfm, *rhs);
          release(lhs->sptfm);
          goto L_04bb;
L_04bc:
          k = next;
          readsymbol(next);
          comparerecords(*lhs, *rhs, k);
L_04bb:
          stp = (stp - 2);
          drop(*lhs);
          drop(*rhs);
          skip(1, (j + invert));
          invert = 0;
          rxi(3, 7, 0, 1);
          forgetreg((1 << 7));
          ccca = 0;
          sset(7, 0, 1, 0);
          goto L_0418;
pc_66:
          sym = next;
          readsymbol(next);
          ownform = 11;
          owntype = 3;
          claimliteral(sym, 3);
          selectliteralarea();
          decvar->disp = ca;
          decvar->base = 15;
          selectcodearea();
          goto L_0418;
pc_67:
          setlhs();
          if (lhs->form != 4) goto L_04bd;
          if (lhs->oper == 0) goto L_04be;
L_04bd:
          t = 25;
          if (!(floating(*lhs))) goto L_04bf;
          t = 26;
L_04bf:
          load(*lhs, t);
          hazard(lhs->sptfm);
L_04be:
          goto L_0418;
pc_73:
          setboth();
          lrd(*rhs, 25);
          address(*lhs, (-1));
          lhs->type = 1;
          rxd(40, rhs->sptfm, *lhs);
          claim(lhs->sptfm);
          lhs->type = 6;
          stp = (stp - 1);
          goto L_0418;
pc_71:
pc_72:
          if (sym != 72) goto L_04c0;
          k = tag();
L_04c0:
          if (next == 83) goto L_04c1;
          tempset();
          sstack(*rhs);
          rhs->type = 0;
          goto L_04c2;
L_04c1:
          readsymbol(next);
L_04c2:
          if (sym != 71) goto L_04c3;
          cstack(0);
          goto L_04c4;
L_04c3:
          vstack(k);
L_04c4:
          assign(1);
          goto L_0418;
pc_74:
          setboth();
          lrd(*lhs, 2);
          lrd(*rhs, 3);
          perm(35);
          if (next > 1) goto L_04c5;
          cput(0);
          goto L_04c6;
L_04c5:
          if (next != 3) goto L_04c7;
          cput(2);
          goto L_04c6;
L_04c7:
          cput(1);
L_04c6:
          stp = (stp - 2);
          sset(7, 0, 1, 0);
          claim(7);
          if (next != 0) goto L_04c8;
          rxi(10, 7, 0, 1);
L_04c8:
          readsymbol(next);
          goto L_0418;
pc_76:
          poplhs();
          x = lhs;
          setlhs();
          if (lhs->type == 0) goto L_04c9;
          poplhs();
          tempset();
          sstack(*lhs);
          drop(*lhs);
          assign(1);
          sset(local, (frame - 32), 4, 0);
          rhs->type = 0;
          setlhs();
L_04c9:
          load(*lhs, 2);
          lrd(*x, 3);
          perm(setops[next]);
          readsymbol(next);
          goto L_0418;
pc_83:
          setboth();
          stacked[(stp - 1)].v = rhs;
          stacked[stp].v = lhs;
          goto L_0418;
pc_78:
          if ((control & 2) == 0) goto L_04ca;
          setlhs();
          testzero(*lhs);
          claim(lhs->sptfm);
          rr(22, 16, 15);
L_04ca:
          goto L_0418;
pc_87:
          cstack(0);
          rhs->form = 1;
          rhs->sptfm = 8;
          goto L_0418;
c_126:
          sym = next;
          readsymbol(next);
          if (sym != 65) goto L_04cb;
          decvar = gvar;
          assemble((-2), labs, names);
          altalign = (altalign | falign);
          goto L_04cc;
L_04cb:
          if (sym != 66) goto L_04cd;
          goto U_015e;
L_04cd:
          if (sym == 67) goto L_04ce;
          abort(1095578677);
L_04ce:
          if (frame <= maxframe) goto L_04cf;
          maxframe = frame;
L_04cf:
          frame = putativeframebase;
L_04cc:
          goto L_0418;
c_123:
          gmode = (-1);
          assemble(gtype, labs, names);
          goto L_0418;
c_125:
          gmode = 0;
          if (amode >= 0) goto L_04d0;
          goto U_015e;
L_04d0:
          if ((gvar->flag & 4) == 0) goto L_04d1;
          goto U_015e;
L_04d1:
          if (names <= gstart) goto L_04d2;
          gvar->extra = parms;
          for (j = (gstart + 1); j += 1; j != names) {
          ap = &var[j];
          parms = (parms - 1);
          fp = &var[parms];
          memcpy(*fp,*ap,sizeof struct VARFM);
          fp->base = 8;
          if ((ap->flag & 96) != 0) goto L_04d7;
          ap->flag = ((ap->flag & (\2)) | 8);
L_04d7:
          }
L_04d6:
          if (parms >= names) goto L_04d8;
          abort(1095578928);
L_04d8:
          if (ap->type != 5) goto L_04d9;
          if ((ap->xform & ((96 << 8) + 255)) != 4) goto L_04d9;
          if (ap->base == 0) goto L_04d9;
          gvar->header = ap->disp;
          fp->flag = (fp->flag | 2);
L_04d9:
L_04d2:
          gdisp = (-1);
          maxparm = frame;
          if (amode == 0) goto L_04da;
          goto U_015e;
L_04da:
          header(*gvar);
          goto L_0418;
c_72:
          decvar = &begin;
          decvar->disp = newtag();
          otype = 0;
          spec = 0;
          potype = 0;
          if (level == 0) goto L_04db;
          cstack(decvar->disp);
          poplhs();
          lhs->type = 0;
          call(*lhs);
L_04db:
          strncpy(blockname,"BLOCK",19+1);
          assemble(0, labs, names);
          goto L_0418;
L_0418:
          }
c_44:
c_48:
c_49:
c_50:
c_51:
c_52:
c_53:
c_54:
c_55:
c_56:
c_57:
c_59:
c_89:
c_96:
c_99:
c_124:
c_127:
          abort(((4144928 << 8) | sym));
          goto L_04dc;
          void alignalternatives()
{
          int n;
          int mod;
          int j;
          struct VARFM *v;
          falign = altalign;
          n = (putativeframebase - trueframebase);
          if (n == 0) goto L_04dd;
          if (altalign != 3) goto L_04de;
L_04dd:
          return;
L_04de:
          if (altalign != 0) goto L_04df;
          mod = n;
          goto L_04e0;
L_04df:
          if (n != 1) goto L_04e1;
          return;
L_04e1:
          mod = 2;
L_04e0:
          for (j = parms; j += 1; j != altfirst) {
          v = &var[j];
          v->disp = (v->disp - mod);
          }
L_04e5:
          maxframe = (maxframe - mod);
L_04dc:
c_59:
          if (level == 0) goto L_04e6;
          if (uncondjump != ca) goto L_04e7;
          if (gvar->type != 0) goto L_04e8;
          if ((control & 32) != 0) goto L_04e8;
L_04e7:
          if ((control & 64) == 0) goto L_04e9;
          if (level != 1) goto L_04e9;
          perm(50);
          cput(0);
L_04e9:
          return();
L_04e8:
          goto L_04ea;
L_04e6:
          if ((ga & 1) == 0) goto L_04eb;
          gbyte(0);
L_04eb:
          if ((lita & 1) == 0) goto L_04ec;
          claimliteral(0, 0);
L_04ec:
L_04ea:
          gvar->flag = (gvar->flag | closed);
          blockmark(17);
          resetoptimisationdata();
U_015e:
          if (amode < 0) goto L_04ed;
          if (local == 13) goto L_04ee;
          activity[local] = 0;
L_04ee:
          level = (level - 1);
          local = breg[level];
          goto L_04ef;
L_04ed:
          alignalternatives();
          if (maxframe <= frame) goto L_04f0;
          frame = maxframe;
L_04f0:
          if (amode != (-2)) goto L_04f1;
          oldframe = frame;
          goto L_04f2;
L_04f1:
          frame = ((frame + 3) & (\3));
          if ((frame >> 16) == 0) goto L_04f3;
          abort(1095578933);
L_04f3:
          gvar->length = frame;
L_04f2:
L_04ef:
          frame = oldframe;
          extraframe = oldextraframe;
          uncondjump = oldjump;
          ca = procca;
          vardiags = oldvardiags;
          newtemp = tempbase;
          nexttemp = oldnexttemp;
          tempbase = oldtempbase;
          lastline = (-15);
          for (;;) {
L_04f4:
          control = (impcom.flags & 255);
          if ((control & 32) == 0) goto L_04f5;
          control = (control & (\23));
L_04f5:
          selectinput(1);
          selectoutput(2);
          printsymbol((12 >> 1));
          printsymbol((8 >> 1));
          claimliteral(8, 3);
          var[0] = 0;
          var[800].length = 32;
          parms = 800;
          cslen = &currentstring[0];
          activity[8] = (-1);
          activity[15] = (-1);
          activity[0] = (-1);
          activity[14] = (-1);
          activity[16] = (-1);
          for (j = 0; j += 1; j != (25 - 1)) {
          stak[j].link = &stak[(j + 1)];
          dlist[j].link = &dlist[(j + 1)];
          }
L_04f9:
          stak[25].link = null;
          dlist[25].link = null;
          descasl = &stak[0];
          dasl = &dlist[0];
          using.link = null;
          for (j = 0; j += 1; j != 30) {
          forstk[j] = 0;
          }
L_04fd:
          forstp = 0;
          for = &forstk[0];
          readsymbol(next);
          spec = 0;
          decvar = &begin;
          assemble(2, 0, 0);
          closefiles();
          if (faulty == 0) goto L_04fe;
//           EVENT 0x000f
L_04fe: