#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  static const int True = 1;
  static const int False = 0;
  _imp_string Cliparam;
  Cliparam = _imp_str_literal("adec");
  static const _imp_string Title = _imp_str_literal("  EUCSD IMP Compiler for M68000.  APM Version  2.2g");
  static const int Which = '.imp';
  static const int Maxname = 127;
  _imp_string Mainfile;
  _imp_string Objfile;
  typedef struct Edfile {
    int Start1;
    int Lim1;
    int Start2;
    int Lim2;
    int Lim;
    int Lbeg;
    int Fp;
    int Change;
    int Flag;
    int Line;
    int Diff;
    unsigned char Top;
    unsigned char Win;
    unsigned char Bot;
    unsigned char Min;
    unsigned char Row;
    unsigned char Col;
    _imp_string Name;
  } Edfile;
  static const int Newgroup = 1;
  static const int Nodefault = 2;
  _imp_string Date;
  Date = _imp_str_literal("02/02/02");
  _imp_string Time;
  Time = _imp_str_literal("02:02");
  int Cputime;
  Cputime = 123;
  static int Item = 0;
  static int Listout = 0;
  static const int Arrbit = 0x80000000;
  static const int Loopbit = 0x40000000;
  static const int Capbit = 0x20000000;
  static const int Overbit = 0x10000000;
  static const int Assbit = 0x08000000;
  static const int Strassbit = 0x04000000;
  static const int Sassbit = 0x02000000;
  static const int Bassbit = 0x01000000;
  static const int Assmask = Assbit | Strassbit | Sassbit | Bassbit;
  static const int Linebit = 0x00800000;
  static const int Diagbit = 0x00400000;
  static const int Tracebit = 0x00200000;
  static const int Stackbit = 0x00100000;
  static const int Checkbit = 0x00080000;
  static const int Sysbit = 0x00040000;
  static const int Strictbit = 0x00020000;
  static const int Volbit = 0x00010000;
  static const int Halfbit = 0x00008000;
  static const int Lowbit = 0x00004000;
  static const int Editbit = 0x00002000;
  static const int Runbit = 0x00001000;
  static const int Forcebit = 0x00000800;
  static const int Logbit = 0x00000400;
  static const int Warnbit = 0x00000200;
  static const int Nonsbit = 0x00000100;
  static const int Permbit = 0x00000080;
  static const int Newbit = 0x00000040;
  static const int Codelist = 0x00000020;
  static const int Dictlist = 0x00000010;
  static const int Explist = 0x00000008;
  static const int Maplist = 0x00000004;
  static const int Ttlist = 0x00000002;
  static const int List = 0x00000001;
  static const int Listbits = Codelist + Dictlist + Explist + Maplist + Ttlist + List;
  static int Control = Warnbit + Checkbit + Linebit + Diagbit + Editbit + Volbit + Strassbit + Assbit + Arrbit +
                       Loopbit + Capbit + Stackbit;
  int Initcon;
  int Time1;
  int Time2;
  static const int Oflow = 1;
  static const int Fail = 11;
  static const int Done = 12;
  static const int Redo = 13;
  static const int Abandon = 14;
  static const int Maxint = 0x7FFFFFFF;
  static const int Minint = ~Maxint;
  static const int Sign16 = ~0x7FFF;
  static const int Sign = ~0x7FFFFFFF;
  static const int Smallmin = -1024;
  static const int Smallmax = 1023;
  static const int Litmax = Smallmin - (Smallmax + 1);
  static const int Litmin = Litmax - 199;
  static const int Litmite = -255;
  static const int Litquick = -16;
  static const int One = -(1 << 1);
  static const int D0 = 1;
  static const int D1 = D0 + 1;
  static const int D2 = D0 + 2;
  static const int D7 = D0 + 7;
  static const int A0 = D0 + 8;
  static const int A1 = A0 + 1;
  static const int A6 = A0 + 6;
  static const int A7 = A0 + 7;
  static const int Inda0 = A0 + 8;
  static const int Inda7 = Inda0 + 7;
  static const int Posta0 = Inda0 + 8;
  static const int Posta7 = Posta0 + 7;
  static const int Prea0 = Posta0 + 8;
  static const int Prea7 = Prea0 + 7;
  static const int Undef = A7;
  static int Dictlim = 1000;
  static int Finalbound = 64;
  int Lablim;
  int Np0;
  int Explim;
  int Charbound;
  static const int Labels = 42;
  static const int Triples = 200;
  static const int Ad = 16384;
  static const int Breg = D0 + 4;
  static const int Lineloc = D0 + 5;
  static const int F1 = A0 + 6;
  static const int Gb = A0 + 5;
  static const int Mb = A0 + 4;
  static const int Maxdreg = D0 + 3;
  static const int Maxareg = A0 + 3;
  static const int D0b = 1;
  static const int D1b = 2;
  static const int D2b = 4;
  static const int Bregb = 16;
  static const int A0b = 0x100;
  static const int A1b = 0x200;
  static const int A2b = 0x400;
  static const int Anydreg = 0x00FF - Bregb;
  static const int Anyareg = 0xFF00;
  static const int Anyreg = 0xFFFF;
  static const int Defaultfree = (2 << (Maxdreg - D0)) - 1 + (((2 << (Maxareg - A0)) - 1) << 8) + Bregb;
  int Maxcalldreg;
  int Maxcallareg;
  int Free;
  int Litpos;
  int Litstore[200 /*-2247:-2048*/];
  typedef struct Objinfo {
    short Flags;
    short Type;
    unsigned char Reg;
    unsigned char Mode;
    int Val;
  } Objinfo;
  typedef struct Identinfo {
  } Identinfo;
  static const int Aregmode = 0b001000;
  static const int Dispmode = 0b101000;
  static const int Indexmode = 0b110000;
  static const int Absmode = 0b111000;
  static const int Pcmode = 0b111010;
  static const int Litmode = 0b111100;
  static const int Indir = 8;
  static const int Post = 16;
  static const int Pre = 24;
  static const int Labmode = 0b10000000 + Pcmode;
  static const int Procmode = 0b11000000 + Pcmode;
  static const int Globalmode = Dispmode + (Gb - A0);
  static const int Ownmode = 0b01000000 + Dispmode + (Mb - A0);
  static const int Constmode = 0b01000000 + Pcmode;
  static const int Framemode = 0b10000000 + Dispmode;
  static const int Cat = 0x000F;
  static const int Writable = 0x0001;
  static const int Readable = 0x0002;
  static const int Volatile = 0x0004;
  static const int Arrflag = 0x0008;
  static const int Alt = 0x0008;
  static const int Wflag = 0x0010;
  static const int Rflag = 0x0020;
  static const int Okflag = 0x0040;
  static const int Noret = 0x0040;
  static const int Mflag = 0x0080;
  static const int Spec = 0x0100;
  static const int Typeid = 0x0200;
  static const int Packed = 0x0400;
  static const int Indirect = 0x0800;
  static const int Proc = 0x3000;
  static const int Proc1 = 0x1000;
  static const int Proc2 = 0x2000;
  static const int Ext = 0x4000;
  static const int Name = Sign16;
  static const int Heritable = Writable + Readable + Volatile + Wflag + Rflag + Okflag + Arrflag;
  static const int Inty = 0;
  static const int Chary = 1;
  static const int Booly = 2;
  static const int Enumy = 3;
  static const int Pointy = 4;
  static const int Realy = 5;
  static const int Stringy = 8;
  static const int Arry = 9;
  static const int Sety = 10;
  static const int Recy = 12;
  static const int Filey = 13;
  static const int Nonord = 12;
  static Objinfo Definedlabel = 0;
  static Objinfo Forwardlabel = 0;
  static Objinfo Beginblock = 0;
  static Objinfo Typeident = 0;
  static const int Main = 1;
  Edfile File[3 /*1:3*/];
  Edfile *Cur;
  int Fcontrol[3 /*1:3*/];
  int Curfile;
  int Lastfile;
  int Curstart;
  int Curlim;
  void Setoptions(_imp_string Parm) {
    static int Removewarning;
    static const int Checks = Assmask + Arrbit + Loopbit + Capbit + Overbit;
    Removewarning = Addr(Parm);
    if (!(Control & Checkbit)) Control = Control & (~Checks);
    if (Control & Listbits) Control = Control & (~Editbit);
  }
  void Setextension(_imp_string * F, _imp_string Ext) {
    int Strip;
    int Last4(_imp_string * S) {
      int I;
      int E;
      I = 0;
      E = 0;
      while (I < *Length(*S)) {
        I++;
        E = (E << 8) + *Charno(*S, I);
      }
      return (E);
    }
    Strip = Last4(Ext);
    if (_imp_strcmp(*F, _imp_str_literal("")) == 0) {
      *F = Mainfile;
      Strip = Which;
    }
    if ((Last4(*F) | 0x202020) == Strip) *Length(*F) = *Length(*F) - 4;
    *F = _imp_join(*F, Ext);
  }
  void Openfiles(void) {
    _imp_string Listfile;
    Listfile = _imp_str_literal("");
    Objfile = _imp_str_literal("");
    File[Main] = 0;
    Setoptions(Cliparam);
    if (!(Control & Diagbit)) Control = Control & (~Linebit);
    File[Main].Name = Mainfile;
    File[Main].Flag = 32768;
    Time1 -= Cputime;
    Time1 += Cputime;
    if (File[Main].Flag) exit(0);
    if (_imp_strcmp(Listfile, _imp_str_literal("")) != 0 || (Control & (List + Ttlist)) != 0) {
      if (!(Control & Ttlist)) {
        Setextension(Listfile, _imp_str_literal(".lis"));
        Listout = 2;
        Openoutput(Listout, Listfile);
      }
      Control = Control & (~(Editbit + Ttlist));
      if (!(Control & Listbits)) Control = Control | List;
    }
    Selectoutput(Listout);
    if (Control & Listbits) {
      if ((Control & Listbits) != Maplist) Control = Control | List;
      Newlines(2);
      Printstring(Title);
      Newlines(2);
      Printstring(_imp_str_literal("   "));
      Printstring(File[Main].Name);
      Printstring(_imp_str_literal("  compiled on "));
      Printstring(Date);
      Printstring(_imp_str_literal("  at  "));
      Printstring(Time);
      Newlines(2);
    }
    Initcon = Control;
  }
  Time1 = 0;
  Openfiles();
  Dictlim += 300;
  Charbound = Dictlim * 8;
  Finalbound = (Finalbound << 10) + 4095;
  Lablim = Dictlim + Labels;
  Explim = Lablim + Triples;
  Np0 = Lablim + 4;
  File[Main].Change = 0x7FFFFFFF;
  Forwardlabel.Flags = Spec;
  Forwardlabel.Mode = Labmode;
  Definedlabel.Mode = Labmode;
  Beginblock.Mode = Procmode;
  Typeident.Flags = Typeid + Recy;
  Identinfo Dict[(Explim - 1) + 1];
  int Dlim;
  int Dlim0;
  int Dmin;
  int Dmin0;
  int Dictshown;
  int Inclim;
  Identinfo *Dlink;
  Identinfo *Dformat;
  Identinfo *Dtemp;
  Identinfo *Dtemp2;
  Identinfo *Dtsprel;
  Identinfo *Dint;
  int Subbed;
  int Ranges;
  unsigned char Char[Charbound + 1];
  int Char0;
  int Charlim;
  int Charmin;
  int Newlen;
  short Hashindex[256 /*0:255*/];
  short *Head;
  static const int Null = 41;
  static const int Procstar = 42;
  static const int Inttype = 43;
  static const int Shorttype = 46;
  static const int Halftype = 49;
  static const int Bytetype = 52;
  static const int Mitetype = 55;
  static const int Booltype = 58;
  static const int Chartype = 61;
  static const int Stringstar = 62;
  static const int String1 = 63;
  static const int Stringtype = 64;
  static const int Arrstar = 65;
  static const int Nullsettype = 66;
  static const int Recstar = 67;
  static const int Realtype = 69;
  static const int Signal = 73;
  static const int Daddr = 74;
  static const int Dsizeof = 77;
  static const int Index = 78;
  static const int Lenref = 79;
  static const int Sindex = 82;
  static const int Imul = 86;
  static const int Idiv = 87;
  static const int Ipow = 88;
  static const int Fneg = 89;
  static const int Fadd = 90;
  static const int Fsub = 91;
  static const int Fmul = 92;
  static const int Fdiv = 93;
  static const int Fpow = 94;
  static const int Float = 95;
  static const int Drem = 98;
  static const int Unass = 102;
  static const int Adok = 103;
  static const int Stackok = 104;
  static const int Asize = 105;
  static const int Concat = 106;
  static const int Dtostring = 107;
  static const int Aget = 109;
  static const int Forok = 110;
  static const int Check = 111;
  static const int Scomp = 112;
  static const int Strcopy = 113;
  static const int Strtostk = 114;
  static const int Dnew = 115;
  static const int Resolves = 117;
  static const int Deventf = 128;
  static const int Devent = 134;
  static const int Dnil = 137;
  static const int Dprintstr = 155;
  static const int Dwrite = 183;
  static const int Opmax = Resolves;
  void Sethashhead(_imp_string * S) {
    int H;
    int I;
    H = 0;
    for (I = 1; I <= *Length(*S); I++) H = H << 1 ^ *Charno(*S, I);
    Head = &Hashindex[H & 255];
  }
  void Preset(void) {
    static const int Cmax = 775;
    static unsigned char Charinit[776 /*0:775*/] = {
        0,   2,   'd', '0', 2,   'd', '1', 2,   'd', '2', 2,   'd', '3', 2,   'd', '4', 2,   'd', '5', 2,   'd', '6',
        2,   'd', '7', 2,   'a', '0', 2,   'a', '1', 2,   'a', '2', 2,   'a', '3', 2,   'a', '4', 2,   'a', '5', 2,
        'a', '6', 2,   'a', '7', 7,   'i', 'n', 't', 'e', 'g', 'e', 'r', 6,   'M', 'A', 'X', 'I', 'N', 'T', 12,  's',
        'h', 'o', 'r', 't', 'i', 'n', 't', 'e', 'g', 'e', 'r', 11,  'h', 'a', 'l', 'f', 'i', 'n', 't', 'e', 'g', 'e',
        'r', 11,  'b', 'y', 't', 'e', 'i', 'n', 't', 'e', 'g', 'e', 'r', 11,  'm', 'i', 't', 'e', 'i', 'n', 't', 'e',
        'g', 'e', 'r', 7,   'B', 'O', 'O', 'L', 'E', 'A', 'N', 5,   'F', 'A', 'L', 'S', 'E', 4,   'T', 'R', 'U', 'E',
        4,   'c', 'h', 'a', 'r', 6,   's', 't', 'r', 'i', 'n', 'g', 5,   'a', 'r', 'r', 'a', 'y', 6,   'r', 'e', 'c',
        'o', 'r', 'd', 4,   'T', 'E', 'X', 'T', 4,   'r', 'e', 'a', 'l', 8,   'l', 'o', 'n', 'g', 'r', 'e', 'a', 'l',
        6,   'S', 'I', 'G', 'N', 'A', 'L', 4,   'a', 'd', 'd', 'r', 6,   's', 'i', 'z', 'e', 'o', 'f', 5,   'I', 'N',
        'D', 'E', 'X', 6,   'l', 'e', 'n', 'g', 't', 'h', 6,   'c', 'h', 'a', 'r', 'n', 'o', 4,   'I', 'M', 'U', 'L',
        4,   'I', 'D', 'I', 'V', 4,   'I', 'P', 'O', 'W', 4,   'F', 'N', 'E', 'G', 4,   'F', 'A', 'D', 'D', 4,   'F',
        'S', 'U', 'B', 4,   'F', 'M', 'U', 'L', 4,   'F', 'D', 'I', 'V', 4,   'F', 'P', 'O', 'W', 5,   'f', 'l', 'o',
        'a', 't', 3,   'r', 'e', 'm', 5,   'U', 'N', 'A', 'S', 'S', 4,   'A', 'D', 'O', 'K', 7,   'S', 'T', 'A', 'C',
        'K', 'O', 'K', 5,   'A', 'S', 'I', 'Z', 'E', 6,   'C', 'O', 'N', 'C', 'A', 'T', 8,   't', 'o', 's', 't', 'r',
        'i', 'n', 'g', 4,   'A', 'G', 'E', 'T', 5,   'F', 'O', 'R', 'O', 'K', 5,   'C', 'H', 'E', 'C', 'K', 5,   'S',
        'C', 'O', 'M', 'P', 7,   'S', 'T', 'R', 'C', 'O', 'P', 'Y', 8,   'S', 'T', 'R', 'T', 'O', 'S', 'T', 'K', 3,
        'n', 'e', 'w', 8,   'r', 'e', 's', 'o', 'l', 'v', 'e', 's', 9,   's', 'u', 'b', 's', 't', 'r', 'i', 'n', 'g',
        7,   'e', 'v', 'e', 'n', 't', 'f', 'm', 5,   'e', 'v', 'e', 'n', 't', 3,   's', 'u', 'b', 4,   'l', 'i', 'n',
        'e', 5,   'e', 'x', 't', 'r', 'a', 7,   'm', 'e', 's', 's', 'a', 'g', 'e', 5,   'e', 'v', 'e', 'n', 't', 2,
        'n', 'l', 3,   's', 'n', 'l', 3,   'n', 'i', 'l', 7,   'd', 'i', 's', 'p', 'o', 's', 'e', 5,   'r', 'o', 'u',
        'n', 'd', 5,   't', 'r', 'u', 'n', 'c', 8,   'f', 'r', 'a', 'c', 't', 'i', 'o', 'n', 3,   'i', 'n', 't', 5,
        'i', 'n', 't', 'p', 't', 6,   'f', 'r', 'a', 'c', 'p', 't', 4,   's', 'q', 'r', 't', 10,  'n', 'e', 'x', 't',
        's', 'y', 'm', 'b', 'o', 'l', 10,  'r', 'e', 'a', 'd', 's', 'y', 'm', 'b', 'o', 'l', 10,  's', 'k', 'i', 'p',
        's', 'y', 'm', 'b', 'o', 'l', 11,  'p', 'r', 'i', 'n', 't', 's', 'y', 'm', 'b', 'o', 'l', 11,  'p', 'r', 'i',
        'n', 't', 's', 't', 'r', 'i', 'n', 'g', 9,   'o', 'p', 'e', 'n', 'i', 'n', 'p', 'u', 't', 10,  'o', 'p', 'e',
        'n', 'o', 'u', 't', 'p', 'u', 't', 11,  's', 'e', 'l', 'e', 'c', 't', 'i', 'n', 'p', 'u', 't', 12,  's', 'e',
        'l', 'e', 'c', 't', 'o', 'u', 't', 'p', 'u', 't', 8,   's', 'e', 't', 'i', 'n', 'p', 'u', 't', 9,   's', 'e',
        't', 'o', 'u', 't', 'p', 'u', 't', 10,  'r', 'e', 's', 'e', 't', 'i', 'n', 'p', 'u', 't', 11,  'r', 'e', 's',
        'e', 't', 'o', 'u', 't', 'p', 'u', 't', 10,  'c', 'l', 'o', 's', 'e', 'i', 'n', 'p', 'u', 't', 11,  'c', 'l',
        'o', 's', 'e', 'o', 'u', 't', 'p', 'u', 't', 6,   'p', 'r', 'o', 'm', 'p', 't', 7,   'n', 'e', 'w', 'l', 'i',
        'n', 'e', 5,   's', 'p', 'a', 'c', 'e', 6,   's', 'p', 'a', 'c', 'e', 's', 8,   'n', 'e', 'w', 'l', 'i', 'n',
        'e', 's', 4,   'r', 'e', 'a', 'd', 138, 'r', 'e', 'a', 'd', 's', 't', 'r', 'i', 'n', 'g', 4,   'r', 'e', 'a',
        'd', 136, 'r', 'e', 'a', 'd', 'r', 'e', 'a', 'l', 4,   'r', 'e', 'a', 'd', 5,   'w', 'r', 'i', 't', 'e', 7,
        'c', 'p', 'u', 't', 'i', 'm', 'e', 5,   'p', 'r', 'i', 'n', 't', 7,   'p', 'r', 'i', 'n', 't', 'f', 'l', 8,
        'i', 'n', 's', 't', 'r', 'e', 'a', 'm', 9,   'o', 'u', 't', 's', 't', 'r', 'e', 'a', 'm', 8,   'c', 'l', 'i',
        'p', 'a', 'r', 'a', 'm', 0};
    static const int Premax = 196;
    static short Dictinit[936 /*246:1181*/] = {
        516,    -1,    0,      0,     0,      0,     527,    -1,    0,      0,     0,      4,     512,    43,
        4,      56,    -32768, 0,     0,      -44,   4,      60,    -32768, 0,     0,      43,    4,      60,
        32767,  -1,    512,    43,    2,      56,    -32768, 0,     0,      -44,   2,      60,    -1,     -32768,
        0,      -44,   2,      60,    0,      32767, 512,    43,    2,      56,    -32768, 0,     0,      -44,
        2,      60,    0,      0,     0,      -44,   2,      60,    0,      -1,    512,    43,    1,      56,
        -32768, 0,     0,      -44,   1,      60,    0,      0,     0,      -44,   1,      60,    0,      255,
        512,    43,    1,      56,    -32768, 0,     0,      -44,   1,      60,    -1,     -128,  0,      -44,
        1,      60,    0,      127,   514,    58,    1,      0,     0,      0,     0,      58,    1,      60,
        0,      0,     0,      58,    1,      60,    0,      1,     513,    61,    255,    0,     0,      0,
        520,    61,    0,      0,     0,      0,     520,    -62,   -2,     0,     0,      0,     520,    -62,
        -256,   0,     0,      0,     521,    0,     0,      0,     0,      0,     522,    -1,    0,      0,
        0,      0,     524,    0,     0,      0,     0,      0,     525,    61,    4,      0,     0,      0,
        517,    0,     4,      0,     0,      0,     517,    0,     4,      0,     0,      0,     0,      -1,
        0,      0,     0,      0,     0,      -1,    0,      0,     0,      0,     4256,   42,    0,      56,
        0,      16122, 4098,   75,    0,      56,    0,      0,     0,      -44,   76,     0,     0,      4,
        -32701, -1,    0,      6313,  -1,     -4,    4098,   75,    0,      56,    0,      0,     4096,   42,
        0,      56,    -32767, 2861,  4099,   80,    0,      56,    0,      0,     0,      -53,   81,     6144,
        0,      4,     -32701, -63,   0,      6313,  -1,     -4,    4099,   83,    0,      56,    0,      0,
        0,      -53,   84,     6144,  0,      4,     -32701, -63,   85,     6313,  -1,     -4,    67,     -44,
        0,      169,   -1,     -8,    4256,   42,    0,      56,    0,      16116, 4256,   42,    0,      56,
        0,      16110, 4096,   42,    0,      56,    0,      16098, 4096,   42,    0,      56,    0,      16092,
        4096,   42,    0,      56,    0,      16086, 4096,   42,    0,      56,    0,      16080, 4096,   42,
        0,      56,    0,      16074, 4096,   42,    0,      56,    0,      16068, 4096,   42,    0,      56,
        0,      16062, 4098,   96,    0,      56,    0,      16056, 0,      -70,   97,     0,     0,      4,
        67,     -44,   0,      169,   -1,     -4,    4098,   99,    0,      56,    0,      0,     0,      -44,
        100,    0,     0,      4,     67,     -44,   101,    169,   -1,     -4,    67,     -44,   0,      425,
        -1,     -8,    4096,   42,    0,      56,    -32722, 2578,  4096,   42,    0,      56,    -32704, 2064,
        4096,   42,    0,      56,    -32688, 2839,  4096,   42,    0,      56,    -32665, 3097,  4096,   42,
        0,      56,    -32640, 2077,  4098,   108,   0,      56,    -32611, 6,     0,      -64,   97,     6144,
        0,      4,     4096,   42,    0,      56,    -32605, 2597,  4096,   42,    0,      56,    -32568, 2334,
        4096,   42,    0,      56,    -32538, 1806,  4096,   42,    0,      56,    -32524, 2626,  4096,   42,
        0,      56,    -32458, 2070,  4096,   42,    0,      56,    -32436, 2090,  4103,   116,   0,      56,
        0,      16008, 0,      -68,   76,     6144,  0,      4,     22786,  118,   0,      108,   0,      0,
        0,      -59,   119,    0,     0,      0,     -32701, -63,   120,    6313,  -1,     -4,    67,     -65,
        121,    6569,  -1,     -260,  -32701, -63,   122,    6825,  -1,     -264,  -32701, -63,   0,      7081,
        -1,     -268,  4098,   124,   0,      56,    -32394, 15,    0,      -65,   125,    6144,  0,      4,
        -32701, -63,   126,    6313,  -1,     -4,    67,     -44,   127,    169,   -1,     -8,    67,     -44,
        0,      425,   -1,     -12,   524,    0,     129,    0,     -1,     -264,  3,      52,    0,      0,
        0,      0,     3,      52,    0,      0,     0,      1,     3,      46,    0,      0,     0,      2,
        3,      43,    0,      0,     0,      4,     3,      64,    0,      0,     0,      8,     67,     128,
        0,      45,    0,      32,    66,     43,    0,      60,    0,      10,    66,     61,    0,      60,
        0,      10,    67,     67,    0,      56,    0,      0,     4096,   139,   0,      56,    0,      16002,
        0,      -1,    76,     0,     0,      4,     4098,   141,   0,      56,    0,      16050, 0,      -44,
        142,    0,     0,      4,     67,     -70,   0,      169,   -1,     -4,    4098,   141,   0,      56,
        0,      16044, 4098,   145,   0,      56,    0,      16038, 0,      -70,   142,    0,     0,      4,
        4098,   141,   0,      56,    0,      16032, 4098,   141,   0,      56,    0,      16026, 4098,   145,
        0,      56,    0,      16020, 4098,   145,   0,      56,    0,      16014, 4098,   132,   0,      56,
        0,      15996, 4098,   132,   0,      56,    0,      15990, 4096,   42,    0,      56,    0,      15990,
        4256,   154,   0,      56,    0,      15984, 0,      -1,    97,     0,     0,      4,     4096,   156,
        0,      56,    0,      15978, 0,      -1,    157,    0,     0,      4,     67,     -65,   0,      6313,
        -1,     -256,  26880,  159,   0,      108,   0,      0,     0,      -1,    160,    0,     0,      0,
        67,     -44,   161,    169,   -1,     -4,    67,     -65,   0,      6313,  -1,     -260,  26880,  159,
        0,      108,   0,      0,     4096,   154,   0,      56,    0,      15960, 4096,   154,   0,      56,
        0,      15954, 26880,  166,   0,      108,   0,      0,     0,      -1,    97,     0,     0,      0,
        26880,  166,   0,      108,   0,      0,     26880,  0,     0,      108,   0,      0,     26880,  0,
        0,      108,   0,      0,     4096,   42,    0,      56,    0,      15936, 4096,   42,    0,      56,
        0,      15930, 26880,  173,   0,      108,   0,      0,     0,      -1,    157,    0,     0,      0,
        4096,   42,    0,      56,    -32379, 4,     4096,   42,    0,      56,    -32375, 4,     22784,  166,
        0,      108,   0,      0,     22784,  166,   0,      108,   0,      0,     22790,  179,   0,      108,
        0,      0,     0,      -65,   0,      6144,  0,      0,     22798,  181,   0,      108,   0,      0,
        0,      -70,   0,      0,     0,      0,     22798,  1,     0,      108,   0,      0,     22784,  184,
        0,      108,   0,      0,     0,      -1,    100,    0,     0,      0,     26886,  1,     0,      108,
        0,      0,     22784,  187,   0,      108,   0,      0,     0,      -1,    188,    0,     0,      0,
        67,     -70,   189,    169,   -1,     -4,    67,     -44,   190,    425,   -1,     -8,    67,     -44,
        0,      681,   -1,     -12,   22784,  192,   0,      108,   0,      0,     0,      -1,    193,    0,
        0,      0,     67,     -70,   101,    169,   -1,     -4,    67,     43,    0,      45,    0,      392,
        67,     43,    0,      45,    0,      396,   67,     64,    0,      45,    0,      464};
    int I;
    int Ci;
    int Anons;
    Identinfo *Dp;
    void Putchar(void) {
      *Byteinteger(Charlim) = Charinit[Ci];
      Charlim++;
      Ci++;
    }
    void Textset(Identinfo * Dp) {
      int Len;
      Dp.Hlink = 0;
      if (Dp.Type < 0) {
        Dp.Type = ~Dp.Type;
        Dp.Text = 0;
        Anons--;
        if (Anons == 0 && Dlim <= Mitetype + 2) {
          Dp.Hlink = Ranges;
          Ranges = Dlim;
        }
      } else {
        Dp.Text = Ci;
        if (Charinit[Ci + 1] & 32)
          if (Deventf < Dlim && Dlim < Devent) {
            *Head = Dlim;
            Head = &Dp.Hlink;
          } else {
            Sethashhead(*String(Addr(Charinit[Ci])));
            Dp.Hlink = *Head;
            *Head = Dlim;
            if (Dlim == Deventf) Head = &Dp.Link;
          }
        Len = Charinit[Ci];
        do {
          Putchar();
          Len--;
        } while (Len >= 0);
        Len = Charinit[Ci] - 128;
        while (Len >= 0) {
          Putchar();
          Len--;
        }
        Anons = 2;
      }
    }
    for (I = 0; I <= 255; I++) Hashindex[I] = 0;
    *Byteinteger(Char0) = 0;
    Charlim = Char0 + 1;
    Charmin = Charlim + Charbound;
    Ranges = 0;
    Ci = 1;
    Anons = 100;
    Dict[0] = 0;
    Dlim = D0;
    do {
      Dp = &Dict[Dlim];
      if (Dlim <= Prea7) {
        *Dp = 0;
        Dp->Flags = Okflag + Writable + Readable;
        Dp->Mode = Dlim - D0;
        Dp->Type = Inttype;
        if (Dlim <= A7) Textset(*Dp);
      } else {
        Dp->Details = *Record(Addr(Dictinit[Dlim * 6]));
        Textset(*Dp);
      }
      Dlim++;
      if ((Control & Permbit) != 0 && Dlim >= Signal) break;
    } while (Dlim <= Premax);
    Dictshown = Dlim;
    I = Dictlim;
    do {
      Dp = &Dict[I];
      *Dp = 0;
      Dp->Mode = Labmode;
      I++;
    } while (I != Np0);
  }
  int Explo;
  int Oldexplo;
  int Np;
  int Startnp;
  static const int Move = 1;
  static const int Add = 2;
  static const int Sub = 3;
  static const int Cmp = 4;
  static const int And = 5;
  static const int Or = 6;
  static const int Eor = 7;
  static const int Not = 8;
  static const int Neg = 9;
  static const int Lsl = 10;
  static const int Lsr = 11;
  static const int Muls = 12;
  static const int Divs = 13;
  static const int Mulu = 14;
  static const int Divu = 15;
  static const int Bra = 16;
  static const int Bsr = 17;
  static const int Bcc = 20;
  static const int Bcs = 21;
  static const int Bne = 22;
  static const int Beq = 23;
  static const int Bvc = 24;
  static const int Bvs = 25;
  static const int Bge = 28;
  static const int Blt = 29;
  static const int Bgt = 30;
  static const int Ble = 31;
  static const int Compare = Cmp;
  static const int Goto = Bra;
  static const int Jamass = 32;
  static const int Okass = 33;
  static const int Assign = 34;
  static const int Incass = 35;
  static const int Forass = 36;
  static const int Stop = 37;
  static const int Return = 38;
  static const int Repeat = 39;
  static const int Else = 40;
  static const int Jumpout = 41;
  static const int Settrap = 42;
  static const int Swgoto = 43;
  static const int Label = 44;
  static const int Recref = 45;
  static const int Prel = 46;
  static const int Storemap = 47;
  static const int Iabs = 48;
  static const int Fabs = 49;
  static const int End = 50;
  int Starts;
  int Cycles;
  int Curlab;
  int Pendout;
  int Pendcond;
  int Pendin;
  int Polarity;
  int Condop;
  static short Extspecs = 0;
  static short Externs = 0;
  typedef struct Contentinfo {
    short Ccx;
    short Ccy;
    short Line;
    short Content[16 /*1:16*/];
  } Contentinfo;
  typedef struct Blockinf {
    int Sp;
    int Stack;
    int Extra;
    int Totstack;
    int Free;
    int Status;
    int Type;
    int Localdpos;
    int Parlim;
    int Localtext;
    int Localad;
    int Vintage;
    int Localpc;
    int Localswpc;
    int Pid;
    int Access;
    int Forward;
    int Lab1;
    int Looplab;
    int Eventsp;
    int Faults;
    int Return;
    int Shorts;
    int Temps;
    int Dynarray;
    int Oldcontrol;
    int Mode;
    int Val;
    Identinfo *Dpid;
    Contentinfo Reg;
  } Blockinf;
  static const int Unknown = 0x0002;
  static const int Wrongcc = 0x0004;
  static const int Onstack = 0x0008;
  static const int Globbed = 0x0010;
  static const int Labglobbed = 0x0020;
  static const int Hadspec = 0x0040;
  static const int Hadswitch = 0x0080;
  static const int Hadon = 0x1000;
  static const int Hadordererr = 0x2000;
  static const int Hadinst = 0x4000;
  static const int Outerlevel = 0;
  static const int Maxlevel = 7;
  int Level;
  int Vintage;
  Blockinf C;
  Blockinf Hold[7 /*0:6*/];
  Contentinfo Lreg[43 /*0:42*/];
  static const int Progbound = 16383;
  short Prog[16384 /*0:16383*/];
  unsigned char Pflag[16384 /*0:16383*/];
  static const int Shortjump = 1;
  static const int Jump = 2;
  static const int Longjump = 3;
  static const int Global = 4;
  static const int Indglobal = 7;
  static const int Zeroshorts = 8;
  int Pc;
  int Swpc;
  unsigned char Final[Finalbound + 1];
  int Cad;
  int Ownad;
  int Jokerad;
  int Ownbase;
  int Final0;
  int Accounted;
  int Firstentry;
  int Firstpos;
  static int Type = 0;
  static int Value = 0;
  Identinfo *Ditem;
  int Speccing;
  int Dump;
  static int Atom = 0;
  int Matched;
  int Sym;
  int Line;
  static int Codeflag = ' ';
  int Listflag;
  int Linestart;
  int Fp;
  int Atomp;
  int Expp;
  int Isshort(int V) {
    if (-32768 <= V && V <= 32767) return (True);
    return (False);
  }
  int Ismite(int V) {
    if (-128 <= V && V <= 127) return (True);
    return (False);
  }
  int Mite(int V) {
    V = V & 255;
    if (V & 128) V -= 256;
    return (V);
  }
  Identinfo *Typecell(int T) { return (&Dict[T]); }
  int Category(int T) { return (Dict[T].Flags & (Packed + Cat)); }
  int Litval(int V) {
    if (!V) return (V);
    if (V > Litmax) {
      if (!(V & 1)) return ((unsigned)(-V) >> 1);
      return (~((unsigned)(-V) >> 1));
    }
    return (Litstore[V]);
  }
  int Faults;
  int Others;
  int Faultnum;
  int Faultp;
  int Statements;
  int Comments;
  int Atoms;
  int Identatoms;
  int Litatoms;
  int Zaps;
  int Steps;
  int Jumps;
  int Shorts;
  _imp_string Rep;
  void Printline(void) {
    Printstring(Rep);
    Printsymbol(Nl);
    Rep = _imp_str_literal("");
  }
  void Putsym(int K) { Rep = _imp_join(Rep, Tostring(K)); }
  void Putstring(_imp_string S) { Rep = _imp_join(Rep, S); }
  void Putnum(int Val) {
    void Pd(int V) {
      if (V <= -10) {
        Pd(V / 10);
        V -= V / 10 * 10;
      }
      Putsym('0' - V);
    }
    if (Val < 0) {
      Putsym('-');
      Pd(Val);
    } else
      Pd(-Val);
  }
  void Putident(int P, int Mode) {
    Identinfo *Dp;
    do {
      if (*Length(Rep) > 50) Printline();
      if (_imp_strcmp(Rep, _imp_str_literal("")) == 0) Spaces(6);
      Dp = &Dict[P];
      if (Mode) {
        Putsym(' ');
        Putsym('"');
      }
      if (Dp->Text > 0)
        Putstring(*String(Char0 + Dp->Text));
      else if (Dp->Text < 0)
        Putnum(~Dp->Text);
      else
        Putnum(P);
      if (Mode) Putsym('"');
      if (Mode <= 0) return;
      P = Dp->Hlink;
    } while (P);
  }
  void Spaces(int N) {
    while (N > 0) {
      Putsym(' ');
      N--;
    }
  }
  void Putspnum(int Val) {
    if (Val >= 0) Putsym(' ');
    Putnum(Val);
  }
  static const unsigned char Hexsym[16 /*0:15*/] = {'0', '1', '2', '3', '4', '5', '6', '7',
                                                    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  void Puthex(int Val) {
    int I;
    for (I = 12; I >= 0; I -= 4) Putsym(Hexsym[(unsigned)Val >> I & 15]);
  }
  void Putoperand(int V) {
    int I;
    void Interpret(int Mode) {
      static int S_sw;
      static void *S[8 /*0:7*/] = {
          &&S_0, &&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7,
      };
      goto *S[S_sw = (unsigned)Mode >> 3 & 7];
    S_0:;
      Putsym('D');
    Putrno:;
      Putsym((Mode & 7) + '0');
      return;
    S_1:;
      if (Mode >= Framemode - Dispmode)
        Putsym('F');
      else
        Putsym('A');
      goto Putrno;
    S_4:;
      Putsym('-');
    S_2:;
    Ind:;
      Putsym('(');
      Interpret((Mode & 0b11000111) + Aregmode);
      Putsym(')');
      return;
    S_3:;
      Interpret(Mode - 8);
      Putsym('+');
      return;
    S_5:;
      Putnum(I);
      goto Ind;
    S_6:;
      Putnum(Mite(I));
      Putsym('(');
      Interpret(Mode + (Aregmode - Indexmode));
      Putsym(',');
      Interpret((unsigned)I >> 12 & 15);
      Putsym('.');
      if (!(I & 0x800))
        Putsym('W');
      else
        Putsym('L');
      Putsym(')');
      return;
    S_7:;
      if ((Mode & 63) == Pcmode) {
        if (Mode == Pcmode) Putnum(I);
        Putstring(_imp_str_literal("(PC)"));
        return;
      }
      if (Mode <= Absmode + 1) {
        Putsym('$');
        if (Mode == Absmode + 1 || Isshort(I) != True) Puthex((unsigned)I >> 16);
      } else {
        Putsym(Hexsym[(unsigned)Mode >> 4 & 3]);
        Putsym(Hexsym[Mode & 15]);
        Putsym('_');
      }
      Puthex(I);
    }
    if (V <= 0) {
      V = Litval(V);
      Putsym('#');
      if (Ismite(V) == True)
        Putnum(V);
      else {
        Putsym('$');
        if ((unsigned)V >> 16) Puthex((unsigned)V >> 16);
        Puthex(V & 0xFFFF);
      }
    } else if (V <= Prea7)
      Interpret(V - D0);
    else if (V < Dictlim)
      Putident(V, 0);
    else if (V < Lablim) {
      Putsym('L');
      Putnum(V - Dictlim);
    } else {
      I = Dict[V].Val;
      Interpret(Dict[V].Mode);
    }
  }
  void Markat(int Col) {
    while (*Length(Rep) < Col) Putsym(' ');
    Putsym('|');
  }
  void Showdict(int From) {
    int I;
    Identinfo D;
    static const unsigned char Flagsym[16 /*0:15*/] = {'W', 'R', 'V', 'A', 'w', 'r', 'o', 'm',
                                                       'S', 'T', 'K', '?', 'P', 'p', 'E', '*'};
    static const unsigned char Catsym[16 /*0:15*/] = {'I', 'C', 'B', 'E', '@', 'X', '?', '?',
                                                      'S', 'A', 'Z', '?', 'R', 'F', '?', '?'};
    if (From >= Dlim) return;
    if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline();
    *Byteinteger(Charlim) = 0;
    Spaces(6);
    Putstring(_imp_str_literal("___identifier____flags___type__link__par_mode___value____"));
    Printline();
    do {
      Putspnum(From);
      Markat(6);
      D = Dict[From];
      Putsym(' ');
      Putident(From, 0);
      if (D.Text > 0) {
        I = Char0 + D.Text;
        I = I + *Byteinteger(I) + 1;
        if (*Byteinteger(I) & 128) {
          *Byteinteger(I) = *Byteinteger(I) - 128;
          Putsym(':');
          Putstring(*String(I));
          *Byteinteger(I) = *Byteinteger(I) + 128;
        }
      }
      Markat(22);
      if (D.Flags & Typeid) {
        Putsym(Catsym[D.Flags & Cat]);
        I = 4;
      } else {
        Putsym(' ');
        I = 0;
      }
      do {
        if ((unsigned)D.Flags >> I & 1) Putsym(Flagsym[I]);
        I++;
      } while (I <= 15);
      Markat(30);
      Putspnum(D.Type);
      Markat(35);
      Putspnum(D.Link);
      Markat(42);
      Putspnum(D.Reg);
      Markat(46);
      Putspnum(D.Mode);
      Markat(51);
      Putspnum(D.Val);
      Markat(63);
      Printline();
      From++;
    } while (From != Dlim);
    Spaces(6);
    Putstring(_imp_str_literal("+-------------------------------------------------------+"));
    Printline();
  }
  void Putmnemonic(int M) {
    M = M << 2;
    do {
      Putsym(((unsigned)M >> 27) + 'A' - 1);
      M = M << 5;
    } while (M);
  }
  auto void Putopcode(int Op);
  void Showexp(int Startp) {
    int P;
    int Q;
    Identinfo *Dp;
    static const int Bopmax = 51;
    static const int Extra[20 /*32:51*/] = {-736721293, -558838176, -1019632402, -756971917, -856095117,
                                            -414728192, -463841714, -463989708,  -892759040, -880488448,
                                            -383729664, -411844977, -669969024,  -464402266, -517820416,
                                            -414632912, -770618368, -871281664,  -891158528, -655110494};
    void Putoprand(int V) {
      if (V >= Explim) {
        Putsym('#');
        V -= Ad;
      }
      if (V < Np0)
        Putoperand(V);
      else
        Putnum(V);
    }
    if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline();
    if (Np <= Np0) return;
    Putstring(_imp_str_literal("      ______action_______first_______second____"));
    Printline();
    P = Np0;
    do {
      if (P == Np) {
        P = Explo;
        if (P >= Oldexplo) break;
        Putstring(_imp_str_literal("      |---------------------------------------|"));
        Printline();
      }
      if (P == Startp)
        Putsym('>');
      else
        Putsym(' ');
      Putnum(P);
      Markat(6);
      Dp = &Dict[P];
      Putsym(' ');
      Q = Dp->Act;
      if (Q <= 31)
        Putopcode(Q);
      else if (Q <= Bopmax)
        Putmnemonic(Extra[Q]);
      else
        Putident(Q, 0);
      Markat(22);
      Putsym(' ');
      Putoprand(Dp->X);
      Markat(34);
      Putsym(' ');
      Putoprand(Dp->Y);
      Markat(46);
      if (P >= Explo) {
        Putspnum(Dp->Type);
        if (Dp->Flags < 0) Putsym('*');
      }
      Printline();
      P++;
    } while (P < Oldexplo);
    Oldexplo = Explo;
    Putstring(_imp_str_literal("      +---------------------------------------+"));
    Printline();
  }
  void Croak(_imp_string S) {
    Selectoutput(0);
    Putstring(_imp_str_literal("** "));
    Putstring(S);
    Putstring(_imp_str_literal(".  Compilation abandoned at line "));
    Putnum(Line);
    Printline();
    _imp_signal(14, 0, 0, _imp_str_literal(""));
  }
  static const int Internerr = 1;
  static const int Plexerr = 2;
  static const int Creacherr = 3;
  static const int Reacherr = 4;
  static const int Noresult = 5;
  static const int Dreacherr = 6;
  static const int Formerr = 7;
  static const int Atomerr = 8;
  static const int Namerr = 9;
  static const int Classerr = 10;
  static const int Sizerr = 11;
  static const int Typerr = 12;
  static const int Boundserr = 13;
  static const int Unending = 14;
  static const int Lowlevel = 15;
  static const int Accesserr = 16;
  static const int Notinloop = 17;
  static const int Notinrout = 18;
  static const int Notinfun = 19;
  static const int Notinpred = 20;
  static const int Duperr = 21;
  static const int Ordererr = 22;
  static const int Matcherr = 23;
  static const int Rangerr = 24;
  static const int Nonliteral = 25;
  static const int Moperr = 26;
  static const int Nocycle = 27;
  static const int Nostart = 28;
  static const int Noif = 29;
  static const int Illstarred = 30;
  static const int Nonstarter = 31;
  static const int Nonvar = 32;
  static const int Nonref = 33;
  static const int Toofew = 34;
  static const int Toomany = 35;
  static const int Nobegin = 36;
  static const int Dubious = 37;
  static const int Notinblock = 38;
  static const int Nonstand = 39;
  static const int Notin = 40;
  static const int Asserr = 41;
  static const int Noend = 42;
  static const int Nofinish = 43;
  static const int Norepeat = 44;
  static const int Counterr = 45;
  static const int Slabmissing = 46;
  static const int Idmissing = 47;
  static const int Point = 64;
  static const int Warn = -128;
  static const int Now = 128;
  void Report(int N, int Id, int Num) {
    static int Lastchange = 0;
    int Mark;
    int Start;
    int Errline;
    void Printtext(int Stream) {
      static const int Esc = 27;
      int K;
      int P;
      static const _imp_string Message[44 /*1:44*/] = {
          _imp_str_literal("Internal error "), _imp_str_literal("Reg not free"),   _imp_str_literal("Out of reach "),
          _imp_str_literal(" out of reach!"),  _imp_str_literal("RESULT missing"), _imp_str_literal("Out of reach"),
          _imp_str_literal("Faulty form"),     _imp_str_literal("Unknown atom"),   _imp_str_literal("Unknown name"),
          _imp_str_literal("Wrong class"),     _imp_str_literal("Wrong size"),     _imp_str_literal("Wrong type"),
          _imp_str_literal("Inside out"),      _imp_str_literal("Endless loop"),   _imp_str_literal("Low level"),
          _imp_str_literal("Not accessible"),  _imp_str_literal("Not in loop"),    _imp_str_literal("Not in routine"),
          _imp_str_literal("Not in fn/map"),   _imp_str_literal("Not in pred"),    _imp_str_literal("Duplicate"),
          _imp_str_literal("Out of order"),    _imp_str_literal("Mismatch"),       _imp_str_literal("Out of range"),
          _imp_str_literal("Not literal"),     _imp_str_literal("Faulty operand"), _imp_str_literal("%CYCLE missing"),
          _imp_str_literal("%START missing"),  _imp_str_literal("Extra %ELSE"),    _imp_str_literal("Ill-starred"),
          _imp_str_literal("Non-starter"),     _imp_str_literal("Not variable"),   _imp_str_literal("Not reference"),
          _imp_str_literal("Too few args"),    _imp_str_literal("Too many args"),  _imp_str_literal("%BEGIN missing"),
          _imp_str_literal("Dubious usage"),   _imp_str_literal("Not in block"),   _imp_str_literal("Nonstandard "),
          _imp_str_literal("Not supported"),   _imp_str_literal(" void"),          _imp_str_literal("%END missing"),
          _imp_str_literal("%FINISH missing"), _imp_str_literal("%REPEAT missing")};
      Putsym(Mark);
      if (Errline < 1000) Putsym(' ');
      if (Errline < 100) Putsym(' ');
      if (Errline < 10) Putsym(' ');
      Putnum(Errline);
      Putsym(Listflag);
      Putsym(' ');
      K = N & 63;
      if (K >= Counterr) {
        if (K == Counterr) {
          if (Num < 0) {
            Putnum(-Num);
            Putstring(_imp_str_literal(" extra"));
          } else {
            if (Num) Putnum(Num);
            Putstring(_imp_str_literal(" missing"));
          }
          Putstring(_imp_str_literal(" value(s) for "));
          Putident(Id, 0);
          return;
        }
        if (K != Slabmissing)
          Putident(Id, 1);
        else {
          Putident(Id, 0);
          Putsym('(');
          Putnum(Num);
          Putsym(')');
        }
        Putstring(_imp_str_literal(" missing"));
      Mend:;
        if (C.Dpid) {
          Putstring(_imp_str_literal(" in "));
          Putident(C.Pid, -1);
        }
        return;
      }
      if (Id > 0) Putident(Id, 0);
      Putstring(Message[K]);
      if (Num > 0) Putnum(Num);
      if (Creacherr <= K && K <= Noresult) goto Mend;
      Spaces(22 - *Length(Rep));
      P = Start;
      while (*Byteinteger(P) == ' ') P++;
      if (P < Faultp - 50) {
        P = Faultp - 47;
        Putstring(_imp_str_literal("..."));
      } else
        Putsym(' ');
      for (;;) {
        K = *Byteinteger(P);
        P++;
        if (P == Faultp) Putsym('|');
        if (K == Nl) break;
        Putsym(K);
      }
      return;
    }
    Mark = '?';
    if (N > 0) {
      Mark = '*';
      C.Faults = C.Faults + 1;
      Faults++;
    }
    Faultnum = 0;
    C.Access = -1;
    if (File[Main].Start1 <= Fp && Fp < Lastchange) return;
    Start = Linestart;
    Errline = Line;
    if (!(N & Point)) {
      Faultp = 0;
    } else {
      while (Start >= Faultp) {
        Start--;
        if (*Byteinteger(Start) == Nl) Errline--;
      }
      while (Start != Curstart && *Byteinteger(Start - 1) != Nl) Start--;
    }
    Time1 -= Cputime;
    if (Listout) {
      Printtext(Listout);
      Printline();
    }
    Selectoutput(0);
    if (Curfile != Lastfile) {
      Lastfile = Curfile;
      Putstring(Cur->Name);
      Printline();
    }
    Printtext(0);
    if (N > Reacherr && Curfile == Main && (Control & Editbit) != 0) {
      if (Faultp > Start) Start = Faultp - 1;
      Cur->Fp = Start;
      Cur->Line = Line;
      if (Lastchange) Cur->Change = 0x7FFFFFFE;
      Selectinput(0);
      File[Main + 1] = 0;
      Rep = _imp_str_literal("");
      Selectoutput(Listout);
      Time1 += Cputime;
      if (Cur->Flag < 0) _imp_signal(14, 0, 0, _imp_str_literal(""));
      if (Cur->Flag == 'I') Control = Control & (~Editbit);
      if (Cur->Change < 0x7FFFFFFE) {
        Lastchange = Cur->Change;
        _imp_signal(13, 0, 0, _imp_str_literal(""));
      }
    } else {
      Printline();
      Selectoutput(Listout);
      Time1 += Cputime;
    }
  }
  void Fault(int N) {
    if (Faultnum == 0 || (N > 0 && Faultnum < 0)) {
      Faultnum = N;
      Faultp = Atomp;
      if (Faultnum >= Now) Report(Faultnum & 127, 0, 0);
    }
  }
  void Intern(int N) { Report(Internerr, 0, N); }
  int Litref(int V) {
    int I;
    if (!V) return (V);
    if (V > 0) {
      if (V <= Smallmax) return (-(V << 1));
    } else if (V >= Smallmin)
      return ((V << 1) + 1);
    Litstore[Litpos] = V;
    I = Litmin - 1;
    do
      I++;
    while (Litstore[I] != V);
    if (I == Litpos) {
      Litpos++;
      if (Litpos >= Litmax) Croak(_imp_str_literal("Too many literals"));
    }
    return (I);
  }
  void Putexp(int Act, int X, int Y, int T) {
    Type = T;
    Item = Explim;
    if (Explo <= X && X < Item) Item = X;
    if (Explo <= Y && Y < Item) Item = Y;
    do {
      Item--;
      Ditem = &Dict[Item];
      if (Item < Explo) {
        Explo = Item;
        Ditem->Act = Act;
        Ditem->X = X;
        Ditem->Y = Y;
        Ditem->Flags = 0;
        Ditem->Type = T;
        Ditem->Mode = 0;
        break;
      }
    } while (Ditem->Act != Act || Ditem->X != X || Ditem->Y != Y);
  }
  void Putexp2(int Op, int First, int T) {
    if (!Item) Item = Litref(Value);
    Putexp(Op, First, Item, T);
  }
  int Normitem(void) {
    if (Item) return (Item);
    return (Litref(Value));
  }
  void Toreal(void) {
    if (Item)
      Putexp(Float, Item, 0, Realtype);
    else {
      *Real(Addr(Value)) = Value;
      Type = Realtype;
    }
  }
  int Temp(int M, int V) {
    Dtemp->Mode = M;
    Dtemp->Val = V;
    return (Lablim);
  }
  int Tempx(int R1, int R2) {
    Dtemp->Mode = R1 + (Indexmode - A0);
    Dtemp->Val = ((R2 - D0) << 12) + 0x0800;
    return (Lablim);
  }
  int Tempd(int A, int Disp) {
    Dtemp->Mode = A + (Dispmode - A0);
    Dtemp->Val = Disp;
    return (Lablim);
  }
  int Tempx2(int R1, int R2) {
    Dtemp2->Mode = R1 + (Indexmode - A0);
    Dtemp2->Val = ((R2 - D0) << 12) + 0x0800;
    return (Lablim + 1);
  }
  static const int Lea = 78;
  static const int Pea = 55;
  static const int Clr = 52;
  static const int Dbra = 81;
  static const int Jsr = 56;
  static const int Link = 72;
  static const int Unlk = 73;
  static const int Rts = 68;
  static const int Movem = 100;
  static const int Trapi = 101;
  static const int Dc = 102;
  static const int Shift = 32;
  static const int Reg = 1;
  static const int Areg = 2;
  static const int Ireg = 3;
  static const int Quick = 4;
  static const int Mquick = 5;
  static const int Ea = 6;
  static const int Rwea = 7;
  static const int Wea = 8;
  static const int Imm = 9;
  static const int Tquick = 10;
  static const int Rel = 11;
  static const int Longrel = 12;
  static const int Qreg = 13;
  static const int Postareg = 14;
  static const int Qea = 15;
  static const int Revea = 16;
  static const int Ximm = 17;
  static const int Data = 18;
  static const int Preareg = 19;
  static const int Qpre = 20;
  static const int Exreg = 21 + Shift;
  static const int Reg9 = Reg + Shift;
  static const int Qreg9 = Qreg + Shift;
  static const int Ireg9 = Ireg + Shift;
  static const int Postareg9 = Postareg + Shift;
  static const int Quick9 = Quick + Shift;
  static const int Areg9 = Areg + Shift;
  static const int Sized = 1 << 15;
  static const int Asized = 1 << 14;
  static const int Reversible = (Revea << 6) + Reg9 + Sized;
  static const int Multiple = (Ximm << 6) + Ea + Asized;
  static const int Defmax = 129;
  static const int Def[259 /*0:258*/] = {
      0,           33192,       -621079552,  -805272543,  -1035862016, -1879014367, -414121984,  -1342144095,
      -958922752,  -1073707999, -1025376256, -2147449823, -551550976,  -1325365177, -889651200,  1174437895,
      -587595776,  1140883463,  -598507520,  -519533759,  -650772480,  -536310975,  -650575872,  -1044381279,
      -615101440,  -2118123103, -929346560,  -1061158495, -615099392,  -2134900319, -929344512,  1610612747,
      -987725824,  1627389963,  -986120192,  1644167179,  -997949440,  1660944395,  -993427456,  1677721611,
      -1003388928, 1694498827,  -1002864640, 1711276043,  -991789056,  1728053259,  -1000833024, 1744830475,
      -983465984,  1761607691,  -982941696,  1778384907,  -989462528,  1795162123,  -992706560,  1811939339,
      -999129088,  1828716555,  -993394688,  1845493771,  -998637568,  1862270987,  -993886208,  -520058047,
      -1019871232, -536835263,  -1019674624, -518485183,  -453640192,  -535262399,  -453443584,  1879048545,
      -621079008,  1342212359,  -1035844608, 1358989575,  -414104576,  809517474,   -621079520,  -792706654,
      -1035860992, -1866448478, -414120960,  -1329577566, -958921728,  -1324874834, -958909440,  100696647,
      -1035852800, 67142215,    -414112768,  201359942,   -958913536,  33587783,    -1025367040, 33351,
      -551256064,  167805511,   -889641984,  -519009471,  -453234688,  -535786687,  -453228544,  1107329032,
      -959905792,  1073774599,  -598482944,  1207959559,  -601780224,  1212153862,  -531595264,  1317011462,
      -717684736,  1321205766,  -724041728,  1254096903,  -400982016,  1241546758,  -382074880,  -1056963295,
      -1037987840, -2130705119, -434008064,  -788495071,  -1035837440, -1862236895, -414097408,  1316028416,
      -587726848,  1315962880,  -463890816,  1316159488,  -448626688,  1316421632,  -448200704,  1316290560,
      -448167936,  1316093961,  -414728192,  1316356096,  -383728960,  1312817162,  -383729664,  1313866306,
      -661181440,  1314390018,  -354014208,  1212153857,  -412041216,  1216348161,  -880124928,  1220542465,
      -880136192,  -1052766911, -880574464,  1103102946,  -665812992,  1098908065,  -964329472,  1355284556,
      -936615936,  1372061772,  -936836096,  1388838988,  -937155584,  1405616204,  -937014272,  1422393420,
      -937325568,  1439170636,  -937309184,  1455947852,  -936963072,  1472725068,  -937245696,  1489502284,
      -936702976,  1506279500,  -936686592,  1523056716,  -936890368,  1539833932,  -936991744,  1556611148,
      -937192448,  1573388364,  -937013248,  1590165580,  -937177088,  1606942796,  -937028608,  20973767,
      -1003217920, 25168072,    -1003075584, 29362376,    -986525696,  16779462,    -985018368,  1216365638,
      -621079136,  1312817738,  -383729376,  18,          -936378368,  1354760200,  -415236096,  1371537416,
      -429916160,  1388314632,  -427524096,  1405091848,  -423002112,  1421869064,  -432963584,  1438646280,
      -432439296,  1455423496,  -421363712,  1472200712,  -430407680,  1488977928,  -413040640,  1505755144,
      -412516352,  1522532360,  -419037184,  1539309576,  -422281216,  1556086792,  -428703744,  1572864008,
      -422969344,  1589641224,  -428212224,  1606418440,  -423460864,  1153433984,  -616460736,  1186988416,
      -615921664,  1086324744,  -630601728,  1314914306,  -615854592,  1315438594,  -630534656,  37486601,
      -1019113920, 41680905,    -1018574848, 171704329,   -884896192,  175898633,   -884357120,  3932169,
      -549351872,  8126473,     -548812800};
  void Putopcode(int Op) { Putmnemonic(Def[Op + Op]); }
  void Store(int V, int F) {
    Prog[Pc] = V;
    Pflag[Pc] = F;
    Pc++;
  }
  void Makeroom(int Size) {
    int Newbase;
    int Newlim;
    Size = (Size + 127) & (~127);
    Ownbase -= Size;
    if (Ownbase <= Cad) Croak(_imp_str_literal("Program too big"));
    Newbase = Ownbase;
    Newlim = Newbase + Ownad;
    do {
      Final[Newbase] = Final[Newbase + Size];
      Newbase++;
    } while (Newbase < Newlim);
  }
  void Fillcode(int N) {
    int I;
    I = Cad;
    Cad += N;
    while (N > 0) {
      Final[I] = 0x80;
      I++;
      N--;
    }
  }
  void Fillown(int N) {
    int I;
    Makeroom(N);
    I = Ownbase + Ownad;
    Ownad += N;
    while (N > 0) {
      Final[I] = 0x80;
      I++;
      N--;
    }
  }
  void Setcodeword(int V) {
    Shortinteger = V;
    Cad += 2;
  }
  int Codeword(int Cad) { return (Shortinteger); }
  void Setcodelongword(int V) {
    Setcodeword((unsigned)V >> 16);
    Setcodeword(V);
  }
  void Setownword(int V) {
    if (Ownbase + Ownad > Finalbound) Makeroom(2);
    Shortinteger = V;
    Ownad += 2;
  }
  void Extendstack(int Delta) {
    C.Sp = C.Sp - Delta;
    if (C.Sp < C.Stack) {
      C.Stack = C.Sp;
      if (C.Stack < C.Totstack) C.Totstack = C.Stack;
    }
  }
  void Plant(int Op, int Y, int X) {
    int Opcode;
    int Pc1;
    int I;
    int F;
    int Extword;
    int Info;
    int Kind;
    int Mode;
    int Modex;
    int Size;
    Identinfo *Dx;
    Identinfo *Dy;
    static int S_sw;
    static void *S[22 /*0:21*/] = {
        &&S_0,  &&S_1,  &&S_2,  &&S_3,  &&S_4,  &&S_5,  &&S_6,  &&S_7,  &&S_8,  &&S_9,  &&S_10,
        &&S_11, &&S_12, &&S_13, &&S_14, &&S_15, &&S_16, &&S_17, &&S_18, &&S_19, &&S_20, &&S_21,
    };
    static const unsigned char Sizesym[4 /*0:3*/] = {'L', 'B', 'W', '?'};
    int Nonlocal(int L) {
      int R;
      if (!L) return (Mb);
      if (L != Level) Hold[L].Status = Hold[L].Status | Globbed;
      if (L == Outerlevel + 1) return (F1);
      R = Maxareg;
      do {
        if (C.Reg.Content == D7 + L) return (R);
        R--;
      } while (R >= A0);
      R = Maxareg;
      while (!(A0b << (R - A0) & Free)) {
        if (R == A0) {
          Fault(Plexerr);
          break;
        }
        R--;
      }
      C.Reg.Content = D7 + L;
      Dtsprel->Mode = Globalmode;
      Dtsprel->Val = L << 2;
      Plant(Move, Lablim + 2, R);
      return (R);
    }
    static const int Moveq = 36;
    static const int Addq = 37;
    static const int Movea = 39;
    static const int Adda = 40;
    static const int Addi = 44;
    if (X > 0) {
      if (X >= Explim) {
        Intern(1);
        return;
      }
      Dx = &Dict[X];
      Modex = Dx->Mode;
      if (Modex >= Framemode && Modex != C.Mode && (Modex & 0b111000) != 0b111000)
        Modex = Nonlocal(Modex & 7) - A0 + (Modex & (7 << 3));
    } else {
      Modex = Litmode;
      Dx = Dint;
    }
    if (Y > 0) {
      if (Y >= Explim) {
        Intern(1);
        return;
      }
      Dy = &Dict[Y];
      Mode = Dy->Mode;
      if (Mode >= Framemode && Mode != C.Mode && (Mode & 0b111000) != 0b111000)
        Mode = Nonlocal(Mode & 7) - A0 + (Mode & (7 << 3));
    } else {
      Mode = Litmode;
      Dy = Dint;
    }
    Size = (unsigned)Op >> 8;
    Op = Op & 255;
    if (Op == Move)
      if (!(Modex & 0b111000)) {
        if (Y <= 0 && Y >= Litmite && (Size & 3) == 0) Op = Moveq;
      } else if (!(Modex & 0b110000))
        Op = Movea;
      else if (Op <= Cmp)
        if (Op < Cmp && Y < 0 && Y >= Litquick && (Y & 1) == 0)
          Op += Addq - Add;
        else if ((Modex & 0b111000) == Aregmode)
          Op += Adda - Add;
        else if (Y <= 0)
          Op += Addi - Add;
        else if (Op <= Eor)
          if (Y <= 0) Op += Addi - Add;
    Info = Def[Op + Op - 1];
    Opcode = (unsigned)Info >> 16;
    if (Info & Sized) {
      if (!Size) Size = 4;
      if (Op == Move)
        if (Size == 4)
          Opcode += 0x2000;
        else if (Size == 2)
          Opcode += 0x3000;
        else
          Opcode += 0x1000;
      else if (Size == 4)
        Opcode += 0x80;
      else if (Size == 2)
        Opcode += 0x40;
    } else if (Info & Asized) {
      if (Size == 1) Fault(Sizerr);
      if (Op != Movem) {
        if (!Size)
          if (Y > 0 || Isshort(Litval(Y)) != True) Size = 4;
        if (Size == 4)
          if (Op == Movea)
            Opcode = Opcode ^ 0x1000;
          else
            Opcode += 0x0100;
      } else {
        if (!Size) Size = 4;
        if (Size == 4) Opcode += 0x0040;
      }
    }
    if ((Control & Codelist) != 0 && (Control & List) != 0) {
      if (*Length(Rep) >= 4) Printline();
      Putsym(Codeflag);
      Spaces(4 - *Length(Rep));
      Putopcode(Op);
      if (Size) {
        Putsym('.');
        Putsym(Sizesym[Size & 3]);
      }
      Spaces(12 - *Length(Rep));
      if (Info & (63 << 6)) {
        Putoperand(Y);
        if (Info & 63) Putsym(',');
      }
      if (Info & 63) Putoperand(X);
      Spaces(33 - *Length(Rep));
      Putsym(':');
    }
    Pc1 = Pc;
    Pflag[Pc1] = C.Shorts;
    Pc++;
    if (Pc >= Swpc - 8) Croak(_imp_str_literal("Code space exhausted"));
    Kind = (unsigned)Info >> 6;
  Again:;
    goto *S[S_sw = Kind & 31];
  S_0:;
  Next:;
    Kind = Info;
    if (Kind) {
      Dy = Dx;
      Y = X;
      Mode = Modex;
      Info = 0;
      goto Again;
    }
    Prog[Pc1] = Opcode;
    if ((Control & Codelist) != 0 && (Control & List) != 0) {
      do {
        Putsym(' ');
        Puthex(Prog[Pc1]);
        Pc1++;
      } while (Pc1 < Pc);
      Printline();
    }
    return;
    void Pcrel(int Shorten) {
      if (Dy->Mode == Labmode) {
        F = Jump;
        if (!Shorten) F = Longjump;
        if (Extword > 0) {
          if (Shorten != 0 && (Extword - Pflag[Extword] - Pc + C.Shorts) << 1 >= -128)
            if (C.Shorts == 255)
              Zaps += 100;
            else {
              Shorts++;
              C.Shorts = C.Shorts + 1;
              F = Shortjump;
            }
        } else {
          Extword = -Extword;
          Dy->Val = -Pc;
        }
      } else if (Dy->Mode == Procmode) {
        F = Indglobal;
        Extword = Y;
      } else if (Dy->Mode == Constmode) {
        F = Global;
        if (Extword < 0) F++;
        if (Extword > 65535) F += 2;
      } else if (Dy->Mode != Pcmode)
        Fault(Moperr);
    }
  S_15:;
    if ((Mode & 63) != X - (A0 - Indexmode) || (Dy->Val & 255) != 0) goto Ea0;
    Opcode = 0xD1C0 + ((unsigned)Dy->Val >> 12 & 15);
    goto Next;
  S_8:;
    Dy->Flags = Dy->Flags | (Mflag | Wflag);
    goto Wea1;
  S_7:;
    Dy->Flags = Dy->Flags | Mflag;
  Wea1:;
    if (Y <= 0 || (Mode & 63) >= Pcmode) goto Err;
    goto Ea1;
  S_16:;
    if (Modex & 0b111000) {
      Kind = Shift;
      Info = Rwea;
      Opcode = Opcode ^ 0x0100;
      goto Sreg;
    }
  S_6:
  Ea0:;
    if (Y <= 0) {
      Opcode += Litmode;
      goto Simm;
    }
    if ((Dy->Flags & (Ext + Spec + Rflag + Wflag)) == Ext + Spec && (Dy->Flags & Proc) != 0) {
      if (Ownad & 1) Fillown(1);
      Dy->Val = Ownad;
      Setownword(0x207C + ((Mb - A0) << 9));
      Setownword(0);
      Setownword(0);
      Setownword(0x4EF9);
      Setownword(0);
      Setownword(0);
    }
    if ((Op == Lea || Op == Pea) && (Mode & 63) != Pcmode) {
      Dy->Flags = Dy->Flags | (Mflag + Rflag + Wflag);
      if ((Mode & 0b111000) < Aregmode + Indir) goto Err;
    } else
      Dy->Flags = Dy->Flags | (Mflag + Rflag);
  Ea1:;
    Extword = Dy->Val;
    if (Mode == C.Mode) {
      Mode = Dispmode + 7;
      Extword -= C.Sp;
      if (Extword < 0) {
        if (Extword < -4) Intern(4);
        Mode = Aregmode + Pre + 7;
        Extendstack(-Extword);
        Extword = 0;
      }
    }
    Mode = Mode & 63;
    if (Mode >= Dispmode) {
      F = 0;
      if (Mode == Pcmode) Pcrel(0);
      if (Mode <= Dispmode + 7)
        if (!Extword) {
          if (Mode >= Dispmode) Mode += Aregmode + Indir - Dispmode;
        } else {
          if (-32768 > Extword || Extword > 32767) Fault(Dreacherr);
          Store(Extword, F);
        }
      else {
        if (Mode == Absmode && Isshort(Extword) != True) Mode = Absmode + 1;
        if (Mode == Absmode + 1) Store((unsigned)Extword >> 16, 0);
        Store(Extword, F);
      }
    }
    if (Kind & Shift) Mode = (((Mode & 7) << 3) + ((unsigned)Mode >> 3)) << 6;
    Opcode += Mode;
    goto Next;
  S_21:;
    if (!(Mode & 0b111000)) {
      if (Modex & 0b111000) {
        Opcode = Opcode ^ 0xC8;
        Info = Areg;
      }
      goto Sreg;
    }
    Opcode += 8;
    Info = Areg;
    goto Sareg;
  S_20:;
    if (!(Mode & 0b111000)) goto Sreg;
    Opcode += 8;
    Info = Preareg + Shift;
  S_19:;
    Mode += Post - Pre;
  S_14:;
    Mode -= Post;
  S_2:
  Sareg:;
    Mode -= 8;
  S_1:
  Sreg:;
    if (Mode & 0b111000) goto Err;
    Mode = Mode & 7;
    if (Kind & Shift) Mode = Mode << 9;
    Opcode += Mode;
    goto Next;
  S_13:;
    if (Y > 0) {
      Opcode += 0x20;
      goto Sreg;
    }
    if (Y == One && Size == 2 && (Modex & 0b111000) != 0) {
      Opcode = Opcode ^ 0x290;
      goto Next;
    }
  S_4:;
    if (Y >= 0) goto Err;
    Y = Litval(Y);
    if (Y > 8) goto Err;
    Opcode += (Y & 7) << 9;
    goto Next;
  S_10:;
    if (-30 > Y || (Y & 1) != 0) goto Err;
  S_5:;
    if (Y > 0 || Y < Litmite) goto Err;
    Y = Litval(Y);
    Opcode += Y & 255;
    goto Next;
  S_11:;
    if (Y <= 0 && Y >= Litmite) goto *S[S_sw = Mquick];
  S_12:;
    if (Y <= 0) goto Simm;
    Dy->Flags = Dy->Flags | Rflag;
    Extword = Dy->Val;
    F = 0;
    Pcrel(Longrel - (Kind & 31));
    Store(Extword, F);
    goto Next;
  S_3:;
    if (Y > 0) goto Sreg;
    Opcode = Opcode ^ 0x900;
  S_9:;
    if (Y > 0) goto Err;
  Simm:;
    Y = Litval(Y);
    if (Size == 4) Store((unsigned)Y >> 16, 0);
  Put:;
    Store(Y, 0);
    goto Next;
  S_17:;
    if (Y > 0) {
      Opcode = Opcode ^ 0x0400;
      I = X;
      X = Y;
      Y = I;
      Dx = Dy;
      Modex = Mode;
    }
    Y = Litval(Y);
    if (Prea0 <= X && X <= Prea7) {
      I = 0;
      for (Extword = 1; Extword <= 16; Extword++) {
        I = (I << 1) + (Y & 1);
        Y = (unsigned)Y >> 1;
      }
      Y = I;
    }
    goto Put;
  S_18:;
    if (Y <= 0) goto Err;
    if (Mode != Absmode) goto Err;
    Opcode = Dy->Val;
    goto Next;
  Err:;
    Fault(Moperr);
    goto Next;
  }
  void Plantlit(int Op, int V, int X) {
    if (V >= 0)
      if (V > Smallmax) {
        Litstore[Litmax] = V;
        V = Litmax;
      } else
        V = -(V << 1);
    else if (V < Smallmin) {
      Litstore[Litmax] = V;
      V = Litmax;
    } else
      V = (V << 1) + 1;
    Plant(Op, V, X);
  }
  void Plantlit2(int Op, int Y, int V) {
    if (V >= 0)
      if (V > Smallmax) {
        Litstore[Litmax] = V;
        V = Litmax;
      } else
        V = -(V << 1);
    else if (V < Smallmin) {
      Litstore[Litmax] = V;
      V = Litmax;
    } else
      V = (V << 1) + 1;
    Plant(Op, Y, V);
  }
  void Align(int *Ad, int Size) {
    if (Size != 1 && (*Ad & 1) != 0) *Ad = *Ad + 1;
  }
  void Addimm(int Bytes, int Dest) {
    if (Bytes <= 0) {
      if (!Bytes) return;
      if (Bytes >= -8) {
        Plantlit(Sub, -Bytes, Dest);
        return;
      }
    } else if (Bytes <= 8) {
      Plantlit(Add, Bytes, Dest);
      return;
    }
    if (A0 <= Dest && Dest <= A7 && Isshort(Bytes) == True) {
      Plant(Lea, Tempd(Dest, Bytes), Dest);
      return;
    }
    Plantlit(Add, Bytes, Dest);
  }
  int Freereg(int Rset) {
    int R;
    int R1;
    R = D0;
    Rset = Rset & Free;
    if (!Rset)
      Fault(Plexerr);
    else {
      while (!(Rset & 1)) {
        R++;
        Rset = (unsigned)Rset >> 1;
      }
      R1 = R;
      while (C.Reg.Content != Undef) {
        R++;
        Rset = (unsigned)Rset >> 1;
        if (!Rset) {
          R = R1;
          break;
        }
        while (!(Rset & 1)) {
          R++;
          Rset = (unsigned)Rset >> 1;
        }
      }
      Free -= D0b << (R - D0);
    }
    return (R);
  }
  void Moveblock(int Source, int Dest, int Bytes) {
    int Op;
    int F;
    int R;
    int Pc1;
    Op = Move;
    if (!Source) Op = Clr;
    if (Bytes <= 16 && (Bytes & 1) == 0) {
      while (Bytes >= 4) {
        Plant(Op, Source, Dest);
        Bytes -= 4;
      }
      if (Bytes >= 2) Plant(Op + (2 << 8), Source, Dest);
    } else {
      Op += 1 << 8;
      if (!(Bytes & 1)) {
        Bytes = (unsigned)Bytes >> 1;
        Op += 1 << 8;
        if (!(Bytes & 1)) {
          Bytes = (unsigned)Bytes >> 1;
          Op += 2 << 8;
        }
      }
      F = Free;
      if (Bytes <= 32768 && (Free & Anydreg) != 0) {
        R = Freereg(Anydreg);
        Plantlit(Move, Bytes - 1, R);
        Pc1 = Pc;
        Plant(Op, Source, Dest);
        Plantlit2(Dbra, R, (Pc1 - Pc - 1) << 1);
        Bytes = Undef;
      } else {
        R = Freereg(Anydreg | Bregb);
        Plantlit(Move, Bytes, R);
        Pc1 = Pc;
        Plant(Op, Source, Dest);
        Plant(Sub, One, R);
        Plantlit2(Bne, 0, (Pc1 - Pc - 1) << 1);
        Bytes = 0;
      }
      C.Reg.Content = Bytes;
      Free = F;
    }
  }
  void Updatesp(void) {
    if (!C.Val) return;
    if (C.Val < 0) {
      Addimm(-C.Val, A7);
      C.Sp = C.Sp - C.Val;
    } else {
      if (!(Control & Assmask))
        Addimm(-C.Val, A7);
      else
        Moveblock(D7, Prea7, C.Val);
      Extendstack(C.Val);
    }
    C.Val = 0;
  }
  void Getbounds(int T, int *Lo, int *Hi) {
    if (Dict[T].Type == T && T != Inttype) {
      *Lo = 0;
      *Hi = Dict[T].Size;
    } else {
      if (Dict[T + 1].Mode != Litmode)
        *Lo = Minint;
      else
        *Lo = Dict[T + 1].Val;
      if (Dict[T + 2].Mode != Litmode)
        *Hi = Maxint;
      else
        *Hi = Dict[T + 2].Val;
    }
  }
  int Size(int T) {
    int S;
    int Ss;
    int Lo;
    int Hi;
    Identinfo *Tp;
    Tp = &Dict[T];
    if (!(Tp->Flags & Nonord)) {
      if (Tp->Type != T) return (Tp->Size());
      if (Tp->Type == Inttype) return (4);
      if (Tp->Size() <= 255) return (1);
      return (2);
    }
    if ((Tp->Flags & Cat) == Recy) return (Tp->Val);
    if ((Tp->Flags & Cat) != Arry) return (Tp->Size());
    if (Tp->Mode >= Framemode) return (0);
    S = 4;
    if (Tp->Flags >= 0) S = Size(Tp->Type);
    Getbounds(Tp->Xtype, Lo, Hi);
    if (Lo == Minint || Hi == Maxint) return (0);
    Ss = (Hi - Lo + 1) * S;
    if (Ss <= 0) return (Ss);
    if (S == 1) {
      if (Ss == 1) return (Ss);
    } else if (Ss <= 4)
      return (Ss);
    return (-Ss);
  }
  int Nsize(Identinfo * Dp) {
    if (Dp.Flags & (Name + Indirect)) return (4);
    if (Dp.Flags & Proc) return (0);
    return (Size(Dp.Type));
  }
  int Tsize(int T) { return (Size(Dict[T].Type)); }
  void Forget(int R) { C.Reg.Content = Undef; }
  void Forgetcc(void) { C.Reg.Ccy = Undef; }
  void Forgetregs(void) {
    short *Cc;
    int I;
    I = Maxareg;
    Cc = &C.Reg.Content;
    for (;;) {
      *Cc = Undef;
      if (Cc == &C.Reg.Content) break;
      I--;
      Cc = &C.Reg.Content;
    }
    C.Reg.Ccy = Undef;
    C.Reg.Line = -9;
  }
  void Forgettriples(void) {
    Litpos = Litmin;
    Explo = Explim;
    Oldexplo = Explim;
  }
  void Forgetall(void) {
    int I;
    int J;
    Contentinfo *Lr;
    Forgetregs();
    J = Dictlim;
    for (;;) {
      J++;
      if (J >= Curlab) break;
      Lr = &Lreg[J - Dictlim];
      for (I = D0; I <= Maxareg; I++) Lr->Content = Undef;
      Lr->Ccx = Undef;
    }
    Forgettriples();
  }
  void Definejumps(int Chain) {
    int I;
    int J;
    int K;
    Chain = -Chain;
    if (Chain <= 0) return;
    C.Forward = C.Forward - 1;
    C.Access = 1;
    do {
      I = Prog[Chain];
      if (Pflag[Chain] == Jump) {
        J = Chain - Pflag[Chain - 1];
        K = (Pc - C.Shorts - J) << 1;
        if (K > 2 && K <= 127)
          if (C.Shorts == 255)
            Zaps += 100;
          else {
            C.Shorts = C.Shorts + 1;
            Shorts++;
            Pflag[Chain] = Shortjump;
            J = Chain;
            do {
              if (Pflag[J] >= Zeroshorts) Pflag[J] = Pflag[J] + 1;
              J++;
            } while (J != Pc);
          }
      }
      Prog[Chain] = Pc;
      Chain = I;
    } while (Chain > 0);
  }
  void Savecontext(int L) {
    int R;
    Contentinfo *Lr;
    if (L - Dictlim < 0) return;
    Lr = &Lreg[L - Dictlim];
    if (Dict[L].Val >= 0) {
      Dict[L].Val = 0;
      *Lr = C.Reg;
      C.Forward = C.Forward + 1;
    } else {
      for (R = D0; R <= Maxareg; R++)
        if (Lr->Content != C.Reg.Content) Lr->Content = Undef;
      if (Lr->Ccx != C.Reg.Ccx || Lr->Ccy != C.Reg.Ccy) Lr->Ccy = Undef;
      if (Lr->Line != C.Reg.Line) Lr->Line = -9;
    }
  }
  void Srcall(int X) {
    void Putprim(Identinfo * Dx) {
      static short Primcode[396 /*1:396*/] = {
          0x1541, 0x7272, 0x6179, 0x2062, 0x6F75, 0x6E64, 0x7320, 0x6578, 0x6365, 0x6564, 0x6564, 0xB098, 0x6E06,
          0x9098, 0x6C10, 0xD0A0, 0x41FA, 0xFFDE, 0x2400, 0x7202, 0x7076, 0x4EF8, 0x3EFA, 0x4A58, 0x660C, 0x4840,
          0x4A40, 0x6610, 0x4840, 0xC0D8, 0x4E75, 0x2F01, 0x2200, 0xC2E8, 0xFFFE, 0x6008, 0x2F01, 0x2200, 0x4840,
          0xC2D0, 0x4841, 0xC0D8, 0xD081, 0x221F, 0x4E75, 0x1355, 0x6E61, 0x7373, 0x6967, 0x6E65, 0x6420, 0x7661,
          0x7269, 0x6162, 0x6C65, 0x660C, 0x41FA, 0xFFE8, 0x7201, 0x7058, 0x4EF8, 0x3EFA, 0x4E75, 0x0F49, 0x6E76,
          0x616C, 0x6964, 0x2061, 0x6464, 0x7265, 0x7373, 0x6E0C, 0x41FA, 0xFFEC, 0x7201, 0x7058, 0x4EF8, 0x3EFA,
          0x4E75, 0x1553, 0x7461, 0x636B, 0x2073, 0x7061, 0x6365, 0x2065, 0x7868, 0x6175, 0x7374, 0x6564, 0xD88F,
          0xB886, 0x6C0E, 0x4284, 0x41FA, 0xFFE0, 0x7203, 0x7055, 0x4EF8, 0x3EFA, 0x4284, 0x4E75, 0x1741, 0x7272,
          0x6179, 0x2062, 0x6F75, 0x6E64, 0x7320, 0x696E, 0x7369, 0x6465, 0x206F, 0x7574, 0x9282, 0x6F0C, 0x41FA,
          0xFFE2, 0x7203, 0x7055, 0x4EF8, 0x3EFA, 0x4481, 0x5281, 0x4EF8, 0x3EF4, 0x4E75, 0x0E53, 0x7472, 0x696E,
          0x6720, 0x746F, 0x6F20, 0x6269, 0x6780, 0x1811, 0x9004, 0x6504, 0x9010, 0x640C, 0x41FA, 0xFFE4, 0x7203,
          0x7051, 0x4EF8, 0x3EFA, 0x1018, 0x670C, 0xD111, 0x1398, 0x4801, 0x5204, 0x5300, 0x66F6, 0x2049, 0x4E75,
          0x3F00, 0x7001, 0x1E80, 0x204F, 0x548F, 0x4E75, 0x124E, 0x6F20, 0x7370, 0x6163, 0x6520, 0x666F, 0x7220,
          0x6172, 0x7261, 0x7980, 0x5680, 0xE480, 0xE588, 0x6D08, 0x204F, 0x91C0, 0xB1C6, 0x6C0E, 0x2400, 0x41FA,
          0xFFD8, 0x7201, 0x7072, 0x4EF8, 0x3EFA, 0x205F, 0xE488, 0x6004, 0x4840, 0x2F07, 0x51C8, 0xFFFC, 0x4840,
          0x51C8, 0xFFF4, 0x4ED0, 0x4E75, 0x1149, 0x6E76, 0x616C, 0x6964, 0x2025, 0x666F, 0x7220, 0x6C6F, 0x6F70,
          0x2F00, 0x9082, 0x6720, 0x2F01, 0x6708, 0x4EB8, 0x3EEE, 0x4A80, 0x6D0E, 0x508F, 0x41FA, 0xFFD8, 0x7201,
          0x7055, 0x4EF8, 0x3EFA, 0x4A81, 0x66EE, 0x221F, 0x201F, 0x4E75, 0x0C4F, 0x7574, 0x206F, 0x6620, 0x7261,
          0x6E67, 0x6580, 0x41FA, 0xFFF0, 0x7201, 0x7056, 0x4EF8, 0x3EFA, 0x4E75, 0x1355, 0x6E61, 0x7373, 0x6967,
          0x6E65, 0x6420, 0x7661, 0x7269, 0x6162, 0x6C65, 0xB0FC, 0x0000, 0x6F1A, 0xB2FC, 0x0000, 0x6F14, 0xBE10,
          0x6606, 0xBE28, 0x0001, 0x670A, 0xBE11, 0x6612, 0xBE29, 0x0001, 0x660C, 0x41FA, 0xFFCA, 0x7202, 0x7054,
          0x4EF8, 0x3EFA, 0x48E7, 0xC0C0, 0x4240, 0x1018, 0x6730, 0x4241, 0x1219, 0x6722, 0x5380, 0x5381, 0xB041,
          0x6E12, 0x9240, 0xB109, 0x56C8, 0xFFFC, 0x6602, 0x4441, 0x4CDF, 0x0303, 0x4E75, 0xB109, 0x56C9, 0xFFFC,
          0x66F2, 0x7201, 0x4CDF, 0x0303, 0x4E75, 0x1011, 0x4440, 0x4CDF, 0x0303, 0x4E75, 0x0E53, 0x7472, 0x696E,
          0x6720, 0x746F, 0x6F20, 0x6269, 0x6780, 0xB010, 0x640C, 0x41FA, 0xFFEA, 0x7203, 0x7051, 0x4EF8, 0x3EFA,
          0x4280, 0x1010, 0x12D8, 0x51C8, 0xFFFC, 0x4E75, 0x0E53, 0x7472, 0x696E, 0x6720, 0x746F, 0x6F20, 0x6269,
          0x6780, 0xB010, 0x640C, 0x41FA, 0xFFEA, 0x7201, 0x7056, 0x4EF8, 0x3EFA, 0x0240, 0x00FE, 0x245F, 0x9EC0,
          0x558F, 0x224F, 0xBFC8, 0x6E0E, 0x1010, 0x12D8, 0x51C8, 0xFFFC, 0x204F, 0x224F, 0x4ED2, 0x1018, 0x5289,
          0xD0C0, 0xD2C0, 0x1320, 0x51C8, 0xFFFC, 0x204F, 0x224F, 0x4ED2, 0x4E75, 0x43EF, 0xFF00, 0x2448, 0xD5C0,
          0x2049, 0x9280, 0x6C04, 0x4211, 0x4E75, 0x1281, 0x5219, 0x12DA, 0x51C9, 0xFFFC, 0x4E75, 0x700A, 0x4EF8,
          0x3E70, 0x4E75, 0x7020, 0x4EF8, 0x3E70, 0x4E75};
      int Start;
      int Limit;
      Identinfo *Ddx;
      if (Cad & 1) Fillcode(1);
      Start = (unsigned)Dx.Val >> 16 & 511;
      Limit = Start + (Dx.Val & 255);
      Dx.Val = Cad + ((unsigned)Dx.Val >> 7 & (255 << 1));
      Dx.Mode = Procmode;
      if (Start == Limit) {
        Ddx = &Dict[Check];
        if (Ddx->Mode == Absmode) {
          Putprim(*Ddx);
          Dx.Val = Cad;
        }
        Setcodeword(0x0C80);
        Setcodelongword(Dict[X + 1].Val);
        Setcodeword(0x6D00);
        Setcodeword(Ddx->Val - Cad);
        Setcodeword(0x0C80);
        Setcodelongword(Dict[X + 2].Val);
        Setcodeword(0x6E00);
        Setcodeword(Ddx->Val - Cad);
        Setcodeword(0x4E75);
      } else
        do {
          Setcodeword(Primcode[Start]);
          Start++;
        } while (Start < Limit);
    }
    Identinfo *Dx;
    Identinfo *Tp;
    Dx = &Dict[X];
    Tp = Typecell(Dx->Type);
    if (Dx->Mode == Absmode && Dx->Val < 0)
      Putprim(*Dx);
    else {
      if (Tp->Val <= 0) C.Status = C.Status | Unknown;
      if (C.Sp - Imod(Tp->Val) < C.Totstack) C.Totstack = C.Sp - Imod(Tp->Val);
    }
    if ((Dx->Mode & 63) == Pcmode) {
      if ((Dx->Flags & Spec) != 0 && (Dx->Flags & Rflag) == 0) C.Forward = C.Forward + 1;
      Plant(Bsr, 0, X);
    } else if ((Dx->Flags & (Name + Indirect)) == 0 || (Dx->Flags & Ext) != 0)
      Plant(Jsr, 0, X);
    else if (Free & A0b << 3) {
      Plant(Move, X, A0 + 3);
      Plant(Jsr, 0, A0 + 3 + Indir);
      Forget(A0 + 3);
    } else {
      Plant(Move, X, Tempd(A7, -4));
      Plantlit(Move, 0x4EF9, Tempd(A7, -6));
      Plant(Jsr, 0, Lablim);
    }
  }
  void Definelabel(int Lab) {
    int R;
    int Chain;
    Contentinfo *Lr;
    Chain = Dict[Lab].Val;
    if (Chain >= 0) {
      Updatesp();
      Forgetregs();
    } else {
      Lr = &Lreg[Lab - Dictlim];
      if (!C.Access) {
        C.Reg = *Lr;
      } else {
        for (R = D0; R <= Maxareg; R++)
          if (C.Reg.Content != Lr->Content) Forget(R);
        if (C.Reg.Ccx != Lr->Ccx || C.Reg.Ccy != Lr->Ccy) Forgetcc();
        if (Lr->Line != C.Reg.Line) C.Reg.Line = -9;
      }
    }
    Definejumps(Chain);
    Dict[Lab].Val = Pc;
    if ((Control & Codelist) != 0 && (Control & List) != 0) Putoperand(Lab);
  }
  void Setuserlabel(int *Chain) {
    Updatesp();
    if (C.Temps != 0 && C.Access != 0) Addimm(C.Temps, A7);
    Definejumps(*Chain);
    *Chain = Pc;
    C.Access = 1;
    if (C.Temps) Addimm(-C.Temps, A7);
    Forgetregs();
    if (Curlab == C.Lab1) Forgettriples();
  }
  void Flush(void) {
    if (Pendcond < 0) {
      Litstore[Litpos] = Line;
      if (Control & Tracebit)
        Plantlit2(Trapi, Litpos, 15);
      else if (Line - C.Reg.Line > 8)
        Plant(Move + (2 << 8), Litpos, Lineloc);
      else
        Plantlit(Add + (2 << 8), Line - C.Reg.Line, Lineloc);
      Forgetcc();
      C.Reg.Line = Line;
    } else {
      if (Pendout) {
        Pendcond = Pendcond & 15;
        if (!Pendcond) C.Access = 0;
        if (Pendcond != 1) {
          Savecontext(Pendout);
          Plant(Bra + Pendcond, 0, Pendout);
        }
      }
      if (Pendin) Definelabel(Pendin);
    }
    Pendcond = 0;
  }
  static const int Inst = 1 << 30;
  void Eval(int *Pp, int Rset) {
    static const int Asl = 32;
    static const int Cmpm = 43;
    static const int Trapv = 70;
    static const int Swap = 74;
    static const int Extl = 76;
    static const int Jmp = 57;
    static const int Tst = 59;
    static const int Dbne = 86;
    static const int Movew = Move + (2 << 8);
    static const int Addw = Add + (2 << 8);
    static const int Moveb = Move + (1 << 8);
    static const int Addb = Add + (1 << 8);
    static const int Subb = Sub + (1 << 8);
    static const int Cmpb = Cmp + (1 << 8);
    static const int Cmpmb = Cmpm + (1 << 8);
    static const int Val = Sign + Anyreg;
    static const int Ref = Sign;
    static const int Sizeshift = 16;
    static const int Tobyte = 1 << 16;
    static const int Toshort = 1 << 17;
    static const int Tostack = 1 << 19;
    static const int Asad = 1 << 20;
    static int Do_sw;
    static void *Do[118 /*0:117*/] = {
        &&Do_0,       &&Do_1,       &&Do_2,       &&Do_3,       &&Do_4,       &&Do_5,       &&Do_6,       &&Do_7,
        &&Do_8,       &&Do_9,       &&Do_10,      &&Do_11,      &&Do_12,      &&Do_13,      &&Do_14,      &&Do_15,
        &&Do_16,      &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default,
        &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default,
        &&Do_32,      &&Do_33,      &&Do_34,      &&Do_35,      &&Do_36,      &&Do_37,      &&Do_38,      &&Do_39,
        &&Do_40,      &&Do_41,      &&Do_42,      &&Do_43,      &&Do_44,      &&Do_45,      &&Do_46,      &&Do_47,
        &&Do_48,      &&Do_49,      &&Do_50,      &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default,
        &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default,
        &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_default,
        &&Do_default, &&Do_73,      &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_78,      &&Do_79,
        &&Do_default, &&Do_default, &&Do_82,      &&Do_default, &&Do_default, &&Do_default, &&Do_86,      &&Do_87,
        &&Do_88,      &&Do_89,      &&Do_90,      &&Do_91,      &&Do_92,      &&Do_93,      &&Do_94,      &&Do_95,
        &&Do_default, &&Do_default, &&Do_98,      &&Do_default, &&Do_default, &&Do_default, &&Do_default, &&Do_103,
        &&Do_default, &&Do_105,     &&Do_106,     &&Do_107,     &&Do_default, &&Do_109,     &&Do_default, &&Do_111,
        &&Do_default, &&Do_default, &&Do_default, &&Do_115,     &&Do_default, &&Do_117,
    };
    static int Stsiz = 0;
    int I;
    int J;
    int P;
    int Act;
    int X;
    int Y;
    int Xx;
    int Yy;
    int Wx;
    int Wy;
    int Sx;
    int Sy;
    int R;
    int Oldfree;
    int Freed;
    int M;
    int V;
    int Sp;
    int Stsize;
    int Op;
    int Case;
    Identinfo *Dp;
    Identinfo *Dx;
    Identinfo *Dy;
    Identinfo *Tx;
    int Freedreg(void) { return (Freereg(Anydreg)); }
    int Freeareg(int Content) {
      int R;
      R = Freereg(Anyareg);
      C.Reg.Content = Content;
      return (R);
    }
    void Push(int X) {
      Plant(Move, X, Prea7);
      Extendstack(4);
    }
    void Pop(int X) {
      Plant(Move, Posta7, X);
      C.Sp = C.Sp + 4;
    }
    void Pushs(int X, int S) {
      Plant(Move + (S << 8), X, Prea7);
      if (S < 4)
        Extendstack(2);
      else
        Extendstack(4);
    }
    void Pushblock(int Areg, int Bytes) {
      if (Bytes <= 4)
        Moveblock(Areg + Indir, Prea7, Bytes);
      else {
        Addimm(Bytes, Areg);
        Moveblock(Areg + Pre, Prea7, Bytes);
      }
      Extendstack(Bytes);
    }
    void Compileuncondbranch(int L) {
      if (Pendcond)
        if (Pendcond < 0) {
          Pendcond = 0;
        } else if (Pendin) {
          Flush();
        } else {
          Pendcond = Pendcond ^ 1;
          if (*Pp + 1 < Np && Dict[*Pp + 1].Act == Else) C.Access = -2;
        }
      Pendcond = Pendcond & 15;
      if (!Pendcond) C.Access = 0;
      if (Pendcond != 1) Plant(Bra + Pendcond, 0, L);
      Pendcond = 0;
    }
    int Cleanreg(void) {
      int R;
      if (Free & Bregb) {
        Free -= Bregb;
        return (Breg);
      }
      R = Freedreg();
      Plant(Clr, 0, R);
      return (R);
    }
    int Weight(int P) {
      int A;
      int Wy;
      Identinfo *Dp;
      if (P >= Explim) P -= Ad;
      if (P < Np0) return (1);
      Dp = &Dict[P];
      A = Dp->Act;
      if (A >= Imul) return (999);
      Wy = Weight(Dp->Y);
      if (Wy >= 999) return (Wy);
      if (A == Recref && Dict[Dp->X].Flags >= 0) Wy--;
      return (Wy + Weight(Dp->X));
    }
    void Checkaddress(int V) {
      if (A0 <= V && V <= A7)
        Plant(Cmp + (2 << 8), 0, V);
      else
        Plant(Tst, 0, V);
      Srcall(Adok);
      Forgetcc();
    }
    void Call(void) {
      int Sp;
      int Stage;
      int Maxq;
      int Awkward;
      void Evalparlist(int Arg, int Q) {
        Identinfo *Darg;
        Identinfo *Dv;
        int V;
        int W;
        int F;
        int R;
        int S;
        if (!Arg) return;
        Darg = &Dict[Arg];
        Q++;
        if (Q > Maxq) Maxq = Q;
        if (!(Q & 1))
          V = Dict[P + ((unsigned)Q >> 1)].X;
        else
          V = Dict[P + ((unsigned)Q >> 1)].Y;
        R = Darg->Reg & 15;
        S = Size(Darg->Type);
        if (Darg->Flags & Proc) {
          S = 0;
          if (Awkward) {
            F = V;
            if (F >= Explim) F -= Ad;
            Dv = &Dict[F];
            if ((Dv->Flags & (Ext + Spec)) != Ext + Spec) {
              if (Stage) {
                Evalparlist(Darg->Link, Q);
                return;
              }
              if (Dv->Flags & (Name + Indirect))
                Plant(Move, F, Prea7);
              else
                Plant(Pea, 0, F);
              Plantlit(Move + (2 << 8), 0x4EF9, Prea7);
              Plant(Move, Mb, Prea7);
              Plantlit(Move + (2 << 8), 0x287C, Prea7);
              Extendstack(12);
              S = C.Sp;
              Evalparlist(Darg->Link, Q);
              if (Darg->Val > 0)
                Plant(Pea, 0, Temp(C.Mode, S));
              else {
                Plant(Lea, Temp(C.Mode, S), R + D0);
                Free = Free & (~(D0b << R));
              }
              return;
            }
          }
        }
        if (Darg->Val > 0) {
          Evalparlist(Darg->Link, Q);
          if (Stage) return;
          if (Darg->Flags < 0) {
            F = Free;
            Eval(V, Anyareg);
            Push(V);
            Free = F;
            return;
          }
          if (S > 0) {
            F = Free;
            Eval(V, Val);
            Pushs(V, S);
            Free = F;
          } else {
            Stsiz = S;
            if (Category(Darg->Type) != Stringy) Stsiz = -Stsiz;
            Eval(V, Tostack);
          }
          return;
        }
        if (S <= 0 && Darg->Flags >= 0) {
          if (V >= Explim) V -= Ad;
          if (V >= Np0) {
            Dv = &Dict[V];
            if (Dv->Act >= Concat && Dv->Mode == 0) {
              if (!Stage) {
                Stsiz = S;
                if (Category(Darg->Type) != Stringy) Stsiz = -Stsiz;
                R = V;
                Eval(R, Tostack);
                Free = Free | A0b;
                C.Reg.Content = V + Ad;
                Dv->Val = C.Sp;
                Evalparlist(Darg->Link, Q);
              } else {
                Evalparlist(Darg->Link, Q);
                if (C.Reg.Content != V + Ad) {
                  Dv->Mode = C.Mode;
                  Plant(Lea, V, R + D0);
                  Dv->Mode = 0;
                }
                Free = Free & (~(D0b << R));
              }
              return;
            }
          }
          V += Ad;
        }
        W = Weight(V);
        if (W >= 999) {
          Evalparlist(Darg->Link, Q);
          if (Stage) return;
        } else {
          if (W >= 2 && Stage != 0) {
            Eval(V, D0b << R);
            Evalparlist(Darg->Link, Q);
            return;
          }
          Evalparlist(Darg->Link, Q);
          if (!Stage) return;
        }
        Eval(V, D0b << R);
      }
      Awkward = 0;
      if ((Dx->Flags & Proc2) != 0 && ((Dx->Flags & Ext) == 0 || (Dx->Flags & Spec) != 0)) {
        Awkward = 1;
        Push(Mb);
      }
      Sp = C.Sp;
      Maxq = 0;
      Stage = 0;
      Evalparlist(Dict[Dx->Type].Link, -1);
      Stage = 1;
      Evalparlist(Dict[Dx->Type].Link, -1);
      Srcall(Act);
      if (C.Sp != Sp) {
        Addimm(Sp - C.Sp, A7);
        C.Sp = Sp;
      }
      if (Awkward) Pop(Mb);
      if (P < Np) *Pp = P + ((unsigned)Maxq >> 1);
      Forgetregs();
      if ((Dx->Flags & (Ext + Proc)) == Ext + Proc1) C.Reg.Line = Line;
    }
    void Structcall(int Entry, int Size) {
      if (Size <= 0) {
        Size = Mite(-Size - 1);
        Forget(Breg);
      }
      Plantlit(Move, Size, D0);
      Srcall(Entry);
      Forget(D0);
    }
    void Pushstructure(void) {
      if (Stsize <= 0) {
        Structcall(Strtostk, Stsize);
        Forget(A0);
        Forget(A1);
        Forget(A0 + 2);
        Extendstack(256 - (Stsize & 254));
      } else
        Pushblock(A0, (Stsize + 1) & (~1));
    }
    void Okreg(int Got) {
      R = Got;
      if (!(D0b << (Got - D0) & Rset)) {
        C.Reg.Content = *Pp;
        if ((Rset & Free) == 0 && (Rset & Tostack) != 0) {
          Pushstructure();
          R = A7;
        } else {
          R = Freereg(Rset & (~Bregb));
          Plant(Move, Got, R);
          if (R < A0) {
            C.Reg.Ccx = *Pp;
            C.Reg.Ccy = 0;
          }
        }
      }
    }
    void Okareg(int Got, int Ok) {
      R = Got;
      if (!(A0b << (Got - A0) & Ok)) {
        R = Freereg(Ok);
        Plant(Move, Got, R);
      }
    }
    void Loadaddress(int P) {
      int I;
      int F;
      if (Rset & Anyareg & Free) {
        if ((Dp->Mode & 0b111000) == Indexmode && (Dp->Val & 255) == 0) {
          I = A0b << (Dp->Mode & 7);
          if (Rset & Free & I) Rset = I;
        }
        R = Freereg(Rset & Anyareg);
        Plant(Lea, P, R);
      } else {
        F = Free;
        I = Freeareg(P + Ad);
        Plant(Lea, P, I);
        Free = F;
        R = Freereg(Rset & (~Bregb));
        Plant(Move, I, R);
      }
    }
    void Commandeer(int Regs) {
      int R;
      Freed = ~Free & Regs;
      if (Freed) {
        Regs = Freed;
        R = D0;
        while (Regs) {
          if (Regs & 1) {
            Push(R);
            Forgetcc();
          }
          Regs = (unsigned)Regs >> 1;
          R++;
        }
        Free = Free | Freed;
        Rset = Rset & (~Freed);
      }
    }
    void Restore(int Regs) {
      int R;
      R = A7;
      while (Regs) {
        if (Regs & 0x8000) {
          Pop(R);
          Forget(R);
          Forgetcc();
        }
        Regs = Regs << 1 & 0xFFFF;
        R--;
      }
    }
    void Partreg(void) {
      if (R == Breg || R >= A0) Sy = 4;
      while (Imod(Sy) < Sx)
        if (Sy > 0) {
          Plant(Extl - 2 + Sy, 0, R);
          Sy += Sy;
        } else {
          if (Sy == -1)
            Plantlit(And, 255, R);
          else
            Plantlit(And, 0xFFFF, R);
          Sy = 4;
        }
    }
    Stsize = Stsiz;
    if (Rset & Tobyte) Rset = Rset & (~Anyareg);
    P = *Pp;
    if (P >= Explim) P -= Ad;
    if (Rset & Asad) {
      Rset -= Asad;
      *Pp = P + Ad;
    }
    if (P <= 0)
      Dp = Dint;
    else
      Dp = &Dict[P];
    Oldfree = Free;
    Freed = 0;
    if (Rset != Inst) {
      if ((Dp->Mode & 0b110000) != 0 || *Pp >= Np0) {
        J = *Pp;
        if (Rset & (Anydreg | Bregb)) {
          I = D0;
          do {
            if (C.Reg.Content == J) {
              J = I;
              break;
            }
            I++;
            if (I == Maxdreg + 1) I = A0;
          } while (I <= Maxareg);
        } else if (Rset & Anyareg) {
          I = Maxareg;
          do {
            if (C.Reg.Content == J) {
              J = I;
              break;
            }
            I--;
            if (I == A0 - 1) I = Maxdreg;
          } while (I >= D0);
        } else if (J < Explim && Rset != Tostack) {
          I = A0;
          do {
            if (C.Reg.Content == J + Ad) {
              Free = Free & (~(A0b << (I - A0)));
              Dp->Flags = Dp->Flags | (Rflag + Wflag);
              *Pp = I + Indir;
              return;
            }
            I++;
          } while (I <= Maxareg);
        }
      } else {
        J = Dp->Mode + D0;
        if (Rset < 0) {
          *Pp = J;
          return;
        }
        *Pp = C.Reg.Content;
      }
      if (0 < J && J <= A7) {
        Okreg(J);
        Dp->Flags = Dp->Flags | Rflag;
        goto Endload;
      }
      if (P <= 0) {
        if (Rset < 0) return;
        if (Rset == Tostack) {
          I = Constmode;
          if (!P) I = Pcmode;
          Plant(Lea, Temp(I, Litval(P)), A0);
          Forget(A0);
          Pushstructure();
          return;
        }
        if (*Pp < Explim) {
          if (P < -(255 << 1) || (P & 1) != 0) Rset = Rset & (~Bregb);
          R = Freereg(Rset);
          if (R < A0 || P != 0)
            Plant(Move, P, R);
          else
            Plant(Sub, R, R);
        } else {
          I = Constmode;
          if (!P) I = Pcmode;
          Loadaddress(Temp(I, Litval(P)));
        }
        if (R < A0) {
          C.Reg.Ccx = *Pp;
          C.Reg.Ccy = 0;
        }
        goto Endload;
      }
    }
    if (P >= Np0) {
    More:;
      Act = Dp->Act;
      X = Dp->X;
      Y = Dp->Y;
      Xx = X;
      Yy = Y;
      if (Act > Opmax) goto Proccall;
      goto *Do[Do_sw = Act];
    }
  Do_1:;
  Load:;
    I = 0;
    if (Dp->Flags & Indirect) I++;
    if (Dp->Flags < 0) I += 2;
    if (*Pp >= Explim) {
      if (!I) {
        Free = Oldfree;
        Loadaddress(P);
      } else {
        if (I == 3) {
          Free = Oldfree;
          R = Freeareg(Undef);
          Plant(Move, P, R);
          P = R + Indir;
        }
        if (Rset < 0) {
          *Pp = P;
          return;
        }
        Free = Oldfree;
        R = Freereg(Rset);
        Plant(Move, P, R);
      }
      if (R < A0) {
        C.Reg.Ccx = *Pp;
        C.Reg.Ccy = 0;
      }
    } else {
      if (I > 0) {
        Free = Oldfree;
        R = Maxareg + 1;
        do {
          R--;
          if (R < A0) {
            R = Freeareg(P + Ad);
            Plant(Move, P, R);
            if (I == 3) Plant(Move, R + Indir, R);
            if (I > 1 && (Control & Assbit) != 0) Checkaddress(R);
          }
        } while (C.Reg.Content != P + Ad);
        Free = Free & (~(A0b << (R - A0)));
        P = R + Indir;
      }
      if (Rset == Ref) {
        *Pp = P;
        return;
      }
      Sx = (unsigned)Rset >> Sizeshift & 3;
      if (!Sx) Sx = 4;
      I = Dp->Flags;
      Sy = Size(Dp->Type);
      if (C.Localdpos <= P && P < Dictlim && (I & Okflag) == 0 && C.Forward == 0) {
        if (!(I & Wflag))
          if (!C.Faults) Report(Asserr + Warn, P, 0);
        if (Dp->Flags >= 0 && Sy > 0) Dp->Flags = Dp->Flags + Okflag;
      }
      if (Rset == Tostack) {
        Free = Oldfree;
        Plant(Lea, P, A0);
        Forget(A0);
        Pushstructure();
        return;
      }
      if (Sy <= 0) {
        Intern(5);
        return;
      }
      if (!(Control & (unsigned)Bassbit >> 1 << Sy)) I = I | Okflag;
      if ((I & Okflag) != 0 && Rset < 0)
        if (Sy == Sx) {
          *Pp = P;
          return;
        }
      Free = Oldfree;
      if (I & Okflag)
        I = -1;
      else
        I = Sy;
      if (Sy != 4 && ((Dict[Dp->Type].Flags & Nonord) != 0 || Dict[Dp->Type + 1].Val == 0)) Sy = -Sy;
      if (Sy == -1) {
        if (Free & Bregb)
          if (Rset & Bregb)
            Rset = Bregb;
          else {
            Plant(Moveb, P, Breg);
            Forget(Breg);
            P = Breg;
            Sy = 4;
          }
      } else
        Rset = Rset & (~Bregb);
      if (Sy < 2 || Sx == 1)
        if (!(Rset & (Anydreg | Bregb))) {
          R = Freedreg();
          Plant(Move + (Imod(Sy) << 8), P, R);
          Partreg();
          P = R;
          Free = Oldfree;
        } else
          Rset = Rset & (~Anyareg);
      if (Sy == 2 && (Rset & Anyareg & Free) != 0) {
        Rset = Rset & (~Anydreg);
      }
      R = Freereg(Rset);
      Plant(Move + (Imod(Sy) << 8), P, R);
      if (R < A0) {
        C.Reg.Ccx = *Pp;
        C.Reg.Ccy = 0;
      }
      if (Sy != 4) Partreg();
      if (I >= 0) {
        Plant(Cmp + (I << 8), R, D7);
        Srcall(Unass);
        Forgetcc();
      }
      if (Sy != 4 && R != Breg) {
        Forget(R);
        goto Endload1;
      }
    }
  Endload:;
    C.Reg.Content = *Pp;
  Endload1:;
    Free = Free & (~(D0b << (R - D0)));
    if (Rset == Ref) R += Indir;
    *Pp = R;
    return;
  Dataload:;
    Eval(P, Anydreg);
    Okreg(P);
    goto Endload;
    int Freeishareg(int For) {
      int I;
      I = M & 7;
      if ((A0b << I & Oldfree) == 0 || M >= Framemode) return (Freeareg(For));
      Free = Free & (~(A0b << I));
      I += A0;
      C.Reg.Content = For;
      return (I);
    }
    void Adeval(int X, int Y, int Q) {
      int I;
      int J;
      if (X <= 0) {
        M = Constmode;
        V = Litval(X);
      } else {
        Eval(X, Ref);
        M = Dict[X].Mode;
        V = Dict[X].Val;
        if (M == C.Mode && V < 0) {
          M = Dispmode + 7;
          V -= C.Sp;
        } else if ((M & 0b111000) == Aregmode + Indir)
          M += Dispmode - (Aregmode + Indir);
      }
      if (Y) Eval(Y, Anyreg);
      if ((M & 0b111000) == Indexmode) {
        if (!Y) {
          J = Mite(V);
          I = J + Q;
          if (Ismite(I) == True) {
            V = V - J + (I & 255);
            return;
          }
        }
        I = Freeishareg(X + Ad);
        Plant(Lea, X, I);
        M = I + (Dispmode - A0);
        V = 0;
      }
      if (Y)
        if ((M & 63) == Pcmode) {
          I = Freeareg(Undef);
          Plant(Lea, Temp(M, V + Q), I);
          M = I + (Dispmode - A0);
          V = 0;
          Q = 0;
        } else if (Ismite(V + Q) != True) {
          if (Ismite(Q) != True) {
            I = Freeishareg(Undef);
            if (Isshort(V + Q) == True)
              Plant(Lea, Temp(M, V + Q), I);
            else {
              Plant(Lea, X, I);
              Addimm(Q, I);
            }
            Q = 0;
          } else {
            I = Freeishareg(X + Ad);
            Plant(Lea, X, I);
          }
          M = I + (Dispmode - A0);
          V = 0;
        }
      V += Q;
      if (Y) {
        M += Indexmode - Dispmode;
        V = ((Y - D0) << 12) + 0x0800 + (V & 255);
      }
    }
  Do_78:;
    Dx = &Dict[X];
    I = Dx->Type;
    Tx = &Dict[I];
    Getbounds(Tx->Xtype, Sx, Sy);
    M = Imod(Nsize(*Tx));
    if ((Dx->Flags & Arrflag) != 0 && (Y > 0 || Sx == Minint || M == 0)) {
      Commandeer(D0b + D1b + A0b);
      Eval(Y, D0b);
      J = 0;
      while (!Tx->Mode) {
        J += 12;
        I++;
        Tx = &Dict[I];
      }
      if (Tx->Flags & Indirect) {
        Plant(Move, I, A0);
        if (J) Addimm(J, A0);
      } else {
        if (Tx->Val == 0 && Tx->Mode == Constmode) {
          if (Cad & 1) Fillcode(1);
          Tx->Val = Cad;
          Setcodelongword(Sy);
          Setcodelongword(Sx);
          Setcodelongword(M);
        }
        Plant(Lea, I, A0);
      }
      Srcall(Index);
      Forget(D0);
      Forget(A0);
      Restore(Freed & (~D0b));
      Free = Oldfree & (~D0b);
      Freed = Freed & D0b;
      I = X;
      Eval(I, (Anyareg & Free) + Asad);
      Plant(Add, D0, I);
      if (Dp->Flags < 0)
        Forget(I);
      else
        C.Reg.Content = P + Ad;
      if (!Freed) Free = Free | D0b;
      Restore(Freed);
      M = I + (Dispmode - A0);
      V = 0;
      goto Setflags;
    }
  Index1:;
    J = 0;
    if (Y <= 0) {
      J = Litval(Y);
      Y = 0;
    }
    if (Y >= Np0 && Dict[Y].Act == Add && Dict[Y].Y <= 0) {
      J = Litval(Dict[Y].Y);
      Y = Dict[Y].X;
    }
    if (M > 1)
      if (Y) {
        if ((M & (M - 1)) != 0 && M <= 32767 && Sy <= 32767 && Sx >= -32768)
          Putexp(Muls, Y, Litref(M), Inttype);
        else
          Putexp(Imul, Y, Litref(M), Inttype);
        Y = Item;
      }
    if ((Dx->Flags & (Name + Ext + Arrflag + Indirect)) == Indirect && Sx != 0) {
      Dx->Val = Dx->Val + 4;
      Adeval(X, Y, J * M);
      Dx->Val = Dx->Val - 4;
    } else {
      J -= Sx;
      if (M > 1) J = J * M;
      Adeval(X, Y, J);
    }
  Setflags:;
    Dx->Flags = Dx->Flags | (Mflag + Wflag + Rflag);
  Setmode:;
    if (Dispmode <= M && M < Indexmode) {
      if (Isshort(V) != True) {
        Okareg(M + (A0 - Dispmode), Oldfree & Anyareg);
        Addimm(V, R);
        Forget(R);
        M = R - (A0 - Dispmode);
        V = 0;
      }
      if (*Pp >= Explim && V == 0 && Rset != Ref && Dp->Flags >= 0) {
        Okreg(M + (A0 - Dispmode));
        Free = Oldfree;
        goto Endload;
      }
    }
    Dp->Mode = M;
    Dp->Val = V;
    goto Load;
  Do_45:;
    Dx = &Dict[X];
    Adeval(X, 0, Dict[Y].Val);
    goto Setflags;
  Do_47:;
    V = 0;
    if (Y >= Explim) {
      Y -= Ad;
      Eval(Y, Ref);
      M = Dict[Y].Mode;
      V = Dict[Y].Val;
    } else {
      if (Y >= Np0) {
        if (Dict[Y].Act == Add) {
          M = Dict[Y].Y;
          if (M <= 0) {
            Y = Dict[Y].X;
            V = Litval(M);
          }
        }
      }
      Eval(Y, Anyareg);
      if ((Control & Assbit) != 0 && *Pp < Explim) Checkaddress(Y);
      M = Y + (Dispmode - A0);
    }
    goto Setmode;
  Do_79:;
  Do_82:;
    if (X >= Explim) X -= Ad;
    Dx = &Dict[X];
    if (Y <= 0)
      Adeval(X, 0, Litval(Y));
    else {
      Eval(Y, Anydreg);
      Adeval(X, Y, 0);
    }
    goto Setflags;
  Do_115:;
    Commandeer(C.Free);
    Plant(Move, Y, D0);
    Srcall(Act);
    Forgetregs();
    C.Reg.Line = Line;
    goto Endmap;
  Do_107:;
  Proccall:;
    Dx = &Dict[Act];
    if (P < Np) goto Rcall;
    if (!(Dx->Flags & Writable)) goto Funcall;
    Commandeer(C.Free);
    Call();
  Endmap:;
    Free = Oldfree;
    R = A0;
    if (Rset != Ref) Okareg(A0, ~Freed & Anyareg);
    Restore(Freed);
    Free = Free & (~(A0b << (R - A0)));
    C.Reg.Content = P + Ad;
    M = R + (Dispmode - A0);
    V = 0;
    goto Setmode;
  Funcall:;
    Commandeer(C.Free);
    Call();
    R = (*Typecell(Dx->Type)(Dx->Type).Reg & 15) + D0;
    if (Dx->Flags & Okflag) {
      C.Reg.Ccx = *Pp;
      C.Reg.Ccy = 0;
    }
  Endloadr:;
    Free = Oldfree;
    if (Rset != Ref) Okreg(R);
    Restore(Freed);
    goto Endload;
  Rcall:;
    if (Pendcond) Flush();
    Updatesp();
    while (Act == Dprintstr && X >= Np0 && Dict[X].Act == Concat) {
      Dp->X = Dict[X].X;
      Call();
      Free = C.Free;
      X = Dict[X].Y;
      Dp->X = X;
    }
    Call();
    if (Dx->Flags & Noret) C.Access = 0;
    if (*Pp + 1 == Np && Curlab == C.Lab1 && Dict[Curlab].Val >= 0 && Dict[Curlab + 1].Val >= 0) Forgettriples();
    return;
    void Evalxy(void) {
      Rset = Rset & (~Bregb);
      Commandeer(D0b + D1b);
      if (999 > Weight(X) && Weight(X) < Weight(Y)) {
        Eval(Y, D1b);
        Eval(X, D0b);
      } else {
        Eval(X, D0b);
        Eval(Y, D1b);
      }
    }
    void Stackop(int S) {
      Stsiz = S;
      Sp = C.Sp;
      Eval(X, Tostack);
      Free = Free | A0b;
      Eval(Y, A0b + Asad);
      Plant(Move, A7, A1);
      Structcall(Act, S);
      Forget(A0);
      Forget(A1);
      Forget(A0 + 2);
    }
  Do_46:;
    Dx = &Dict[X];
    M = Imod(Size(Dx->Type));
    Sx = 0;
    Sy = 999999;
    goto Index1;
  Do_111:;
    Commandeer(D0b);
    Eval(Y, D0b);
    Srcall(X);
    R = D0;
    goto Endloadr;
  Do_2:;
    if (Control & Overbit) {
      if (!(Rset & (~Anyareg))) goto Dataload;
      Rset = Rset & (~Anyareg);
    }
    if (!(Rset & (~Bregb))) goto Dataload;
    Rset = Rset & (~Bregb);
    if (Y < 0) {
      if (Y >= Litquick) {
        if (Y & 1) {
          Y--;
          Act = Sub;
        }
        Eval(X, Rset & Free);
        goto Fin1;
      }
      if (Y == -(128 << 1)) {
        Act = Sub;
        Y++;
        goto Op2;
      }
    }
    goto Op1;
  Do_7:;
    if (!(Rset & (~Bregb))) goto Dataload;
    Rset = Rset & (~Bregb);
  Do_6:;
  Do_5:;
    if (!(Rset & (~Anyareg))) goto Dataload;
    Rset = Rset & (~Anyareg);
  Op1:;
    Wx = Weight(X);
    if (Wx <= 1 && Y <= 0 && Y >= Litmite && (Rset & (~Anyareg)) != 0) {
      Rset = Rset & (~Anyareg);
      I = X;
      X = Y;
      Y = I;
    } else if (999 > Wx && Wx < Weight(Y)) {
      I = X;
      X = Y;
      Y = I;
    }
    goto Op2;
  Do_3:;
    if (Control & Overbit) {
      if (!(Rset & (~Anyareg))) goto Dataload;
      Rset = Rset & (~Anyareg);
    }
    Rset = Rset & (~Bregb);
  Op2:;
    Eval(X, Rset & Free);
  Op3:;
    Oldfree = Free;
    if (Y <= 0 && Y >= Litmite && (Free & (Anydreg | Bregb)) != 0) {
      Eval(Y, Anydreg | Bregb);
    } else if (Act == Eor && Y > 0)
      Eval(Y, Anydreg);
    else if (Act > Sub)
      if (X == Breg && Y > 0) {
        Sy = Tsize(Y);
        if (Sy == 1 || (Sy == 2 && Act == And)) {
          Eval(Y, (Val & (~Anyareg)) + (Sy << Sizeshift));
          if (Y > D7) Act += Sy << 8;
        } else
          Eval(Y, Val & (~Anyareg));
      } else
        Eval(Y, Val & (~Anyareg));
    else
      Eval(Y, Val);
    Free = Oldfree;
  Fin1:;
    Plant(Act, Y, X);
    if (Act > Sub) goto Fin3;
  Fin2:;
    if (Control & Overbit) Plant(Trapv, 0, 0);
  Fin3:;
    *Pp = X;
    C.Reg.Content = P;
    if (Act <= Opmax) {
      C.Reg.Ccx = P;
      C.Reg.Ccy = 0;
    } else
      Forgetcc();
    return;
  Do_12:
  Do_14:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    Eval(X, Rset & Free);
    Oldfree = Free;
    if (Y > 0) Eval(Y, Anydreg);
    Free = Oldfree;
    Plant(Act, Y, X);
    goto Fin2;
  Do_10:
  Do_11:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    Eval(X, Rset & Free);
    if (Y < 0 && Y >= Litquick) {
      if (Y & 1) {
        Act = Act ^ (Lsl ^ Lsr);
        Y--;
      }
    } else {
      Oldfree = Free;
      Eval(Y, Anydreg);
      Free = Oldfree;
    }
    goto Fin1;
  Do_9:;
    if (Y) {
      R = Y;
      Y = X;
      X = R;
      Act = Sub;
      goto *Do[Do_sw = Sub];
    }
  Do_8:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    Eval(X, Rset & Free);
    Plant(Act, 0, X);
    goto Fin3;
  Do_48:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    X = Y;
    Eval(X, Rset & Free);
    if (C.Reg.Ccx != Y || C.Reg.Ccy != 0) Plant(Move, X, X);
    Plantlit2(Bge, 0, 2);
    Plant(Neg, 0, X);
    goto Fin2;
  Do_49:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    X = Y;
    Eval(X, Rset & Free);
    Plantlit(And, 0x7FFFFFFF, X);
    goto Fin3;
    void Doshift(void) {
      int I;
      I = 0;
      do {
        I++;
        J = (unsigned)J >> 1;
      } while (!(J & 1));
      if (I == 1)
        Plant(Add, X, X);
      else {
        I = Litref(I);
        if (I < Litquick) {
          Oldfree = Free;
          Eval(I, Anydreg);
          Free = Oldfree;
        }
        Plant(Asl, I, X);
      }
    }
  Do_86:;
    if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
    Rset = Rset & (~(Anyareg | Bregb));
    if (Y < 0) {
      J = Litval(Y);
      I = J & (J - 1);
      if (I == 0 || (I & (I - 1)) == 0) {
        Eval(X, Rset & Free);
        if (!(J & 1)) Doshift();
        if (J != 1) {
          Plant(Move, X, Prea7);
          Doshift();
          Plant(Add, Posta7, X);
        }
        goto Fin2;
      }
    }
  Do_91:
  Do_93:;
  Do_88:
  Do_94:;
  Do_90:
  Do_92:;
    Evalxy();
    Srcall(Act);
    if (Act == Imul && (Control & Overbit) != 0) Plant(Trapv, 0, 0);
    Forget(D1);
    R = D0;
    Forgetcc();
    goto Endloadr;
  Do_87:
  Do_98:;
    if (Control & Halfbit) {
      if (Act == Idiv) Act = Divs;
    Do_13:
    Do_15:;
      if (!(Rset & (~(Anyareg | Bregb)))) goto Dataload;
      Rset = Rset & (~(Anyareg | Bregb));
      Eval(X, Rset & Free);
      Oldfree = Free;
      Eval(Y, Anydreg);
      Free = Oldfree;
      if (Act == Drem) {
        Plant(Divs, Y, X);
        Plant(Swap, 0, X);
      } else
        Plant(Act, Y, X);
      Plant(Extl, 0, X);
      goto Fin3;
    }
    Evalxy();
    Srcall(Idiv);
    Putexp(Act ^ (Idiv ^ Drem), Xx, Yy, Inttype);
    if (Act == Idiv) {
      C.Reg.Content = Item;
      R = D0;
    } else {
      C.Reg.Content = Item;
      R = D1;
    }
    Forgetcc();
    goto Endloadr;
  Do_95:;
  Do_89:;
    Commandeer(D0b);
    Eval(X, D0b);
    Srcall(Act);
    Forgetcc();
    R = D0;
    goto Endloadr;
  Do_106:;
    if ((Free & (A0b + A1b + A2b + D0b + Bregb)) != A0b + A1b + A2b + D0b + Bregb) Fault(Plexerr);
    Stackop(-256);
  Endconc:;
    if (!(Rset & Tostack)) {
      if (C.Sp != Sp) {
        Addimm(Sp - C.Sp, A7);
        C.Sp = Sp;
      }
    } else
      Rset = A0b;
    R = A0;
    goto Endloadr;
    void Condswop(void) {
      int Temp;
      Temp = X;
      X = Y;
      Y = Temp;
      Temp = Xx;
      Xx = Yy;
      Yy = Temp;
      Temp = Sx;
      Sx = Sy;
      Sy = Temp;
      Temp = Wx;
      Wx = Wy;
      Wy = Temp;
      if (Case & 8) Case = Case ^ 3;
    }
    void Unsigned(void) {
      if (Case & 8) {
        Case = Case ^ 8;
        if (Case & 2) Case = Case ^ 4;
      }
    }
  Do_4:;
    if (Pendcond) Flush();
    Updatesp();
    Sp = C.Sp;
    *Pp = *Pp + 1;
    Dp = &Dict[*Pp];
    Case = Dp->Act;
    if (X <= 0) {
      if (!X) Case = Case ^ 1;
      Pendcond = (Case & 1) + Bra;
      goto Endcomp;
    }
    if (X >= Explim) {
      Dx = &Dict[X - Ad];
      Sx = 4;
    } else {
      Dx = &Dict[X];
      Tx = &Dict[Dx->Type];
      Sx = Size(Dx->Type);
    }
    Dx->Flags = Dx->Flags | Rflag;
    if (Y >= Explim || Y <= 0)
      Sy = 4;
    else
      Sy = Tsize(Y);
    if (C.Reg.Ccx == Y && C.Reg.Ccy == X) {
      Wx = 0;
      Wy = 0;
      Condswop();
    }
    if (C.Reg.Ccx != X || C.Reg.Ccy != Y)
      if (Y) {
        Wx = Weight(X);
        Wy = Weight(Y);
        if (Wx < 999 && Wy > Wx + 1) Condswop();
        if (X >= Explim || Y >= Explim) {
          if (0 <= Y - Ad && Y - Ad < Dictlim && Dict[Y - Ad].Flags >= 0) Condswop();
          Eval(X, Anyareg);
          Eval(Y, Sign + Anyareg);
          Plant(Cmp, Y, X);
          C.Reg.Ccx = Xx;
          C.Reg.Ccy = Yy;
        } else if (Sx > 0)
          if ((Tx->Flags & Cat) == Realy) {
            Eval(X, D0b);
            Eval(Y, D1b);
            Srcall(Fsub);
            Forget(X);
            C.Reg.Ccx = Xx;
            C.Reg.Ccy = Yy;
          } else if (Y < 0) {
            if (Y >= Litmite) {
              Eval(X, Val + (Sx << Sizeshift));
              if ((Sx == 4 && (Free & Anydreg) != 0) || (X > A7 && (Dict[X].Mode & 63) == Pcmode)) {
                Eval(Y, Anydreg);
                if (X > D7) {
                  Condswop();
                  Sx = Sy;
                }
              }
            } else {
              if (Sx == 1) Sx = 0;
              Eval(X, Val + (Sx << Sizeshift));
              if (A0 <= X && X <= A7 && Isshort(Litval(Y)) == True) Sx = 2;
            }
            Plant(Cmp + (Sx << 8), Y, X);
            if (Sx == 1) Unsigned();
            C.Reg.Ccx = Xx;
            C.Reg.Ccy = Yy;
          } else {
            if (Sy < Sx) Condswop();
            Eval(X, Anyreg);
            if (Sy <= 2 && Sy == Sx && (Sy == 1 || X < A0)) {
              Eval(Y, Val + (Sy << Sizeshift));
              Plant(Cmp + (Sy << 8), Y, X);
              if (Sy == 1) Unsigned();
              Forgetcc();
            } else {
              Eval(Y, Val);
              Plant(Cmp, Y, X);
              C.Reg.Ccx = Xx;
              C.Reg.Ccy = Yy;
            }
          }
        else {
          Stsiz = Sx;
          if ((Tx->Flags & Cat) != Stringy) Stsiz = -Stsiz;
          if (((Case & 8) == 0 && (Control & Strassbit) == 0) ||
              Stringy != (Tx->Flags & Cat) && (Tx->Flags & Cat) != Sety) {
            if (Wy >= 999) {
              Eval(X, Tostack);
              Free = Free | A0b;
              Eval(Y, (Anyareg & Free) + Asad);
              X = Freeareg(Undef);
              Plant(Move, A7, X);
            } else {
              Eval(X, (Anyareg & Free) + Asad);
              Forget(X);
              Eval(Y, (Anyareg & Free) + Asad);
            }
            I = Freedreg();
            if ((Tx->Flags & Cat) == Stringy) {
              Plant(Clr, 0, I);
              Plant(Moveb, X + Indir, I);
            } else
              Plantlit(Move, -Sx - 1, I);
            Plant(Cmpmb, X + Post, Y + Post);
            Plantlit2(Dbne, I, -4);
            Forget(I);
            Forget(Y);
          } else {
            if (Wx >= 999) {
              Eval(X, Tostack);
              Free = Free | A0b;
              if (Wy >= 999) {
                Stsiz = Sy;
                if ((Tx->Flags & Cat) != Stringy) Stsiz = -Stsiz;
                Eval(Y, Tostack);
                Y = A1;
                Plant(Move, A7, Y);
                Sy = (Imod(Sy) + 1) & (~1);
                if (!Sy) Sy = 256;
                X = A0;
                Plant(Lea, Tempd(A7, Sy), X);
              } else {
                Eval(Y, A1b + Asad);
                X = A0;
                Plant(Move, A7, X);
              }
            } else {
              Eval(X, A0b + Asad);
              Eval(Y, A1b + Asad);
            }
            Srcall(Scomp);
            Unsigned();
          }
          Forgetcc();
        }
      } else if (Sx <= 0 || (Sx == 1 && Dx->Mode >= Dispmode))
        if ((Tx->Flags & Cat) == Stringy || Sx == 1) {
          Eval(X, Ref);
          Plant(Tst + (1 << 8), 0, X);
          Forgetcc();
          Unsigned();
        } else {
          Eval(X, (Anyareg & Free) + Asad);
          I = Freedreg();
          Plantlit(Move, -Sx - 1, I);
          Plant(Tst + (1 << 8), 0, X + Post);
          Plantlit2(Dbne, I, -4);
          Forget(I);
          Forget(X);
        }
      else {
        Eval(X, Anydreg);
        if (C.Reg.Ccx != Xx || C.Reg.Ccy != 0) {
          Plant(Move, X, X);
          C.Reg.Ccx = Xx;
          C.Reg.Ccy = 0;
        }
      }
    Pendcond = Case;
  Endcomp:;
    Pendin = Dp->X;
    Pendout = Dp->Y;
  Checksp:;
    if (C.Sp != Sp) {
      Addimm(Sp - C.Sp, A7);
      C.Sp = Sp;
    }
    return;
  Do_117:;
    if (Pendcond) Flush();
    Updatesp();
    Sp = C.Sp;
    Dx = &Dict[Act];
    Call();
    *Pp = *Pp + 2;
    Dp = &Dict[*Pp];
    Pendcond = Dp->Act;
    goto Endcomp;
    int Easy(int Y) {
      int R1;
      int F;
      Identinfo *Dy;
      static int S = 0;
      if (Y < Np0) return (False);
      Dy = &Dict[Y];
      if (Dy->Act > Concat || Dy->Act == Prel) return (False);
      F = Free;
      if (Dy->X == X) {
        S = Tsize(X);
        if (Dy->Act != Concat) S = -S;
        Eval(X, A1b + Asad);
      } else if (Dy->Y >= Np0 || Dy->Y == X || Easy(Dy->X) != True)
        return (False);
      Y = Dy->Y;
      if (Y >= Np0 && Dict[Y].Act == Dtostring) {
        Y = Dict[Y].X;
        Eval(Y, Tobyte + Val);
        R1 = Cleanreg();
        Plant(Addb, One, X + Indir);
        Plant(Moveb, X + Indir, R1);
        Plant(Moveb, Y, Tempx(X, R1));
        Forget(R1);
      } else {
        Eval(Y, A0b + Asad);
        Structcall(Dy->Act, S);
        Forget(A0);
        Forget(A1);
        Forget(D1);
        Forget(D2);
      }
      Free = F & (~A1b);
      return (True);
    }
    void Beware(int Dest) {
      int R;
      int D;
      int Unsafe(int P) {
        for (;;) {
          if (P <= Undef) return (False);
          if (P == Dest || P == D) return (True);
          if (P >= Explim) P -= Ad;
          if (P < Np0) return (False);
          if (Dict[P].Act > Opmax) return (True);
          if (Dest == Dict[P].Y || Dict[P].Y >= Np0) return (True);
          P = Dict[P].X;
        }
      }
      if (Dest <= A7) {
        Forget(Dest);
        return;
      }
      D = Dest;
      if (D >= Explim) D -= Ad;
      for (R = D0; R <= Maxareg; R++)
        if (Unsafe(C.Reg.Content) == True) Forget(R);
      if (Unsafe(C.Reg.Ccx) == True || Unsafe(C.Reg.Ccy) == True) Forgetcc();
    }
    int Xfree(int V, int Strong) {
      Identinfo *Dp;
      for (;;) {
        if (V >= Explim) V -= Ad;
        if (V < Dictlim) break;
        Dp = &Dict[V];
        if (Xfree(Dp->Y, 1) != True) return (False);
        if (Dp->Y >= Dictlim) Strong = 1;
        V = Dp->X;
      }
      if (V != X || Strong == 0) return (True);
      return (False);
    }
  Do_36:;
    Eval(Y, D0b);
    *Pp = *Pp + 1;
    Dp = &Dict[*Pp];
    I = Dp->X;
    Eval(I, D1b);
    I = Dp->Y;
    Eval(I, D2b);
    Srcall(Forok);
  Do_32:;
  Do_34:;
  Do_33:;
    if (Pendcond) Flush();
    if (Xx >= Explim) {
      Wx = Weight(Xx - Ad);
      Dx = &Dict[Xx - Ad];
      Sx = 4;
    } else {
      Wx = Weight(Xx);
      Dx = &Dict[Xx];
      Sx = Size(Dx->Type);
    }
    Tx = &Dict[Dx->Type];
    Sp = C.Sp - C.Val;
    if (Sx <= 0) {
      Updatesp();
      if ((Tx->Flags & Cat) == Stringy) {
        if (!Sx) Sx = -256;
        Op = -1;
        if (Y >= Np0) Op = Dict[Y].Act;
        if (!Y) {
          Eval(X, Ref);
          Plant(Clr + (1 << 8), 0, X);
        } else if (Op == Dtostring) {
          Y = Dict[Y].X;
          Eval(Y, Tobyte + Val);
          Eval(X, (Anyareg & Free) + Asad);
          Plant(Moveb, One, X + Post);
          Plant(Moveb, Y, X + Indir);
          Forget(X);
          Forgetcc();
        } else if (Act == Jamass || Easy(Y) != True) {
          if (Op >= Concat && Wx > 1) {
            Stsiz = Sx;
            Eval(Y, Tostack);
            Free = Free | A0b;
            Eval(X, A1b + Asad);
            Plant(Move, A7, A0);
            Y = A0;
            Structcall(Strcopy, Sx);
          } else if (Act != Assign || Sx == -256 || (Control & Capbit) == 0) {
            if (Wx > 1) {
              Eval(X, (Anyareg & Free) + Asad);
              Eval(Y, (Anyareg & Free) + Asad);
            } else {
              Eval(Y, (Anyareg & Free) + Asad);
              Eval(X, (Anyareg & Free) + Asad);
            }
            I = Freereg(Anydreg | Bregb);
            if (Act == Jamass) {
              Plantlit(Move, Mite(-Sx - 1), I);
              Plant(Moveb, I, X + Post);
              Plant(Cmpb, Y + Post, I);
              Plantlit2(Bcs, 0, 6);
              Plant(Sub, One, X);
              Plant(Moveb, Y + Pre, I);
            } else {
              Plant(Moveb, Y + Indir, I);
            }
            Plant(Moveb, Y + Post, X + Post);
            Plant(Subb, One, I);
            Plantlit2(Bcc, 0, -6);
            Forget(I);
          } else {
            if (Wx > 1) {
              Eval(X, A1b + Asad);
              Eval(Y, A0b + Asad);
            } else {
              Eval(Y, A0b + Asad);
              Eval(X, A1b + Asad);
            }
            Structcall(Strcopy, Sx);
          }
          Forget(X);
          Forget(Y);
          Forgetcc();
        }
      } else if (Easy(Y) != True) {
        if (Y == 0 || Wx > 1) Eval(X, (Anyareg & Free) + Asad);
        if (Y) {
          if (!Sx) Sx = Tsize(Y);
          Eval(Y, (Anyareg & Free) + Asad);
          Forget(Y);
          Y += Post;
          if (Wx <= 1) Eval(X, (Anyareg & Free) + Asad);
        }
        Forget(X);
        if (!Sx)
          Fault(Sizerr);
        else
          Moveblock(Y, X + Post, -Sx);
      }
      Beware(Xx);
      goto Checksp;
    }
    if (C.Val) {
      if (Dx->Val == Sp && Dx->Mode == C.Mode)
        if (Sx == 4 || X >= Explim)
          C.Val = C.Val - 4;
        else
          C.Val = C.Val - 2;
      Updatesp();
    }
    Op = Move;
    Case = Val;
    if (Sx != 4) Case += Sx << Sizeshift;
    if (X <= A7)
      if (Xfree(Y, 0) == True) {
        Case = 1 << (X - D0);
        Free = Free | Case;
      } else
        Free = Free & (~(1 << (X - D0)));
    if (Sx != 4 && Act == Assign && (Control & Capbit) != 0) {
      Eval(Y, D0b);
      Srcall(Dx->Type);
    }
    I = Y;
    if (I >= Explim) I -= Ad;
    if (I >= Np0) {
      if ((Dx->Flags & Okflag) != 0 || (Control & (unsigned)Bassbit >> 1 << Sx) == 0) {
        Dy = &Dict[I];
        if (Y >= Explim) {
          if (Dy->Act == Prel && Dy->X == X - Ad && (Dy->Y < 0 || Dy->Type == Bytetype)) {
            Y = Dy->Y;
            if (Dy->Type != Bytetype) Y = Litref(Litval(Y) * Imod(Size(Dy->Type)));
            Act = Add;
            goto Tostore;
          }
        } else if (Dy->X == X && (Dy->Act < Neg || (Dy->Act == Neg && Dy->Y == 0))) {
          Act = Dy->Act;
          Y = Dy->Y;
          goto Tostore;
        }
      }
      if (Wx < 999) {
        Eval(Y, Case);
        Eval(X, Ref);
      } else {
        Eval(X, Ref);
        Eval(Y, Case);
      }
    } else {
      Eval(X, Ref);
      if (Y <= 0)
        if (Y == 0 && (Dx->Flags & Readable) != 0)
          Op = Clr;
        else if (Y >= Litmite && Sx == 4)
          Eval(Y, Anydreg);
        else if (Y > A7)
          Eval(Y, Case);
    }
    if (Y != X) {
      if (0 < Y && Y <= Maxareg && 0 < Yy && Yy == C.Reg.Content) {
        Beware(Xx);
        C.Reg.Content = Xx;
      } else
        Beware(Xx);
      Plant(Op + ((Sx & 3) << 8), Y, X);
      C.Reg.Ccx = Xx;
      C.Reg.Ccy = 0;
    } else
      Beware(Xx);
  Endass:;
    if (C.Localdpos <= Xx && Xx < Dictlim && C.Forward == 0) Dx->Flags = Dx->Flags | Okflag;
    return;
  Do_35:;
    if (Pendcond) Flush();
    Dx = &Dict[Xx];
    Sx = Size(Dx->Type);
    Wx = Weight(X);
    Act = Add;
  Tostore:;
    if (!Y)
      Eval(X, Ref);
    else if (Y < 0) {
      if (Act == Add) {
        if (Y >= Litquick) {
          if (Y & 1) {
            Act = Sub;
            Y--;
          }
          Eval(X, Ref);
          goto Past;
        }
        if (Y == -(128 << 1)) {
          Act = Sub;
          Y++;
        }
      }
      Eval(X, Ref);
      if (Y >= Litmite && (Anydreg & Free) != 0) Eval(Y, Anydreg);
    } else if (X <= A7)
      Eval(Y, Val);
    else if (999 > Wx && Wx < Weight(Y)) {
      Eval(Y, Anydreg);
      Eval(X, Ref);
    } else {
      Eval(X, Ref);
      Eval(Y, Anydreg);
    }
  Past:;
    Plant(Act + (Sx << 8), Y, X);
    if ((Control & Overbit) != 0 && Act <= Sub) Plant(Trapv, 0, 0);
    Beware(Xx);
    C.Reg.Ccx = Xx;
    C.Reg.Ccy = 0;
    goto Endass;
  Do_38:;
    Updatesp();
    if (C.Type) {
      R = *Typecell(C.Dpid)(C.Dpid).Reg & 15;
      if (C.Type > 0 && Size(C.Type) > 0) {
        if (Pendcond != 0 && Pendin != 0) Flush();
        I = Y;
        if (C.Reg.Content != Y) {
          if (Pendcond) Flush();
          Eval(Y, D0b << R);
        }
        if (C.Reg.Ccx != I || C.Reg.Ccy != 0) C.Status = C.Status | Wrongcc;
      } else {
        C.Status = C.Status | Wrongcc;
        if (Pendcond) Flush();
        if (C.Type > 0) Y += Ad;
        Sp = C.Sp;
        Eval(Y, D0b << R);
        if (C.Sp != Sp) {
          Addimm(Sp - C.Sp, A7);
          C.Sp = Sp;
        }
      }
    }
    if (C.Temps) {
      if (Pendcond) Flush();
      Addimm(C.Temps, A7);
    }
    Dict[Dictlim].Val = C.Return;
    Compileuncondbranch(Dictlim);
    C.Return = -(Pc - 1);
    return;
  Do_41:;
    Updatesp();
    if (Pendcond > 0 && Pendin != 0) Flush();
    if (Y != X) Savecontext(Y);
    Compileuncondbranch(Y);
    return;
  Do_39:;
    Updatesp();
    Compileuncondbranch(X);
    if (Dict[X + 1].Val < 0) Definelabel(X + 1);
    if (Y < 0) {
      C.Val = Y;
      C.Temps = C.Temps + Y;
      Updatesp();
    }
    return;
  Do_40:;
    if (C.Access != 0 && C.Access != -2) {
      Savecontext(Y);
      Compileuncondbranch(Y);
    }
    if (X != 0 && Dict[X].Val < 0) Definelabel(X);
    return;
  Do_16:;
    Updatesp();
    if (!Dict[Y].Val) C.Forward = C.Forward + 1;
    if (C.Temps) Addimm(C.Temps, A7);
    I = Pendcond;
    Compileuncondbranch(Y);
    if (I != 0 && C.Temps != 0) Addimm(-C.Temps, A7);
    return;
  Do_44:;
    Updatesp();
    Definelabel(X);
    return;
  Do_37:;
    Updatesp();
    if (Pendcond) Flush();
    Plant(Clr, 0, D0);
    Srcall(Signal);
    C.Access = 0;
    return;
  Do_73:;
    Updatesp();
    if (Pendcond) Flush();
    Sp = C.Sp;
    *Pp = *Pp + 1;
    Dp = &Dict[*Pp];
    Xx = Dp->X;
    Yy = Dp->Y;
    X = Litval(X);
    if (Yy != Undef) {
      Eval(Yy, A0b + Asad);
      X += 64;
    }
    if (Xx != Undef) {
      Eval(Xx, D2b);
      X += 32;
    }
    if (Y != Undef) {
      Eval(Y, D1b);
      X += 16;
    }
    X = Litref(X);
    Eval(X, D0b);
    if (Control & Sysbit)
      Plant(Jmp, 0, Signal);
    else
      Plant(Jsr, 0, Signal);
    if (C.Sp != Sp) {
      Addimm(Sp - C.Sp, A7);
      C.Sp = Sp;
    }
    C.Access = 0;
    return;
  Do_42:;
    Updatesp();
    Push(D0 + 6);
    Push(Mb);
    Plant(Pea, 0, Temp(Pcmode, 10));
    C.Sp = C.Sp - 4;
    Push(Gb + Indir);
    Plant(Move, A7, Gb + Indir);
    C.Eventsp = C.Sp;
    C.Forward = C.Forward + 1;
    Lreg[C.Lab1 - Dictlim] = C.Reg;
    Plant(Bra, 0, C.Lab1);
    Pflag[Pc - 1] = Longjump;
    Forgetregs();
    Plant(Dc, 0, Temp(Absmode, Litval(Y)));
    return;
  Do_43:;
    if (Pendcond) Flush();
    Updatesp();
    Dx = &Dict[X];
    Dx->Flags = Dx->Flags | Rflag;
    I = Dx->Val;
    Dy = Typecell(Dx->Type);
    Getbounds(Dy->Xtype, Sx, Sy);
    if (Y <= 0) {
      Y = Litval(Y);
      I = I + Y - Sx;
      if (C.Temps) Addimm(C.Temps, A7);
      Plant(Bra, 0, Temp(Labmode, Prog[I]));
      Prog[I] = Dtemp->Val;
    } else {
      Eval(Y, D0b);
      if (I > Pc) {
        C.Forward = C.Forward + (Sy - Sx + 1);
        if (!(Dx->Flags & Arrflag)) {
          if (C.Temps) Addimm(C.Temps, A7);
          Plant(Lea, Temp(Pcmode, 10 - Sx - Sx), A0);
          Plant(Add, D0, D0);
        } else {
          Wx = 12;
          if (C.Temps) {
            Wx += 2;
            if (C.Temps > 8) Wx += 2;
          }
          Plant(Lea, Temp(Pcmode, Wx), A0);
          Srcall(Index);
          if (C.Temps) Addimm(C.Temps, A7);
        }
        Plant(Add + (2 << 8), Tempx(A0, D0), A0);
        Plant(Jmp, 0, A0 + Indir);
        if (Dx->Flags & Arrflag) {
          Store((unsigned)Sy >> 16, 0);
          Store(Sy, 0);
          Store((unsigned)Sx >> 16, 0);
          Store(Sx, 0);
          Store(0, 0);
          Store(2, 0);
        }
        Dx->Val = Pc;
        do {
          Store(Prog[I], 0);
          if (I == Swpc) Swpc++;
          I++;
          Sx++;
        } while (Sx <= Sy);
      } else {
        if (Dx->Flags & Arrflag) I -= 7;
        Plant(Bra, 0, Temp(Labmode, I - 6));
      }
    }
    C.Access = 0;
    return;
  Do_105:;
    if (Y) {
      Updatesp();
      Eval(Y, D0b);
    } else
      Srcall(Asize);
    *Pp = *Pp + 1;
    Dp = &Dict[*Pp];
    Xx = Dp->X;
    Yy = Dp->Y;
    Free = C.Free - D0b;
    Eval(Xx, D1b);
    Eval(Yy, D2b);
    Push(D0);
    Push(D1);
    Push(D2);
    Forgetregs();
    Free = Free | (D1b + D2b);
    Dict[X].Val = C.Sp;
    return;
  Do_103:;
    Updatesp();
    if (X)
      if (X != D0)
        Eval(X, D0b);
      else
        Srcall(Asize);
    if (Y) Push(Y);
    Push(D0);
    return;
  Do_109:;
    Plant(Move, X, D0);
    Srcall(Aget);
    Plant(Move, A7, X);
    if (Y) {
      Dx = &Dict[X];
      Dx->Val = Dx->Val + 4;
      Plant(Move, A7, D0);
      Plant(Add, D0, X);
      Dx->Val = Dx->Val - 4;
    }
    Forget(D0);
    Forget(A0);
    return;
    void Compileentry(int Linked, int Arg) {
      int I;
      int R;
      int Vsp;
      int Lastvsp;
      int Holdsp;
      Identinfo *Darg;
      Identinfo *Tp;
      Holdsp = C.Sp;
      C.Sp = 0;
      Lastvsp = 0;
      if (Linked > 0) C.Stack = C.Stack - 4;
      if (Linked == 0 && (C.Status & Onstack) != 0) {
        C.Sp = 4;
        Holdsp -= 4;
        C.Stack = C.Stack - 4;
      }
      C.Stack = C.Stack - 4;
      if (C.Stack < C.Totstack) C.Totstack = C.Stack;
      if ((Control & Stackbit) != 0 && ((C.Status & Unknown) != 0 || C.Totstack < -128)) {
        Plantlit(Move, C.Stack, Breg);
        Srcall(Stackok);
      }
      if (Level > Outerlevel && Linked > 0)
        if (Level > 1) {
          Plant(Move, Tempd(Gb, Level << 2), Prea7);
          Plant(Move, A7, Tempd(Gb, Level << 2));
        } else {
          Plant(Link, 0, F1);
        }
      Darg = &Dict[Arg];
      for (;;) {
        Arg = Darg->Link;
        if (!Arg) break;
        Darg = &Dict[Arg];
        if (Darg->Val <= 0) {
          Vsp = Darg->Val;
          R = (Darg->Reg & 15) + D0;
          if ((Darg->Flags & Mflag) != 0 || Linked > 0) {
            Addimm(Lastvsp - C.Sp, A7);
            C.Sp = Lastvsp;
            I = Nsize(*Darg);
            if (I > 0)
              Plant(Move + (I << 8), R, Prea7);
            else if (Darg->Flags & Proc) {
              Plant(Move, R, Prea7);
              Plantlit(Movew, 0x4EF9, Prea7);
            } else {
              Tp = Typecell(Darg->Type);
              if ((Tp->Flags & Cat) == Stringy) {
                if ((Control & Capbit) != 0 && Tp->Size() > -256) {
                  Plantlit(Cmp + (1 << 8), -Tp->Size(), R + Indir);
                  Plantlit2(Bcs, 0, 4);
                  Srcall(Check);
                }
                I = C.Sp - Vsp;
                Addimm(-I, A7);
                Extendstack(I);
                Plant(Moveb, R + Indir, Breg);
                Plant(Moveb, Tempx(R, Breg), Tempx2(A7, Breg));
                Plant(Subb, One, Breg);
                Plantlit2(Bcc, 0, -10);
              } else {
                Free = Bregb;
                Pushblock(R, C.Sp - Vsp);
              }
            }
            C.Sp = Vsp;
          }
          Lastvsp = Vsp;
        }
      }
      if (C.Sp) {
        Addimm(Lastvsp - C.Sp, A7);
        C.Sp = Holdsp;
      } else
        C.Sp = Holdsp - Lastvsp;
    }
  Do_50:;
    Compileentry(C.Status & Globbed, C.Dpid);
    return;
  Do_default:
    Intern(8);
  Do_0:;
  }
  void Compile(int Startp) {
    int P;
    if ((Control & Explist) != 0 && (Control & List) != 0) Showexp(Startp);
    if (Faultnum > 0) {
      Np = Np0;
      return;
    }
    Pendcond = 0;
    P = Startp - 1;
    for (;;) {
      Free = C.Free;
      P++;
      if (P >= Np) {
        if (Startp == Np0) {
          Np = Np0;
          if (Pendcond > 0) Flush();
          return;
        }
        Np = Startp;
        Startp = Np0;
        P = Startp;
      }
      if (C.Reg.Line != Line && (Control & (Tracebit | Diagbit | Linebit)) != 0) {
        if (Pendcond > 0) Flush();
        Pendcond = -1;
      }
      Eval(P, Inst);
    }
  }
  void Setfirstentry(void) {
    int J;
    int K;
    int P;
    Identinfo *Dp;
    Firstpos = Dictlim;
    Firstentry = Finalbound;
    P = 0;
    for (;;) {
      P++;
      if (P >= Dlim) break;
      Dp = &Dict[P];
      if (Dp->Mode != Procmode) continue;
      if (Dp->Val >= Firstentry) continue;
      J = Dp->Val;
      if (J <= 0) {
        if (!J) continue;
        K = -J;
        do {
          J = K << 1;
          K = Codeword(J) & 0xFFFF;
        } while (K);
        if (J >= Firstentry) continue;
      }
      Firstentry = J;
      Firstpos = P;
    }
  }
  void Defineentry(int Chain, int Entry, int Pid) {
    int J;
    do {
      Chain = Chain << 1;
      if (Isshort(Entry - Chain) != True) Report(Reacherr, Pid, 0);
      J = Codeword(Chain) & 0xFFFF;
      Shortinteger = Entry - Chain;
      Chain = J;
    } while (Chain);
  }
  void Checkreach(int Blocksize) {
    int I;
    for (;;) {
      I = Blocksize + Cad;
      if (I >= Ownbase) Croak(_imp_str_literal("Program too big"));
      if (I - Firstentry < 31000) return;
      if (Blocksize >= 32000 || Cad - Firstentry >= 32760) return;
      if (Dict[Firstpos].Val < 0) {
        Defineentry(-Dict[Firstpos].Val, Cad, Firstpos);
        Setcodeword(0x6000);
        Dict[Firstpos].Val = (unsigned)-Cad >> 1;
        Setcodeword(0);
      } else {
        Dict[Firstpos].Val = Cad;
        Setcodeword(0x6000);
        Setcodeword(Firstentry - Cad);
      }
      Steps += 2;
      Setfirstentry();
    }
  }
  void Putword(int V) {
    Printsymbol((unsigned)V >> 8 & 255);
    Printsymbol(V & 255);
  }
  void Doexternals(int Chain, int Specs) {
    int K;
    int A;
    int B;
    Identinfo *Dp;
    Identinfo *Tp;
    *Byteinteger(Charlim) = 0;
    Value = 2;
    do {
      Dp = &Dict[Chain];
      A = Dp->Text + Char0;
      B = *Byteinteger(A);
      if (*Byteinteger(A + B + 1) & 128) {
        A = A + B + 1;
        B = *Byteinteger(A) - 128;
      }
      Value += (B + 14) & (~1);
      if (Specs >= 0) {
        Putword(Dp->Flags & (Ext + Proc) | Sign16);
        Putword(Dp->Mode);
        K = 0;
        if (Dp->Flags & Proc) {
          Tp = &Dict[Dp->Type];
          K = 4;
          if (Tp->Type) K = 6;
          for (;;) {
            if (Tp->Reg & 8) K++;
            if (Tp->Link <= 0) break;
            Tp = &Dict[Tp->Link];
            K = K << 1;
          }
          if (K == 9 && Tp->Type == Stringtype && Tp->Flags >= 0) K += 2;
        }
        Putword((unsigned)K >> 16);
        Putword(K);
        Putword((unsigned)Dp->Val >> 16);
        Putword(Dp->Val);
        Putword((B << 8) + *Byteinteger(A + 1));
        for (;;) {
          A += 2;
          B -= 2;
          if (B < 0) break;
          K = *Byteinteger(A) << 8;
          if (B > 0) K += *Byteinteger(A + 1);
          Putword(K);
        }
      }
      Chain = Dp->Link;
    } while (Chain);
    if (Specs >= 0) {
      Putword(0);
      if (Value & 3) Putword(0);
    }
    Value = (Value + 3) & (~3);
  }
  void Putact(int Act, int X, int Y) {
    Dict[Np].Act = Act;
    Dict[Np].X = X;
    Dict[Np].Y = Y;
    Np++;
  }
  void Compileend(void) {
    int I;
    int J;
    int X;
    int Y;
    int Entry;
    int Lim;
    if (C.Reg.Line != Line && (Control & (Diagbit | Linebit | Tracebit)) != 0 && Level > Outerlevel && C.Access != 0) {
      Pendcond = -1;
      Flush();
    }
    if (C.Eventsp) {
      Plant(Move, Temp(C.Mode, C.Eventsp), Gb + Indir);
      Forgetcc();
    }
    Codeflag = '^';
    X = Pc;
    Putact(End, 0, 0);
    Compile(Np0);
    if (Cad & 1) Fillcode(1);
    Checkreach((Pc - C.Localpc) << 1);
    Entry = Cad;
    Y = X;
    while (Y < Pc) {
      if (Pflag[Y] == Indglobal)
        Setcodeword(Dict[Prog[Y]].Val - Cad);
      else
        Setcodeword(Prog[Y]);
      Y++;
    }
    Codeflag = ' ';
    Pc = X;
    if (C.Access) {
      if (Level > Outerlevel && (C.Status & Globbed) != 0)
        if (Level > 1) {
          Plant(Move, Tempd(Gb, Level << 2), A7);
          Plant(Move, Posta7, Tempd(Gb, Level << 2));
          Forgetcc();
        } else
          Plant(Unlk, 0, F1);
      else if (C.Sp < 0)
        Addimm(-C.Sp, A7);
      if (Level > Outerlevel) {
        if (C.Type > 0 && (C.Status & Wrongcc | C.Reg.Ccx | C.Reg.Ccy) == 0) C.Dpid = C.Dpid | Okflag;
        Plant(Rts, 0, 0);
      } else {
        Plant(Move, 0, D0);
        Srcall(Signal);
      }
    } else
      C.Dpid = C.Dpid | Noret;
    X = C.Dpid;
    if (X < 0) Defineentry(-X, Entry, C.Pid);
    C.Dpid = Entry;
    Lim = Cad + ((Pc - C.Localpc - C.Shorts + Zeroshorts) << 1);
    X = C.Localpc;
    C.Shorts = Zeroshorts;
    while (X < Pc) {
      Y = Prog[X];
      J = Pflag[X];
      if (J)
        if (J < Zeroshorts)
          if (J <= Longjump) {
            Jumps++;
            Y = (Y - Pflag[Y] - X + C.Shorts) << 1;
            if (J == Shortjump) {
              Cad -= 2;
              Y = Prog[X - 1] + (Y & 255);
              C.Shorts = C.Shorts + 1;
            }
          } else if (J == Indglobal) {
            I = Dict[Y].Val;
            if (I <= 0) {
              Dict[Y].Val = -((unsigned)Cad >> 1);
              Y = -I;
            } else {
              I -= Cad;
              if (Isshort(I) != True) Report(Reacherr, Y, 0);
              Y = I;
            }
          } else {
            if (J != Global + 1) {
              Y = Y & 0xFFFF;
              if (J != Global) Y += 65536;
            }
            Y -= Cad;
            if (Isshort(Y) != True)
              if ((Prog[X - 1] & 0xF1FF) != 0x41FA)
                Report(Creacherr, 0, Cad);
              else {
                I = Cad;
                Cad = Lim;
                Setcodeword(Prog[X - 1] ^ (0x41FA ^ 0x207C));
                Setcodelongword(Y - 2);
                Setcodeword(Prog[X - 1] ^ (0x41FA ^ 0xD1D7));
                Setcodeword(0x4E75);
                Lim = Cad;
                Cad = I - 2;
                Setcodeword(0x6100);
                Y = Lim - 10 - Cad;
                Steps += 5;
              }
          }
      Shortinteger = Y;
      Cad += 2;
      X++;
    }
    Cad = Lim;
    Forgetall();
  }
  void Topred(void) {
    if (!Item) Item = Litref(Value);
    Putact(Compare, Item, 0);
    Condop = Bne ^ Polarity;
    Item = Np - 1;
  }
  void Resetcontext(int Pid, int Free) {
    Starts = 0;
    Cycles = 0;
    C = 0;
    Forgetall();
    C.Localdpos = Dlim;
    C.Parlim = Dlim;
    C.Localtext = Charlim;
    C.Localpc = Pc;
    C.Localswpc = Swpc;
    C.Lab1 = Curlab;
    C.Shorts = Zeroshorts;
    C.Free = Free;
    C.Mode = Framemode + Level;
    C.Vintage = Vintage;
    C.Pid = Pid;
    C.Dpid = &Dict[C.Pid];
  }
  void Openblock(int Pid) {
    Forgetregs();
    if (Level == Maxlevel) Croak(_imp_str_literal("Too many levels"));
    C.Oldcontrol = Control;
    Hold[Level] = C;
    Level++;
    Vintage++;
    Resetcontext(Pid, C.Free);
    C.Access = 1;
    C.Localad = Cad - Accounted;
  }
  int Parmatch(int Apos, int Bpos) {
    Identinfo *Ap;
    Identinfo *Bp;
    Identinfo *Atp;
    Identinfo *Btp;
    for (;;) {
      Ap = &Dict[Apos];
      Bp = &Dict[Bpos];
      if ((Ap->Flags ^ Bp->Flags) < 0) return (False);
      if (Ap->Type != Bp->Type) {
        Atp = Typecell(Ap->Type);
        Btp = Typecell(Bp->Type);
        if ((Atp->Flags & Cat) != Arry || Arry != (Btp->Flags & Cat)) return (False);
      }
      Apos = Ap->Link;
      Bpos = Bp->Link;
      if (!Apos) {
        if (Bpos) return (False);
        return (True);
      } else if (!Bpos)
        return (False);
    }
  }
  int Crunched(int P) {
    Identinfo *Dq;
    Identinfo *Dp;
    static int Q = 0;
    static int L = 0;
    Dp = &Dict[P];
    Dp->Text = 0;
    Q = 0;
    L = Dp->Link;
    if (L) {
      if (Dp->Type < P) L = Crunched(L);
      if (P <= L) return (P);
      Dp->Link = L;
      Q = L - 1;
    }
    Dq = &Dict[Q];
    while (Q < P) {
      if (Dq->Type == Dp->Type && Dq->Link == L && Dq->Reg == Dp->Reg && Dq->Val == Dp->Val) {
        Dlim = P;
        return (Q);
      }
      Q++;
      Dq = &Dict[Q];
    }
    return (P);
  }
  void Popcontext(void) {
    Pc = C.Localpc;
    Swpc = C.Localswpc;
    Curlab = C.Lab1;
    Dlim = C.Parlim;
    if (Level > Outerlevel) {
      Charlim = C.Localtext;
      while (Ranges >= C.Parlim) Ranges = Dict[Ranges].Hlink;
      C.Dpid = Crunched(C.Dpid);
      Level--;
      C = Hold[Level];
      Control = Control & Editbit | C.Oldcontrol & (~Editbit);
    }
    if (Dictshown > Dlim) Dictshown = Dlim;
    Starts = 0;
    Cycles = 0;
  }
  void Fixupswitchvector(int Pos, Identinfo *Dp) {
    int X;
    int Y;
    int J;
    int Default;
    int Temp;
    int Lo;
    int Hi;
    Identinfo *Tp;
    Tp = Typecell(Dp.Type);
    X = Dp.Val;
    Default = Dp.Link;
    if (!Default) Default = Pc;
    Getbounds(Tp->Xtype, Lo, Hi);
    if (!(Dp.Flags & Arrflag))
      J = Pflag[X - 1] + Lo;
    else
      J = Pflag[X - 7];
    J -= X;
    while (Lo <= Hi) {
      Y = Prog[X];
      if (Y <= 0) {
        if (!Dp.Link) {
          Report(Slabmissing + Warn, Pos, Lo);
          C.Access = 1;
        }
        if (Y < 0) {
          Y = -Y;
          do {
            Temp = Y;
            Y = Prog[Temp];
            Prog[Temp] = Default;
          } while (Y);
        }
        Y = Default;
      }
      Prog[X] = (Y - Pflag[Y] - J) << 1;
      X++;
      Lo++;
    }
  }
  void Closeblock(void) {
    int Miss;
    int Under;
    int Pos;
    int Base;
    Identinfo *Dp;
    if (C.Type > 0 && (C.Status & Wrongcc) == 0) {
      C.Reg.Ccx = 0;
      C.Reg.Ccy = 0;
    }
    if (C.Return) {
      if (C.Return == -(Pc - 1) && C.Access == 0) {
        C.Return = -Prog[Pc - 1];
        Pc -= 2;
      }
      Definejumps(C.Return);
      C.Access = -1;
    }
    Pflag[Pc] = C.Shorts;
    if (C.Status & Hadswitch) {
      Pos = C.Localdpos;
      while (Pos < Dlim) {
        Dp = &Dict[Pos];
        if (Dp->Mode == Labmode && Dp->Type != 0) Fixupswitchvector(Pos, *Dp);
        Pos++;
      }
    }
    Compileend();
    C.Totstack = C.Totstack - C.Extra;
    if (!(C.Status & Unknown)) C.Totstack = -C.Totstack;
    *Typecell(C.Dpid)(C.Dpid).Val = C.Totstack;
    if (Control & Maplist) {
      Putident(C.Pid, 0);
      Markat(20);
      Putstring(_imp_str_literal(" code:"));
      Putnum(Cad - C.Localad - Accounted);
      Putstring(_imp_str_literal("  entry:"));
      Putnum(C.Dpid - C.Localad - Accounted);
      Putstring(_imp_str_literal("  stack:"));
      Putnum(-C.Stack);
      Putsym('/');
      Putnum(Imod(C.Totstack));
      if (C.Totstack < 0) Putsym('+');
      Accounted = Cad - C.Localad;
      Printline();
    }
    Miss = 0;
    Under = 0;
    Base = C.Localdpos;
    if (!Level) Base = 0;
    Pos = Dlim;
    Dp = &Dict[Pos];
    while (Pos > Base) {
      Pos--;
      Dp = &Dict[Pos];
      if (!(Dp->Flags & Ext)) {
        if (Dp->Text > 0) {
          Sethashhead(*String(Dp->Text + Char0));
          if (*Head == Pos) {
            *Head = Dp->Hlink;
          Check:
            if (Dp->Flags & Spec) {
              Dp->Hlink = Miss;
              Miss = Pos;
            } else if ((((Dp->Flags & (Readable + Rflag)) == Readable && Dp->Mode != Litmode) ||
                        ((Dp->Flags & (Writable + Okflag + Wflag + Spec)) == Writable)) &&
                       Pos >= C.Localdpos && Dp->Mode != 0 && (Dp->Flags & Typeid) == 0 &&
                       (Control & (List | Maplist)) != 0) {
              Dp->Hlink = Under;
              Under = Pos;
            }
          }
        }
      } else if (!Level)
        if (!(Dp->Flags & Spec)) {
          Dp->Link = Externs;
          Externs = Pos;
        } else if (Dp->Flags & (Rflag + Wflag)) {
          Dp->Link = Extspecs;
          Extspecs = Pos;
        }
    }
    if (Miss) Report(Idmissing, Miss, 0);
    if (Under != 0 && C.Faults == 0) {
      Putident(Under, 1);
      Putstring(_imp_str_literal(" underused"));
      Printline();
    }
    Popcontext();
    if (Firstpos >= Dlim) Setfirstentry();
  }
  void Error(int Case) {
    Faultp = Atomp;
    Report(Case, 0, 0);
    _imp_signal(11, 0, 0, _imp_str_literal(""));
  }
  static const int Dud = 63;
  void Syntaxerror(void) {
    if (Atom == Dud)
      Error(Atomerr + Point);
    else
      Error(Formerr + Point);
  }
  void Expfault(int Case) {
    if (Faultnum == 0 || Expp < Faultp) {
      Faultnum = Case | Point;
      Faultp = Expp;
    }
  }
  void Nonstandard(int Case) {
    int B;
    static int Hadit = 0;
    B = 1 << Case;
    if ((B & Hadit) == 0 && (Control & Nonsbit) == 0 && Faultnum == 0) {
      Hadit += B;
      Faultp = Atomp;
      if (Control & Strictbit)
        Report(Nonstand + Point, 0, Case);
      else
        Report(Nonstand + Point + Warn, 0, Case);
    }
  }
  void Nameerror(void) {
    if (Item >= 0) {
      Fault(Namerr + Point + Now);
      if (Charmin - Newlen - 80 >= Charlim) {
        Dmin--;
        Dmin0 = Dmin;
        Charmin = Charmin - Newlen - 1;
        *String(Charmin) = *String(Charlim);
        Dict[Dmin].Text = Charmin - Char0;
        while (*Head > 0) Head = &Dict[*Head].Hlink;
        Dict[Dmin].Hlink = *Head;
        *Head = -Dmin;
      }
    } else
      Others++;
    _imp_signal(11, 0, 0, _imp_str_literal(""));
  }
  void Findop(int Mnemonic, int *Op, int *Types) {
    int I;
    I = 0;
    do {
      I += 2;
      if (I > Defmax + Defmax) Error(Namerr);
    } while (Def[I] != Mnemonic);
    *Types = Def[I - 1];
    *Op = (unsigned)I >> 1;
  }
  void Readline(int Flag) {
    if (Faultnum) Report(Faultnum, 0, 0);
    while (Sym > Nl) {
      Sym = *Byteinteger(Fp);
      Fp++;
    }
    Line++;
    while (Fp == Curlim) {
      if (Curlim != Cur->Lim2)
        Fp = Cur->Start2;
      else if (Curfile == Main)
        _imp_signal(12, 0, 0, _imp_str_literal(""));
      else {
        Cur->Flag = -1;
        Curfile--;
        Cur = &File[Curfile];
        Fp = Cur->Fp;
        Line = Cur->Line;
        Control = Fcontrol[Curfile];
        if (Level == Outerlevel && C.Status < Hadon) Inclim = Dlim;
      }
      Curstart = Cur->Start2;
      Curlim = Cur->Lim2;
      if (Fp < Curstart || Fp > Curlim) {
        Curstart = Cur->Start1;
        Curlim = Cur->Lim1;
      }
    }
    Linestart = Fp;
    if (!Flag) {
      Flag = ' ';
      if (Curfile != Main) Flag = '&';
    }
    Listflag = Flag;
    if (Control & List) {
      Time1 -= Cputime;
      if (_imp_strcmp(Rep, _imp_str_literal("")) != 0) Printline();
      if (Control & Dictlist) Showdict(Dictshown);
      Dictshown = Dlim;
      Write(Line, 4);
      Printsymbol(Listflag);
      Printsymbol(' ');
      do {
        Sym = *Byteinteger(Fp);
        Fp++;
        Printsymbol(Sym);
      } while (Sym > Nl);
      Fp = Linestart;
      Time1 += Cputime;
    }
    Sym = 0;
  }
  static const int Casebit = 32;
  static int Percent = 0;
  static int Subatom = 0;
  static const int Keyend = 1;
  static const int Keyrepeat = 2;
  static const int Keyfinish = 3;
  static const int Keyelse = 4;
  static const int Keybegin = 5;
  static const int Exit = 6;
  static const int Keyreturn = 7;
  static const int Tf = 8;
  static const int Keyresult = 9;
  static const int Keystop = 10;
  static const int Keygoto = 11;
  static const int Keysignal = 12;
  static const int Keymonitor = 13;
  static const int Keyon = 14;
  static const int Iu = 15;
  static const int Keywhile = 16;
  static const int Keyuntil = 17;
  static const int Keyfor = 18;
  static const int Keythen = 19;
  static const int Keystart = 20;
  static const int Keycycle = 21;
  static const int Keylabel = 22;
  static const int Keyconst = 23;
  static const int Keyown = 24;
  static const int Keyext = 25;
  static const int Kattrib = 26;
  static const int Ktype = 27;
  static const int Keyinteger = 28;
  static const int Keylong = 29;
  static const int Keyreal = 30;
  static const int Keystring = 31;
  static const int Keyrecord = 32;
  static const int Keyname = 33;
  static const int Keyformat = 34;
  static const int Fnmap = 35;
  static const int Rpred = 36;
  static const int Keyspec = 37;
  static const int Keyarray = 38;
  static const int Keyswitch = 39;
  static const int Keyof = 40;
  static const int Keyfile = 41;
  static const int Keyprogram = 42;
  static const int Keylist = 43;
  static const int Keycontrol = 44;
  static const int Keycomment = 45;
  static const int Keyevent = 46;
  static const int Keyinclude = 47;
  static const int Keyoption = 48;
  static const int Keyalias = 49;
  static const int Keynot = 50;
  static const int Keyand = 72;
  static const int Keyor = 73;
  static const int Terminator = 51;
  static const int Const = 52;
  static const int Ident = 53;
  static const int Modsign = 54;
  static const int Colon = 59;
  static const int Comma = 60;
  static const int Right = 61;
  static const int Rightb = 62;
  static const int Left = 55;
  static const int Leftb = 56;
  static const int Atsign = 57;
  static const int Underline = 58;
  static const int Arrow = 74;
  static const int Eqeq = 75;
  static const int Noteqeq = 76;
  static const int Equals = 77;
  static const int Noteq = 78;
  static const int Lesseq = 79;
  static const int Less = 80;
  static const int Greateq = 81;
  static const int Greater = 82;
  static const int Plus = 83;
  static const int Minus = 84;
  static const int Exclam = 85;
  static const int Exclam2 = 86;
  static const int Dot = 87;
  static const int Star = 88;
  static const int Slash2 = 89;
  static const int Slash = 90;
  static const int Ampersand = 91;
  static const int Star2 = 92;
  static const int Backslash = 93;
  static const int Uparrow = 94;
  static const int Backslash2 = 95;
  static const int Uparrow2 = 96;
  static const int Tilde = 97;
  static const int Lshift = 98;
  static const int Rshift = 99;
  static const int Atommax = 99;
  static const int Aleft = Left;
  static const int Aright = Right;
  static const int Recsub = Underline;
  static const int Over = Slash2;
  static const int Sconc = Dot;
  static const int Simple = Atommax + 1;
  static const int Vsimple = Simple + 1;
  static const int Major = Plus;
  static const int Scond = Arrow;
  static const int Cond = Keyand;
  static const int Condq = 71;
  int Nextatom(void) {
    static int S_sw;
    static void *S[256 /*0:255*/] = {
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_9,       &&S_10,      &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_33,      &&S_34,      &&S_35,      &&S_default, &&S_37,      &&S_38,      &&S_39,
        &&S_40,      &&S_41,      &&S_42,      &&S_43,      &&S_44,      &&S_45,      &&S_46,      &&S_47,
        &&S_48,      &&S_49,      &&S_50,      &&S_51,      &&S_52,      &&S_53,      &&S_54,      &&S_55,
        &&S_56,      &&S_57,      &&S_58,      &&S_59,      &&S_60,      &&S_61,      &&S_62,      &&S_default,
        &&S_64,      &&S_65,      &&S_66,      &&S_67,      &&S_68,      &&S_69,      &&S_70,      &&S_71,
        &&S_72,      &&S_73,      &&S_74,      &&S_75,      &&S_76,      &&S_77,      &&S_78,      &&S_79,
        &&S_80,      &&S_81,      &&S_82,      &&S_83,      &&S_84,      &&S_85,      &&S_86,      &&S_87,
        &&S_88,      &&S_89,      &&S_90,      &&S_91,      &&S_92,      &&S_93,      &&S_94,      &&S_95,
        &&S_default, &&S_97,      &&S_98,      &&S_99,      &&S_100,     &&S_101,     &&S_102,     &&S_103,
        &&S_104,     &&S_105,     &&S_106,     &&S_107,     &&S_108,     &&S_109,     &&S_110,     &&S_111,
        &&S_112,     &&S_113,     &&S_114,     &&S_115,     &&S_116,     &&S_117,     &&S_118,     &&S_119,
        &&S_120,     &&S_121,     &&S_122,     &&S_123,     &&S_124,     &&S_default, &&S_126,     &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
        &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
    };
    static const int Tab = 9;
    static const int Max10 = Maxint / 10;
    static const int Maxdig = Maxint - Max10 * 10;
    int I;
    int J;
    int P;
    int Radix;
    int Hash;
    float Rval;
    static const unsigned char Map[128 /*0:127*/] = {[0 ... 47] = 0,
                                                     '0',
                                                     '1',
                                                     '2',
                                                     '3',
                                                     '4',
                                                     '5',
                                                     '6',
                                                     '7',
                                                     '8',
                                                     '9',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     'a',
                                                     'b',
                                                     'c',
                                                     'd',
                                                     'e',
                                                     'f',
                                                     'g',
                                                     'h',
                                                     'i',
                                                     'j',
                                                     'k',
                                                     'l',
                                                     'm',
                                                     'n',
                                                     'o',
                                                     'p',
                                                     'q',
                                                     'r',
                                                     's',
                                                     't',
                                                     'u',
                                                     'v',
                                                     'w',
                                                     'x',
                                                     'y',
                                                     'z',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     'a',
                                                     'b',
                                                     'c',
                                                     'd',
                                                     'e',
                                                     'f',
                                                     'g',
                                                     'h',
                                                     'i',
                                                     'j',
                                                     'k',
                                                     'l',
                                                     'm',
                                                     'n',
                                                     'o',
                                                     'p',
                                                     'q',
                                                     'r',
                                                     's',
                                                     't',
                                                     'u',
                                                     'v',
                                                     'w',
                                                     'x',
                                                     'y',
                                                     'z',
                                                     0,
                                                     0,
                                                     0,
                                                     0,
                                                     0};
    static const short Syminit[26 /*97:122*/] = {2,   15,  31,  72, 79,  102, 133, 137, 141, 1,   1, 156, 169,
                                                 183, 190, 205, 1,  220, 257, 297, 309, 319, 327, 1, 1,   1};
    static const unsigned char Symbol[340 /*1:340*/] = {
        128, 114, 114, 97,  121, 166, 108, 105, 97,  115, 177, 110, 100, 200, 101, 103, 105, 110, 133, 121, 116, 101,
        155, 111, 111, 108, 101, 97,  110, 155, 111, 110, 116, 105, 110, 117, 101, 134, 121, 99,  108, 101, 149, 104,
        97,  114, 155, 115, 116, 114, 105, 110, 103, 159, 109, 109, 101, 110, 116, 173, 115, 116, 97,  110, 116, 151,
        151, 114, 111, 108, 172, 121, 110, 97,  109, 105, 99,  153, 110, 100, 129, 108, 115, 101, 132, 120, 105, 116,
        134, 118, 101, 110, 116, 174, 116, 101, 114, 110, 97,  108, 153, 105, 110, 105, 115, 104, 131, 97,  108, 115,
        101, 136, 111, 114, 109, 97,  116, 162, 110, 163, 117, 110, 99,  116, 105, 111, 110, 163, 146, 108, 101, 169,
        111, 116, 111, 139, 97,  108, 102, 155, 102, 143, 110, 116, 101, 103, 101, 114, 156, 99,  108, 117, 100, 101,
        175, 97,  98,  101, 108, 150, 111, 110, 103, 157, 105, 115, 116, 171, 111, 110, 105, 116, 111, 114, 141, 105,
        116, 101, 155, 97,  112, 163, 97,  109, 101, 161, 111, 116, 178, 110, 142, 119, 110, 152, 102, 168, 112, 116,
        105, 111, 110, 176, 114, 201, 114, 101, 100, 105, 99,  97,  116, 101, 164, 111, 103, 114, 97,  109, 170, 101,
        112, 101, 97,  116, 130, 111, 117, 116, 105, 110, 101, 164, 116, 117, 114, 110, 135, 115, 117, 108, 116, 137,
        97,  100, 111, 110, 108, 121, 154, 99,  111, 114, 100, 160, 108, 158, 116, 111, 112, 138, 105, 103, 110, 97,
        108, 140, 121, 115, 116, 101, 109, 153, 104, 111, 114, 116, 155, 112, 101, 99,  165, 119, 105, 116, 99,  104,
        167, 97,  114, 116, 148, 114, 105, 110, 103, 159, 114, 117, 101, 136, 104, 101, 110, 147, 101, 120, 116, 155,
        110, 108, 101, 115, 115, 143, 116, 105, 108, 145, 111, 108, 97,  116, 105, 108, 101, 154, 104, 105, 108, 101,
        144, 114, 105, 116, 101, 111, 110, 108, 121, 154};
    static const unsigned char Altdisp[340 /*1:340*/] = {
        0,  5,  0, 0, 0, 0,  5, 0, 0,  0, 0, 0, 0,  0, 5, 0, 0,  0, 0, 4,  0, 0, 9, 0, 0, 0, 0, 0, 0, 15, 8, 23, 28, 34,
        0,  0,  0, 0, 5, 0,  0, 0, 0,  4, 0, 0, 18, 0, 0, 0, 0,  0, 0, 1,  0, 0, 0, 0, 0, 0, 0, 0, 4, 0,  0, 0,  0,  0,
        0,  0,  0, 0, 0, 0,  0, 0, 0,  7, 3, 0, 0,  4, 0, 0, 0,  4, 8, 0,  1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  6,  6,
        27, 0,  0, 0, 0, 5,  0, 0, 0,  0, 6, 0, 14, 0, 0, 0, 2,  0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  0,  0,
        0,  0,  0, 6, 2, 0,  0, 6, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 5,  0, 0, 0, 0, 4, 0, 0, 0, 0, 0,  0, 0,  7,  0,
        0,  0,  0, 0, 0, 4,  0, 0, 12, 0, 0, 1, 4,  0, 0, 0, 0,  0, 0, 2,  0, 3, 0, 0, 2, 0, 6, 0, 0, 0,  0, 0,  0,  0,
        0,  8,  0, 0, 0, 0,  0, 0, 1,  0, 0, 0, 0,  0, 0, 6, 12, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 5, 0,  0, 0,  0,  5,
        0,  0,  0, 0, 7, 11, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 4, 30, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0,  0, 0,  0,  5,
        5,  0,  0, 0, 3, 4,  0, 0, 0,  0, 0, 0, 0,  0, 0, 4, 0,  0, 0, 0,  0, 0, 0, 0, 4, 0, 0, 1, 4, 0,  0, 0,  0,  0,
        0,  25, 0, 5, 0, 0,  0, 1, 0,  0, 0, 1, 0,  0, 0, 0, 0,  0, 0, 2,  5, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0,  0,  1};
    void Getsym(void) {
      do {
        Sym = *Byteinteger(Fp);
        Fp++;
      } while (Sym == ' ');
      I = Sym - '0';
      if (I >= 10) {
        I = (Sym | Casebit) - 'a';
        if (I >= 0) I += 10;
      }
    }
    Matched = 0;
  Again:
  S_9:;
    if (Sym == Nl) Readline(0);
  Again1:;
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
    } while (Sym == ' ');
    Atomp = Fp;
    Atoms++;
    goto *S[S_sw = Sym];
  Linebreak:
  S_10:;
    if (Atom != Comma) return (Terminator);
  Continuation:;
    Readline('+');
    goto Again1;
  S_123:;
    Comments++;
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == Nl) goto Linebreak;
    } while (Sym != '}');
    goto Again;
  S_43:
    return (Plus);
  S_45:
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Arrow);
    }
    if (*Byteinteger(Fp) == Nl) goto Continuation;
    return (Minus);
  S_42:
    return (Star);
  S_47:
    if (*Byteinteger(Fp) == '/') {
      Fp++;
      return (Slash2);
    }
    return (Slash);
  S_92:
    if (*Byteinteger(Fp) == '\\') {
      Fp++;
      return (Backslash2);
    }
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Noteq);
    }
    return (Backslash);
  S_94:
    if (*Byteinteger(Fp) == '^') {
      Fp++;
      return (Uparrow2);
    }
    return (Uparrow);
  S_126:
    return (Tilde);
  S_33:
    if (*Byteinteger(Fp) == '!') {
      Fp++;
      return (Exclam2);
    }
    return (Exclam);
  S_38:
    return (Ampersand);
  S_46:
    if ('0' <= *Byteinteger(Fp) && *Byteinteger(Fp) <= '9') {
      Rval = 0;
      goto Fraction;
    }
    return (Dot);
  S_61:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Eqeq);
    }
    return (Equals);
  S_35:
    if (*Byteinteger(Fp) == '#') {
      Fp++;
      return (Noteqeq);
    }
    return (Noteq);
  S_60:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Lesseq);
    }
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Noteq);
    }
    if (*Byteinteger(Fp) == '<') {
      Fp++;
      return (Lshift);
    }
    return (Less);
  S_62:
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      return (Greateq);
    }
    if (*Byteinteger(Fp) == '>') {
      Fp++;
      return (Rshift);
    }
    return (Greater);
  S_95:
    return (Underline);
  S_58:
    return (Colon);
  S_44:
    return (Comma);
  S_59:
    return (Terminator);
  S_40:
    return (Left);
  S_91:
    return (Leftb);
  S_41:
    return (Right);
  S_93:
    return (Rightb);
  S_124:
    return (Modsign);
  S_64:
    return (Atsign);
  S_77:
  S_109:;
    if (*Byteinteger(Fp) == '\'') {
      Fp++;
      goto Charconst;
    }
  S_65:
  S_66:
  S_67:
  S_68:
  S_69:
  S_70:
  S_71:
  S_72:;
  S_73:
  S_74:
  S_75:
  S_76:
  S_78:
  S_79:
  S_80:;
  S_81:
  S_82:
  S_83:
  S_84:
  S_85:
  S_86:
  S_87:
  S_88:;
  S_89:
  S_90:
  S_97:
  S_98:
  S_99:
  S_100:
  S_101:
  S_102:;
  S_103:
  S_104:
  S_105:
  S_106:
  S_107:
  S_108:
  S_110:;
  S_111:
  S_112:
  S_113:
  S_114:
  S_115:
  S_116:
  S_117:
  S_118:;
  S_119:
  S_120:
  S_121:
  S_122:;
    if (Percent) goto Keyword;
    Newlen = Charlim + 1;
    Hash = Sym | Casebit;
    *Byteinteger(Newlen) = Hash;
    do {
      Sym = *Byteinteger(Fp);
      Fp++;
    } while (Sym == ' ');
    if (Sym == '\'') {
      if (Hash == 'x') {
        Radix = 16;
        goto Ibm;
      }
      if (Hash == 'k') {
        Radix = 8;
        goto Ibm;
      }
      if (Hash == 'b') {
        Radix = 2;
        goto Ibm;
      }
    }
    Sym = Map[Sym];
    if (Sym) do {
        Newlen++;
        *Byteinteger(Newlen) = Sym;
        Hash = Hash << 1 ^ Sym;
        do {
          Sym = *Byteinteger(Fp);
          Fp++;
        } while (Sym == ' ');
        Sym = Map[Sym];
      } while (Sym);
    Fp--;
    Newlen -= Charlim;
    *Byteinteger(Charlim) = Newlen;
    if (Subbed)
      Head = &Dformat->Link;
    else
      Head = &Hashindex[Hash & 255];
    Item = *Head;
    if (Item) do {
        Ditem = &Dict[Imod(Item)];
        if (*String(Ditem->Text + Char0) == *String(Charlim) && (Item > A7 || Item < 0 || (Control & Lowbit) != 0))
          break;
        Item = Ditem->Hlink;
      } while (Item);
    Identatoms++;
    return (Ident);
  S_37:;
    Sym = *Byteinteger(Fp);
    if ('a' > (Sym | Casebit) || (Sym | Casebit) > 'z') goto Again;
    Fp++;
  Keyword:;
    Percent = 0;
    P = Syminit[Sym | Casebit];
    for (;;) {
      while (Symbol[P] == (*Byteinteger(Fp) | Casebit)) {
        P++;
        Fp++;
      }
      if (Symbol[P] > 127) break;
      Atom = Altdisp[P];
      if (!Atom) {
        if ((Sym | Casebit) != 'c' || *Byteinteger(Fp) != Nl) return (Dud);
        goto Continuation;
      }
      P += Atom;
    }
    if ('a' <= (*Byteinteger(Fp) | Casebit) && (*Byteinteger(Fp) | Casebit) <= 'z') Percent = 1;
    Subatom = Altdisp[P];
    Atom = Symbol[P] - 128;
    if (!Atom) return (Dud);
    return (Atom);
  Ibm:;
    Nonstandard(20);
    Item = -1;
    Value = 0;
    goto Ibm1;
  S_48:
  S_49:
  S_50:
  S_51:
  S_52:
  S_53:
  S_54:
  S_55:
  S_56:
  S_57:;
    Item = 0;
    Type = Inttype;
    Radix = 10;
    Value = Sym - '0';
  Ibm1:;
    for (;;) {
      for (;;) {
        do {
          Sym = *Byteinteger(Fp);
          Fp++;
        } while (Sym == ' ');
        I = Sym - '0';
        if (Radix == 10) {
          if (I < 0 || I >= 10) break;
          if (Value > Max10 || (Value == Max10 && I > Maxdig)) Fault(Rangerr + Point + Warn);
          Value = (((Value << 2) + Value) << 1) + I;
        } else {
          if (I >= 10) I = (Sym | Casebit) - 'a' + 10;
          if (I < 0 || I >= Radix) break;
          J = Radix;
          do {
            if (J & 1) I += Value;
            Value = Value << 1;
            J = (unsigned)J >> 1;
          } while (J);
          Value = I;
        }
      }
      if (Sym != '_') break;
      Radix = Value;
      if (!Radix) return (Dud);
      Value = 0;
    }
    if (Item < 0) {
      if (Sym != '\'') return (Dud);
      Item = 0;
    } else {
      J = 0;
      if (Sym == '.') {
        if (Type == Inttype) Rval = Value;
      Fraction:;
        J = 0;
        Type = Realtype;
        for (;;) {
          Getsym();
          if (0 > I || I >= Radix) break;
          Rval = Rval * Radix + I;
          J--;
        }
        if (!J) return (Dud);
      }
      if (Sym == '@') {
        if (Type == Inttype) {
          Type = Realtype;
          Rval = Value;
        }
        Getsym();
        Value = 0;
        if (Sym == '+')
          Getsym();
        else if (Sym == '-') {
          Value = 1;
          Getsym();
        }
        if (0 > I || I >= Radix) return (Dud);
        P = 0;
        do {
          P = P * Radix + I;
          Getsym();
        } while (0 <= I && I < Radix);
        if (Value) P = -P;
        J += P;
      }
      if (Type == Realtype) {
        if (J) Rval = Rval * IEXP(Radix, J);
        if (Type == Realtype) Value = *Integer(Addr(Rval));
      }
      Fp--;
      Sym = 0;
    }
    Litatoms++;
    return (Const);
  S_39:;
  Charconst:;
    Item = 0;
    Type = Inttype;
    Value = 0;
    for (;;) {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == Nl) return (Dud);
      if (Sym == '\'') {
        if (*Byteinteger(Fp) != '\'') break;
        Fp++;
      }
      Value = (Value << 8) + Sym;
    }
    if (Value) return (Const);
    return (Dud);
  S_34:;
    Item = 0;
    Value = Cad;
    Type = Stringtype;
    I = Line;
    J = Linestart;
    P = 0;
    for (;;) {
      Sym = *Byteinteger(Fp);
      Fp++;
      if (Sym == '"') {
        if (*Byteinteger(Fp) != '"') break;
        Fp++;
      }
      P++;
      if (P > 255) {
        Sym = 0;
        Fp = Atomp;
        Linestart = J;
        return (Dud);
      }
      Final[Value + P] = Sym;
      if (Sym == Nl) Readline('"');
    }
    if (P) {
      Final[Value] = P;
      Cad += P + 1;
    } else
      Value = 0;
    Litatoms++;
    return (Const);
  S_default:;
    return (Dud);
  }
  int A(int K) {
    if (Matched) Atom = Nextatom();
    if (K != Atom) return (False);
    Matched = 1;
    return (True);
  }
  void Get(int K) {
    if (Matched) Atom = Nextatom();
    Matched = 1;
    if (Atom == K) return;
    Syntaxerror();
  }
  void Allow(int K) {
    if (A(K) == True)
      ;
  }
  void Getlitstring(void) {
    int Holditem;
    Holditem = Item;
    Get(Const);
    if (Type != Stringtype) Error(Typerr + Point);
    Cad = Value;
    Item = Holditem;
  }
  int Idtext(int F) {
    int K;
    if (Item > 0 && (F & Ext) == 0) return (Ditem->Text);
    Charlim = Charlim + Newlen + 1;
    if (Charlim + 80 >= Charmin) Croak(_imp_str_literal("Identifier space exhausted"));
    K = Charlim - Newlen - 1 - Char0;
    if ((F & Ext) != 0 && A(Keyalias) == True) {
      Getlitstring();
      *String(Charlim) = *String(Final0 + Value);
      *Byteinteger(Charlim) = *Byteinteger(Charlim) + 128;
      Charlim = Charlim + *Byteinteger(Charlim) - 127;
    }
    return (K);
  }
  Objinfo *Details(int F, int T, int M, int V) {
    static Objinfo D = 0;
    D.Flags = F;
    D.Type = T;
    D.Mode = M;
    D.Val = V;
    return (&D);
  }
  void Declare(Objinfo * D) {
    int I;
    Identinfo *Dp;
    Dp = &Dict[Dlim];
    if (!Speccing) {
      if (Item >= C.Localdpos) {
        if ((D.Flags & Spec) == 0 && (Ditem->Flags & Spec) != 0) {
          if ((D.Flags & (Ext + Proc + Typeid)) == (Ditem->Flags & (Ext + Proc + Typeid))) {
            I = Item;
            if (D.Flags & Ext) {
              if (Ditem->Flags & Rflag) goto Ok;
              Ditem->Mode = D.Mode;
              Ditem->Val = D.Val;
              if (A(Keyalias) == True) {
                Getlitstring();
                Item = I;
              }
            }
            if (!(D.Flags & Proc)) Ditem->Flags = Ditem->Flags & (~(Spec + Indirect));
            return;
          }
          if ((Ditem->Flags & (Ext + Proc)) == Proc1 && (D.Flags & Ext) != 0 && (D.Flags & Proc) != 0) {
            Ditem->Flags = Ditem->Flags - Proc1 + (D.Flags & (Ext + Proc));
            Ditem->Text = Idtext(Ext);
            return;
          }
        }
        if (Item < Inclim && (Ditem->Flags & (Rflag + Wflag)) == 0)
          Fault(Duperr + Warn + Point);
        else
          Fault(Duperr + Point);
      }
    Ok:
      Dp->Hlink = *Head;
      *Head = Dlim;
      Dp->Text = Idtext(D.Flags);
    } else {
      Dp->Hlink = 0;
      Dp->Text = 0;
    }
    Item = Dlim;
    Ditem = Dp;
    Ditem->*Details() = *D;
    Dlim++;
    if (Dlim >= Dmin) {
      if (Control & Logbit) Showdict(0);
      Croak(_imp_str_literal("Too many identifiers"));
    }
  }
  void Declareanon(Objinfo * D) {
    Speccing++;
    Item = 0;
    Declare(*D);
    Speccing--;
  }
  void Declaretemp(int T) {
    C.Val = C.Val + 4;
    C.Temps = C.Temps + 4;
    Declareanon(*Details(Okflag + Writable + Readable, T, C.Mode, C.Sp - C.Val));
  }
  void Declarerange(int Type, int Lower, int Upper) {
    int S;
    int Ok(int L, int U) {
      if ((L <= Lower && Upper <= U) || (0 <= Lower && Upper <= U - L)) return (True);
      return (False);
    }
    S = 4;
    if (Ok(-32768, 32767) == True) {
      S = 2;
      if (Ok(-128, 127) == True) S = 1;
    }
    Ditem->*Details() = *Details(Typeid, Type, Absmode, Sign);
    Ditem->Size() = S;
    Declareanon(*Details(Okflag, Type, Litmode, Lower));
    Declareanon(*Details(Okflag, Type, Litmode, Upper));
    Ditem->Hlink = Ranges;
    Ranges = Item;
    Item -= 2;
  }
  static int Literal = 0;
  static int Jammy = 0;
  auto void Getexpression(int Rank, int Etype);
  int Valok(int Wanted, int T) {
    int Lo;
    int Hi;
    int L;
    int H;
    int Wc;
    int Tc;
    Identinfo *Wp;
    Identinfo *Tp;
    if (Wanted == T && T != Recstar) return (True);
    Wp = Typecell(Wanted);
    Tp = Typecell(T);
    Wc = Wp->Flags & (Packed + Cat);
    Tc = Tp->Flags & (Packed + Cat);
    if (Wc == Tc)
      if (!(Wc & Nonord)) {
        if (Wp->Type == Tp->Type) {
          if (Wp->Type == Wanted) return (True);
          if (Dict[Wanted + 1].Mode != Litmode)
            Getbounds(Dict[Wanted + 1].Type, Lo, Hi);
          else
            Lo = Dict[Wanted + 1].Val;
          if (Dict[Wanted + 2].Mode != Litmode)
            Getbounds(Dict[Wanted + 2].Type, Hi, Hi);
          else
            Hi = Dict[Wanted + 2].Val;
          if (!Item) {
            if (Lo <= Value && Value <= Hi) return (True);
            Jammy = Jammy ^ 1;
          } else {
            if (Tp->Type == T) {
              Jammy = Jammy ^ 1;
              return (True);
            }
            if (Dict[T + 1].Mode != Litmode)
              Getbounds(Dict[T + 1].Type, L, H);
            else
              L = Dict[T + 1].Val;
            if (Dict[T + 2].Mode != Litmode)
              Getbounds(Dict[T + 2].Type, H, H);
            else
              H = Dict[T + 2].Val;
            if (L >= Lo) {
              if (H <= Hi) return (True);
              Jammy = Jammy ^ 1;
              if (L <= Hi) return (True);
            } else {
              Jammy = Jammy ^ 1;
              if (H >= Lo) return (True);
            }
          }
          if (Jammy) Expfault(Rangerr);
          return (True);
        }
      } else if (Wc == Realy)
        return (True);
      else if (Wc == Stringy) {
        if (Wanted == Stringstar) return (True);
        if (!Item) {
          if (!Value) return (True);
          L = Final[Value] + 1;
        } else {
          L = Imod(Tp->Size());
          if (!L) L = 256;
        }
        if (L > Imod(Wp->Size()) && Imod(Wp->Size()) != 0) {
          Jammy = Jammy ^ 1;
          if (Item == 0 && Jammy != 0) Expfault(Rangerr);
        }
        return (True);
      } else if ((Wc & Cat) == Arry) {
        if (Wp->Type == Tp->Type && Valok(Wp->Xtype, Tp->Xtype) == True) return (True);
      } else if (Wanted == Recstar) {
        if (T != Recstar) return (True);
      } else if (T == Recstar || (Item | Value) == 0)
        return (True);
      else if (!Tc) {
        if (Wc == Recy && (Item | Value) == 0) return (True);
        if (Wc == Realy) {
          Toreal();
          return (True);
        }
      } else if (Wc == Stringy && T == Chartype) {
        if (!Item) {
          Final[Cad] = 1;
          Final[Cad + 1] = Value;
          Value = Cad;
          Cad += 2;
          Type = Stringtype;
        } else
          Putexp(Dtostring, Normitem(), 0, String1);
        return (True);
      }
    return (False);
  }
  void Getvalue(int Valtype) { Getexpression(Major, Valtype); }
  void Getliteral(int T) {
    Literal++;
    Getexpression(Major, T);
    Literal--;
  }
  void Getmident(int Min, int Max) {
    Get(Ident);
    if (Item <= 0) {
      if (_imp_strcmp(*String(Charlim), _imp_str_literal("sp")) != 0) Nameerror();
      Item = A7;
      Ditem = &Dict[Item];
    }
    if (Ditem->Mode == Litmode) {
      Value = Ditem->Val;
      Item = 0;
    }
    if (Min > Item || Item > Max) Syntaxerror();
  }
  void Getregset(void) {
    int Hold;
    int Set;
    Set = 0;
    do {
      Getmident(D0, A7);
      Hold = Item;
      if (A(Minus) == True) Getmident(Hold, A7);
      do {
        Set = Set | 1 << (Hold - D0);
        Hold++;
      } while (Hold <= Item);
    } while (A(Slash) == True);
    Item = 0;
    Value = Set;
  }
  void Getmcode(void) {
    int Op;
    int X;
    int Y;
    int Types;
    int Opsize(int Okbyte) {
      if (A(Dot) != True) return (0);
      Sym = *Byteinteger(Fp) & (~Casebit);
      Fp++;
      if (Sym == 'L') return (4);
      if (Sym == 'W') return (2);
      if (Sym == Okbyte) return (1);
      Syntaxerror();
    }
    void Getmop(int T, int Dummy, Identinfo *Dp) {
      static const int Hashsign = Noteq;
      int Sign;
      int Hold;
      int Holdval;
      int M;
      if (A(Hashsign) == True) {
        Getliteral(Inttype);
        return;
      }
      Sign = 0;
      Hold = -1;
      Holdval = 0;
      if (A(Minus) == True) Sign = 1;
      if (A(Ident) == True) {
        Matched = 0;
        Getmident(0, Dlim);
        Hold = Item;
        if (Hold) {
          if (Sign) Syntaxerror();
          if (Item > A7) {
            Dp.Flags = Ditem->Flags;
            Dp.Mode = Ditem->Mode;
            Dp.Val = Ditem->Val;
            while (A(Recsub) == True) {
              Dformat = Typecell(Ditem->Type);
              if ((Dformat->Flags & Cat) != Recy || (Ditem->Flags & (Name + Indirect)) != 0) Syntaxerror();
              Subbed = 1;
              Get(Ident);
              Subbed = 0;
              if (Item <= 0) Error(Namerr + Point);
              Dp.Flags = Ditem->Flags;
              Dp.Type = Ditem->Type;
              Dp.Val = Dp.Val + Ditem->Val;
              Item = Dummy;
              Ditem = Dp;
            }
            return;
          }
          if ((Op & 255) == Movem && Item > 0) {
            Matched = 0;
            Getregset();
          }
          return;
        }
        Holdval = Value;
      } else if (A(Const) == True) {
        Hold = 0;
        Holdval = Value;
      }
      if (Sign) Holdval = -Holdval;
      if (A(Left) == True) {
        Getmident(A0, A7);
        if (Hold < 0) {
          Get(Right);
          if (Sign)
            Item += Pre;
          else if (A(Plus) != True)
            Item += Indir;
          else
            Item += Post;
          return;
        }
        M = Item + (Dispmode - A0);
        if (A(Comma) == True) {
          Getmident(D0, A7);
          if (Ismite(Holdval) != True) Fault(Rangerr);
          M += Indexmode - Dispmode;
          Holdval = ((Item - D0) << 12) + (Holdval & 255);
          if (Opsize(0) != 2) Holdval += 0x0800;
        }
        Get(Right);
      } else {
        if (Hold < 0) Syntaxerror();
        M = Absmode;
      }
      Dp.Mode = M;
      Dp.Val = Holdval;
      Item = Dummy;
    }
    static const int Temp = (((((('t' & 31) << 5) + ('e' & 31)) << 5) + ('m' & 31)) << 5) + ('p' & 31);
    Updatesp();
    Atomp = Fp + 1;
    X = 0;
    for (;;) {
      Sym = *Byteinteger(Fp);
      Fp++;
      if ('A' > (Sym & (~Casebit)) || (Sym & (~Casebit)) > 'Z') break;
      Sym = Sym & 31;
      X = (X << 5) + Sym;
    }
    Fp--;
    Sym = 0;
    if (!X) Syntaxerror();
    if (X == Temp) {
      Value = 0;
      if (A(Ident) == True) {
        Matched = 0;
        Getregset();
      }
      C.Free = Value;
      return;
    }
    do
      X = X << 5;
    while (!(X & (31 << 25)));
    X = X | 0xC0000000;
    Findop(X, Op, Types);
    if (Types & (Sized | Asized)) Op += Opsize('B') << 8;
    X = 0;
    Y = 0;
    if ((unsigned)Types >> 6 & 63) {
      Getmop((unsigned)Types >> 6 & 63, Lablim, *Dtemp);
      X = Normitem();
      if (Types & 63) Get(Comma);
    }
    if (Types & 63) {
      Getmop(Types & 63, Lablim + 1, *Dtemp2);
      Y = Normitem();
    }
    Plant(Op, X, Y);
    Forgetregs();
    C.Access = -1;
  }
  int Refok(int Wanted, int T) {
    Identinfo *Wp;
    Identinfo *Tp;
    if (T == Wanted || Wanted == 0 || T == 0 || (Item | Value) == 0) return (True);
    Wp = Typecell(Wanted);
    Tp = Typecell(T);
    if (!((Wp->Flags ^ Tp->Flags) & (Name + Packed + Cat)))
      if ((Wp->Flags & Cat) == Arry) {
        if (Refok(Wp->Type, Tp->Type) == True) return (True);
      } else if ((Wp->Flags & Cat) == Stringy) {
        if (Tp->Size() == 0 || Wp->Size() == 0) return (True);
      } else if (T == Recstar || Wanted == Recstar)
        return (True);
    return (False);
  }
  void Toref(void) {
    if (Item <= 0 || Ditem->Mode < Dispmode) {
      Atomp = Expp;
      Error(Nonref + Point);
    }
    if (Item >= Dictlim)
      ;
    else if (Ditem->Mode == Absmode && Ditem->Flags >= 0) {
      Item = 0;
      Value = Ditem->Val;
      return;
    }
    Item += Ad;
  }
  void Copydown(int Np1) {
    while (Np > Np1) {
      Np--;
      Explo--;
      Dict[Explo] = Dict[Np];
    }
  }
  void Getreference(int Reftype) { Getexpression(Simple, Reftype | Sign16); }
  void Getparlist(int Special) {
    int Procnp;
    int Pact;
    int Hold;
    int Count;
    int Headitem;
    int Arg;
    int P;
    int Q;
    int Restype;
    Identinfo *Hp;
    Identinfo *Tp;
    Identinfo *Darg;
    void Putactual(void) {
      if (!Item) Item = Litref(Value);
      if (!(Count & 1))
        Hold = Item;
      else {
        Putact(Pact, Hold, Item);
        Pact = 0;
      }
      Count++;
    }
    int Noalt(void) {
      if (!(Hp->Flags & Alt)) {
        Expfault(Typerr);
        return (True);
      }
      Item = Hp->Hlink;
      for (;;) {
        if (Item <= 0) {
          Report(Internerr, 0, 6);
          _imp_signal(11, 0, 0, _imp_str_literal(""));
        }
        Ditem = &Dict[Item];
        if (*String(Ditem->Text + Char0) == *String(Hp->Text + Char0)) break;
        Item = Ditem->Hlink;
      }
      Headitem = Item;
      Pact = Headitem;
      Hp = Ditem;
      Arg = Hp->Type;
      Darg = &Dict[Arg];
      Restype = Darg->Type;
      return (False);
    }
    void Putbounds(int Ft, int At) {
      int Maxarg;
      Identinfo *Ftp;
      Identinfo *Atp;
      Identinfo *Fxp;
      Identinfo *Axp;
      Maxarg = Arg;
      do {
        Ftp = Typecell(Ft);
        Atp = Typecell(At);
        if ((Ftp->Flags & Cat) == Stringy) {
          if (Ftp->Size()) break;
          if (Atp->Size())
            Item = Litref(Imod(Atp->Size()));
          else
            Item = At - 1;
          Putactual();
          if (Ft - 1 > Maxarg) Maxarg = Ft - 1;
          break;
        }
        if (Ftp->Xtype >= Arg) {
          Fxp = Typecell(Ftp->Xtype);
          Axp = Typecell(Atp->Xtype);
          if (Dict[Ftp->Xtype + 1].Mode != Litmode) {
            Item = Atp->Xtype + 1;
            if (Dict[Atp->Xtype + 1].Mode == Litmode) {
              Item = 0;
              Value = Dict[Atp->Xtype + 1].Val;
            }
            Putactual();
            if (Ftp->Xtype >= Maxarg) Maxarg = Ftp->Xtype + 1;
          }
          if (Dict[Ftp->Xtype + 2].Mode != Litmode) {
            Item = Atp->Xtype + 2;
            if (Dict[Atp->Xtype + 2].Mode == Litmode) {
              Item = 0;
              Value = Dict[Atp->Xtype + 2].Val;
            }
            Putactual();
            if (Ftp->Xtype + 1 >= Maxarg) Maxarg = Ftp->Xtype + 2;
          }
        }
        Ft = Ftp->Type;
        At = Atp->Type;
      } while (Ft > Arg);
      Arg = Maxarg;
      Darg = &Dict[Arg];
    }
    Count = 0;
    Hold = 0;
    Procnp = Np;
    Headitem = Item;
    Pact = Headitem;
    Hp = Ditem;
    Arg = Hp->Type;
    Darg = &Dict[Arg];
    Restype = Darg->Type;
    if (A(Left) == True) {
      do {
        Arg = Darg->Link;
        if (!Arg) {
          if (!Special) Error(Toomany + Point);
          Getreference(0);
          Value = Item - Ad;
          do
            if (Type == Realtype) {
              if (Restype == Realtype) break;
            } else if (Valok(Type, Restype) == True)
              break;
          while (Noalt() != True);
          Special = 0;
        } else {
          Darg = &Dict[Arg];
          if (Darg->Flags & Proc) {
            Get(Ident);
            if (Item <= 0) Nameerror();
            if ((Ditem->Flags & Proc) == 0 || Parmatch(Darg->Type, Ditem->Type) != True) Fault(Typerr + Point);
            if (Item > Headitem && Ditem->Mode == Procmode) Fault(Classerr + Point);
            Item += Ad;
            Putactual();
          } else if (Darg->Flags >= 0) {
            Jammy = 0;
            Getexpression(Major, 0);
            do
              if (Valok(Darg->Type, Type) == True) break;
            while (Noalt() != True);
            if (Jammy != 0 && (Control & Capbit) != 0 && Category(Darg->Type) < Realy)
              Putexp(Check, Darg->Type, Item, Darg->Type);
            Putactual();
          } else {
            Getreference(0);
            do
              if (Refok(Darg->Type, Type) == True) break;
            while (Noalt() != True);
            Putactual();
            Tp = Typecell(Darg->Type);
            if ((Tp->Flags & Cat) == Arry && Dict[Arg + 1].Type != Darg->Type && Tp->Mode >= Framemode)
              Putbounds(Darg->Type, Type);
          }
        }
      } while (A(Comma) == True);
      if (Darg->Link != 0 || Special != 0) Error(Toofew + Point);
      Get(Right);
    } else if (Darg->Link)
      Error(Toofew + Point);
    if ((Count & 1) != 0 || Count == 0) Putact(Pact, Hold, 0);
    Type = Restype;
    if (Type) {
      if (!(Hp->Flags & Volatile)) {
        P = Explo;
        while (P < Explim) {
          if (Dict[P].Act == Headitem) {
            Item = P;
            Q = Procnp;
            for (;;) {
              if (Dict[P].X != Dict[Q].X || Dict[P].Y != Dict[Q].Y) break;
              P++;
              Q++;
              if (Q >= Np) goto Okf;
            }
          }
          P++;
        }
      }
      Copydown(Procnp);
      Item = Explo;
    Okf:
      Ditem = &Dict[Item];
      Ditem->Flags = Hp->Flags & Heritable;
      Ditem->Mode = 0;
      if (Hp->Flags & Writable) Ditem->Mode = Dispmode;
      Ditem->Type = Type;
      Np = Procnp;
    }
  }
  void Getresolution(int T, int Item1) {
    int Fore;
    int Ftype;
    int S;
    S = Size(T);
    if (!S) S = -256;
    Fore = 0;
    if (A(Left) != True) {
      Getreference(Stringstar);
      Fore = Item;
      Ftype = Type;
      Get(Dot);
      Get(Left);
    }
    Getvalue(Stringtype);
    Get(Right);
    if (!Item) {
      Item = Litref(Value);
      S += Final[Value];
    }
    if (Fore != 0 && S < Size(Ftype) && Size(Ftype) != 0) Fault(Rangerr + Warn);
    Putact(Resolves, Item1 + Ad, Item + Ad);
    Item = 0;
    if (A(Dot) == True) {
      Getreference(Stringstar);
      if (S < Size(Type) && Size(Type) != 0) Fault(Rangerr + Warn);
    }
    Putact(0, Fore, Item);
    Putact(0, 0, 0);
  }
  int Anon(Objinfo * D) {
    Dict[Lablim + 3].*Details() = *D;
    return (Lablim + 3);
  }
  int Aassop(int T) {
    if (T <= 0) {
      if (A(Eqeq) != True) return (False);
    } else {
      if (Matched) Atom = Nextatom();
      if (Atom != Equals) {
        if (Atom != Less || *Byteinteger(Fp) != '-') return (False);
        Jammy = 1;
        Fp++;
      } else
        Jammy = 0;
      Matched = 1;
    }
    return (True);
  }
  void Getexpression(int Rank, int Etype) {
    int Atomp0;
    int Item1;
    int Type1;
    int Cat1;
    int Val1;
    int Double;
    int Op;
    Identinfo *Ditem1;
    Identinfo *Tp;
    static const int Nop = 0;
    void Getrecord(void) {
      int Fid;
      int Ad;
      int Arg;
      int Hold;
      int Count;
      int Max;
      int S;
      Identinfo *Darg;
      Identinfo *Fidp;
      Literal++;
      if (Cad & 1) Fillcode(1);
      Ad = Cad;
      Fid = Item;
      Fidp = Ditem;
      Arg = Fidp->Link;
      Count = 0;
      Max = -1;
      Get(Left);
      for (;;) {
        for (;;) {
          if (Arg <= 0) Error(Toomany + Point);
          Darg = &Dict[Arg];
          if (Ad + Darg->Val - Cad >= 0) break;
          Arg = Darg->Hlink;
        }
        Fillcode(Ad + Darg->Val - Cad);
        if (A(Recsub) == True) {
          Subbed = 1;
          Dformat = Fidp;
          Get(Ident);
          Subbed = 0;
          if (Item < Arg) Nameerror();
          Fillcode(Ditem->Val - Darg->Val);
          Arg = Item;
          Darg = Ditem;
          if (Aassop((Darg->Flags & Name) + Darg->Type) != True) Syntaxerror();
        }
        S = Nsize(*Darg);
        if (A(Comma) != True) {
          Getvalue((Darg->Flags & Name) + Darg->Type);
          if (S > 0)
            if (S == 4)
              Setcodelongword(Value);
            else if (S == 2)
              Setcodeword(Value);
            else {
              Final[Cad] = Value;
              Cad++;
            }
          if (A(Right) == True) break;
          Get(Comma);
        } else if (S > 0)
          Fillcode(S);
        Arg = Darg->Hlink;
      }
      Fillcode(Ad + Imod(Fidp->Val) - Cad);
      Item = 0;
      Value = Ad;
      Literal--;
    }
    void Swop(void) {
      int Temp;
      Temp = Item1;
      Item1 = Item;
      Item = Temp;
      Temp = Val1;
      Val1 = Value;
      Value = Temp;
      Temp = Type1;
      Type1 = Type;
      Type = Temp;
    }
    static const int Intok = 1 << Inty;
    static const int Charok = 1 << Chary;
    static const int Boolok = 1 << Booly;
    static const int Enumok = 1 << Enumy;
    static const int Realok = 1 << Realy;
    static const int Stringok = 1 << Stringy;
    static const int Arrok = 1 << Arry;
    static const int Setok = 1 << Sety;
    static const int Recok = 1 << Recy;
    static const int Pointok = 1 << Pointy;
    static const int Numok = Intok | Realok;
    static const int Ordok = Intok | Charok | Boolok | Enumok;
    static const int Relok = Ordok | Realok | Stringok;
    void Check1(int Ok) {
      Cat1 = Category(Type);
      if (!((unsigned)Ok >> (Cat1 & Cat) & 1))
        if (Cat1 == Inty && (Ok & Realok) != 0) {
          Toreal();
          Cat1 = Realy;
        } else if ((Ok & Stringok) != 0 && Valok(Stringtype, Type) == True)
          Cat1 = Stringy;
        else
          Fault(Typerr + Point);
      Type1 = Type;
      Item1 = Item;
      Val1 = Value;
    }
    int Frozenlit(int T, int V) {
      int Hold;
      int Res;
      Hold = Item;
      Putexp(Move, 0, Litref(V), T);
      Ditem->Flags = Okflag + Wflag;
      Ditem->Mode = Constmode;
      Ditem->Val = V;
      Res = Item;
      Item = Hold;
      return (Res);
    }
    void Coerce(int C) {
      if (C == Inty && Cat1 == Realy)
        Toreal();
      else if (Cat1 == Inty && C == Realy) {
        if (Item1) {
          Val1 = Item;
          Item = Item1;
          Toreal();
          Item1 = Item;
          Item = Val1;
        } else
          *Real(Addr(Val1)) = Val1;
        Type1 = Realtype;
        Cat1 = Realy;
      } else
        Expfault(Typerr);
    }
    void Getarith(int Rank) {
      Getexpression(Rank, 0);
      Rank = Category(Type);
      if (Rank != Cat1) Coerce(Rank);
    }
    int Rcond(int Op) {
      static const int Equal = 0b1001000010;
      static const int Less = 0b1010000001;
      static const int Greater = 0b0101000001;
      int Which;
      int C;
      Check1(Relok);
      Getexpression(Major, 0);
      C = Category(Type);
      if (C != Cat1) Coerce(C);
      if (Equals <= Atom && Atom <= Greater) {
        if (Double >= 0) Syntaxerror();
        Double = Item;
      } else if (Double < 0)
        Double = -2;
      if (!Item1)
        if (!Item) {
          if (Size(Type1) > 0 || (Item1 | Val1) == 0 || (Item | Value) == 0) {
            if (Val1 < Value)
              Which = Less;
            else if (Val1 == Value)
              Which = Equal;
            else
              Which = Greater;
            return ((unsigned)Which >> (Op - Bne) & 1);
          }
          Item1 = Frozenlit(Type1, Val1);
        } else {
          Swop();
          if (Op & 8) Op = Op ^ 3;
        }
      return (Op);
    }
    int Opval(void) {
      static int Op_sw;
      static void *Op[28 /*72:99*/] = {
          &&Op_72, &&Op_73, &&Op_74, &&Op_75, &&Op_76, &&Op_77, &&Op_78, &&Op_79, &&Op_80, &&Op_81,
          &&Op_82, &&Op_83, &&Op_84, &&Op_85, &&Op_86, &&Op_87, &&Op_88, &&Op_89, &&Op_90, &&Op_91,
          &&Op_92, &&Op_93, &&Op_94, &&Op_95, &&Op_96, &&Op_97, &&Op_98, &&Op_99,
      };
      goto *Op[Op_sw = (Atom)-72];
    Op_83:;
      Check1(Numok + Setok);
      Getarith(Star);
      if (!Cat1) {
        if (!Item1) {
          if (!Item) return (Val1 + Value);
          Swop();
        }
        if (!(Item | Value)) return (Nop);
        Type = Inttype;
        return (Add);
      } else {
        if (!Item1) {
          if (!Item) {
            *Real(Addr(Val1)) = *Real(Addr(Val1)) + *Real(Addr(Value));
            return (Val1);
          }
          Swop();
        }
        if (!(Item | Value)) return (Nop);
        return (Fadd);
      }
    Op_84:;
      Check1(Numok + Setok);
      Getarith(Star);
      if (!Cat1) {
        if (!Item1) {
          if (!Item) return (Val1 - Value);
          if (!Val1) {
            Swop();
            return (Neg);
          }
        }
        Type = Inttype;
        if (!Item) {
          if (!Value) return (Nop);
          if (Value != Minint) Value = -Value;
          return (Add);
        }
        return (Sub);
      } else {
        if (!Item) {
          if (!Item1) {
            *Real(Addr(Val1)) = *Real(Addr(Val1)) - *Real(Addr(Value));
            return (Val1);
          }
          if (!Value) return (Nop);
        }
        return (Fsub);
      }
    Op_85:;
      Check1(Intok);
      Getexpression(Star, Inttype);
      if (!Item1) {
        if (!Item) return (Val1 | Value);
        Swop();
      }
      if (!(Item | Value)) return (Nop);
      Type = Inttype;
      return (Or);
    Op_86:;
      Check1(Intok);
      Getexpression(Star, Inttype);
      if (!Item1) {
        if (!Item) return (Val1 ^ Value);
        Swop();
      }
      if (!(Item | Value)) return (Nop);
      Type = Inttype;
      return (Eor);
    Op_91:;
      Check1(Intok);
      Getexpression(Star2, Inttype);
      if (!Item1) {
        if (!Item) return (Val1 & Value);
        Swop();
      }
      if (!(Item | Value)) {
        Item1 = 0;
        return (0);
      }
      Type = Inttype;
      return (And);
    Op_88:;
      Check1(Numok + Setok);
      Getarith(Star2);
      if (!(Item | Value)) {
        Item1 = 0;
        return (0);
      }
      if (!Cat1) {
        if (!Item1) {
          if (!Item) return (Val1 * Value);
          Swop();
        }
        Type = Inttype;
        if (!(Control & Halfbit)) return (Imul);
        return (Muls);
      } else {
        if (!Item1) {
          if (!Item) {
            *Real(Addr(Val1)) = *Real(Addr(Val1)) * *Real(Addr(Value));
            return (Val1);
          }
          Swop();
        }
        return (Fmul);
      }
    Op_89:;
      Check1(Intok);
      Getexpression(Star2, Inttype);
      if (!Item) {
        if (!Value) {
          Fault(Rangerr);
          return (Nop);
        }
        if (!Item1) return (Val1 / Value);
      }
      Type = Inttype;
      return (Idiv);
    Op_90:;
      Check1(Realok);
      Getexpression(Star2, Realtype);
      if (!Item) {
        if (!Value) {
          Fault(Rangerr);
          return (Nop);
        }
        if (!Item1) {
          *Real(Addr(Val1)) = *Real(Addr(Val1)) / *Real(Addr(Value));
          return (Val1);
        }
      }
      return (Fdiv);
    Op_95:
    Op_96:;
      Check1(Intok);
      Getexpression(Simple, Inttype);
      if (!Item) {
        if (!Item1) return (IEXP(Val1, Value));
        if (!Value) {
          Item1 = 0;
          return (1);
        }
        if (Value == 1) return (Nop);
        if (Value == 2) {
          Item = Item1;
          return (Imul);
        }
      }
      Type = Inttype;
      return (Ipow);
    Op_93:
    Op_94:
    Op_92:;
      Check1(Realok);
      Getexpression(Simple, Inttype);
      Type = Realtype;
      if (!(Item | Item1)) {
        *Real(Addr(Val1)) = REXP(*Real(Addr(Val1)), Value);
        return (Val1);
      }
      return (Fpow);
    Op_98:;
      Check1(Intok);
      Getexpression(Simple, Inttype);
      if (!Item) {
        if (!Item1) return (Val1 << Value);
        if (!Value) return (Nop);
      }
      Type = Inttype;
      return (Lsl);
    Op_99:;
      Check1(Intok);
      Getexpression(Simple, Inttype);
      if (!Item) {
        if (!Item1) return ((unsigned)Val1 >> Value);
        if (!Value) return (Nop);
      }
      Type = Inttype;
      return (Lsr);
    Op_97:;
      Check1(Intok);
      Getexpression(Simple, Inttype);
      if (!Item) return (~Value);
      Swop();
      Type = Inttype;
      return (Not);
    Op_87:;
      Check1(Stringok);
      Getexpression(Dot + 1, Stringtype);
      if (!Item) {
        if (!Item1) {
          if (!Value) return (Val1);
          if (!Val1) return (Value);
          if (Final[Val1] + Final[Value] <= 255) {
            *String(Final0 + Val1) = _imp_join(*String(Final0 + Val1), *String(Final0 + Value));
            Cad--;
          } else
            Fault(Rangerr);
          return (Val1);
        }
        if (!Value) return (Nop);
      } else if (!(Item1 | Val1)) {
        Item1 = Item;
        Val1 = Value;
        Type1 = Type;
        return (Nop);
      }
      Type = Stringtype;
      return (Concat);
    Op_77:;
      return (Rcond(Beq));
    Op_78:;
      return (Rcond(Bne));
    Op_79:;
      return (Rcond(Ble));
    Op_80:;
      return (Rcond(Blt));
    Op_81:;
      return (Rcond(Bge));
    Op_82:;
      return (Rcond(Bgt));
      int Racond(int Op) {
        Toref();
        Item1 = Normitem();
        Type1 = Type;
        Getreference(Type1);
        if (!Item1) {
          Val1 = 0;
          Swop();
        }
        if (Arrow <= Atom && Atom <= Greater) Syntaxerror();
        Double = -2;
        return (Op);
      }
    Op_75:;
      return (Racond(Beq));
    Op_76:;
      return (Racond(Bne));
    Op_74:;
      Check1(Stringok);
      if (!Item1) Item1 = Litref(Val1);
      Getresolution(Type, Item1);
      Item1 = Np - 3;
      Condop = Bne ^ Polarity;
      Type1 = Booltype;
      return (Nop);
    Op_72:;
      if (!Condop) Topred();
      Item1 = Np;
      Type1 = Booltype;
      Putact((Condop ^ Polarity ^ 1) + (Polarity << 7), Item, 0);
      Condop = 0;
      Getexpression(Scond, Booltype);
      Dict[Item1].Y = Item;
      if (A(Keyor) == True) Syntaxerror();
      return (Nop);
    Op_73:;
      if (!Condop) Topred();
      Item1 = Np;
      Type1 = Booltype;
      Putact((Condop ^ Polarity) + ((Polarity ^ 1) << 7), Item, 0);
      Condop = 0;
      Getexpression(Scond, Booltype);
      Dict[Item1].Y = Item;
      if (A(Keyand) == True) Syntaxerror();
      return (Nop);
    }
    if (Matched) Atom = Nextatom();
    Atomp0 = Atomp;
    Jammy = Jammy << 1;
    if (Atom == Ident) {
      Matched = 1;
      if (Item <= 0 || (Ditem->Mode == Labmode && Item < C.Localdpos)) Nameerror();
      if (Item >= Dlim0) Fault(Namerr + Point);
      Type = Ditem->Type;
      if (Ditem->Flags & Typeid)
        if ((Ditem->Flags & Cat) == Recy && Item > Dnil) {
          Getrecord();
          return;
        } else {
          Item1 = Item;
          Ditem1 = Ditem;
          if (A(Less) == True) {
            Getvalue(0);
            Get(Greater);
            Type = Item1;
          } else {
            Get(Left);
            Getvalue(Inttype);
            Get(Right);
            Putexp2(Storemap, Item1, Item1);
            Ditem->Flags = Writable | Readable;
            Ditem->Mode = Dispmode;
          }
        }
      else if (Ditem->Mode == Litmode) {
        Item = 0;
        Value = Ditem->Val;
      } else
        for (;;)
          if (Ditem->Flags & Proc)
            if (Item == Daddr || Item == Dsizeof || Item == Dnew) {
              Get(Left);
              if (Item == Daddr) {
                Getreference(0);
                Type = Inttype;
              } else {
                Item1 = Item;
                Getreference(0);
                Value = Imod(Size(Type));
                if (!Value) Expfault(Sizerr);
                if (Item1 == Dsizeof) {
                  Item = 0;
                  Type = Inttype;
                } else {
                  Putexp(Dnew, 0, Litref(Value), 0);
                  Ditem->Mode = Dispmode;
                }
              }
              Get(Right);
            } else {
              Getparlist(0);
              if (!Type) {
                Atomp = Atomp0;
                Error(Classerr + Point);
              }
            }
          else {
            if (Matched) Atom = Nextatom();
            if (Aleft > Atom || Atom > Recsub || Rank > Simple) break;
            if (Atom == Aleft) {
              do {
                Item1 = Item;
                Ditem1 = Ditem;
                Tp = Typecell(Type);
                if ((Tp->Flags & Cat) == Stringy) {
                  Matched = 1;
                  Nonstandard(2);
                  Getvalue(Bytetype);
                  Putexp2(Sindex, Item1, Chartype);
                } else {
                  if ((Tp->Flags & Cat) != Arry) goto Out;
                  Matched = 1;
                  Getvalue(Tp->Xtype);
                  Putexp2(Index, Item1, Tp->Type);
                }
                Ditem->Flags = Ditem1->Flags & Heritable;
                Ditem->Mode = Ditem1->Mode;
              } while (A(Comma) == True);
              Ditem->Flags = Ditem->Flags + (Tp->Flags & Name);
              Get(Right);
            } else if (Atom == Recsub) {
              Item1 = Item;
              Ditem1 = Ditem;
              Dformat = Typecell(Ditem->Type);
              if ((Dformat->Flags & Cat) != Recy) Syntaxerror();
              Matched = 1;
              Subbed = 1;
              Get(Ident);
              Subbed = 0;
              if (Item <= 0) Error(Namerr + Point);
              Val1 = Ditem1->Flags & Heritable | Ditem->Flags;
              Putexp2(Recref, Item1, Ditem->Type);
              Ditem->Flags = Val1;
              Ditem->Mode = Ditem1->Mode;
            } else if (Atom == Atsign) {
              Nonstandard(4);
              if (!(Ditem->Flags & Typeid)) Syntaxerror();
              Matched = 1;
              Ditem1 = Ditem;
              Item1 = Item;
              Getexpression(Vsimple, Inttype);
              Putexp2(Storemap, Item1, Item1);
              Ditem->Flags = Writable | Readable;
              Ditem->Mode = Dispmode;
            } else {
              if (Ditem->Mode < Dispmode) Error(Nonref + Point);
              if (!Size(Ditem->Type)) Fault(Sizerr);
              Matched = 1;
              Ditem1 = Ditem;
              Item1 = Item;
              Getvalue(Inttype);
              Get(Rightb);
              Putexp2(Prel, Item1, Ditem1->Type);
              Ditem->Flags = Writable | Readable;
              Ditem->Mode = Ditem1->Mode;
            }
          }
    } else if (Atom == Const)
      Matched = 1;
    else if (Atom == Minus) {
      Item = 0;
      Value = 0;
      Type = Inttype;
    } else if (Atom == Left) {
      Matched = 1;
      if (Rank < Major)
        Getexpression(Condq, 0);
      else
        Getexpression(Major, 0);
      Get(Right);
    } else if (A(Keynot) == True) {
      if (Rank >= Major) Syntaxerror();
      Polarity = Polarity ^ 1;
      Getexpression(Scond, Booltype);
      if (!Item) Value = Value ^ 1;
      Polarity = Polarity ^ 1;
    } else if (Atom == Backslash) {
      Item = 0;
      Value = 0;
      Type = Inttype;
      Atom = Tilde;
    } else if (A(Modsign) == True) {
      Getexpression(Major, 0);
      if (Valok(Inttype, Type) == True)
        if (!Item) {
          if (Value < 0)
            if (Value != Minint)
              Value = -Value;
            else
              Expfault(Rangerr);
        } else
          Putexp2(Iabs, 0, Inttype);
      else if (Valok(Realtype, Type) == True)
        Putexp2(Fabs, 0, Realtype);
      else
        Error(Typerr + Point);
      Get(Modsign);
    } else
      Syntaxerror();
  Out:;
    if (Matched) Atom = Nextatom();
    if (Etype < 0) {
      Expp = Atomp0;
      Jammy = (unsigned)Jammy >> 1;
      if (Item | Value) {
        Toref();
        if (Refok(Etype - Sign16, Type) != True) Expfault(Typerr);
      } else {
        Atomp = Atomp0;
        Nonstandard(21);
      }
    } else {
      while (Atom >= Rank) {
        Matched = 1;
        Double = -1;
        Op = Opval();
        if (!(Item1 | Item)) {
          if (Double != -1) {
            if (Double >= 0) {
              Literal++;
              Op = Op & Opval();
              Literal--;
            }
            Type = Booltype;
          }
          Value = Op;
        } else if (Double == -1)
          if (Op) {
            if (!Item1) Item1 = Litref(Val1);
            Putexp(Op, Item1, Normitem(), Type);
          } else {
            Item = Item1;
            Type = Type1;
          }
        else {
          Condop = Op ^ Polarity;
          Putact(Compare, Item1, Normitem());
          Item = Np - 1;
          if (Double >= 0) {
            Putact((Condop ^ Polarity ^ 1) + (Polarity << 7), Np - 1, Np + 1);
            Item = Double;
            Matched = 1;
            Op = Opval();
            if (!(Item1 | Item)) Error(Nonliteral);
            Condop = Op ^ Polarity;
            Putact(Compare, Item1, Normitem());
            Item = Np - 2;
          }
          Type = Booltype;
        }
      }
      Expp = Atomp0;
      Jammy = (unsigned)Jammy >> 1;
      if (Etype) {
        if (Type == Booltype)
          if ((Rank == Cond || Rank == Scond) && Condop == 0) Topred();
        if (Valok(Etype, Type) != True) Expfault(Typerr);
      }
    }
    if (Literal != 0 && Item != 0) {
      Atomp = Expp;
      Error(Nonliteral + Point);
    }
  }
  void Getcondition(void) {
    int Maxlab;
    int Condnp;
    void Assignlabels(int P, int Lab, int Pol) {
      int Base;
      Identinfo *Dp;
      Base = Maxlab;
      while ((P - Condnp) & 1) {
        Dp = &Dict[P];
        P = Dp->Y;
        if ((Dp->Act & 1 << 7) == Pol)
          Assignlabels(Dp->X, Lab, Pol);
        else {
          Maxlab = Base + 1;
          Assignlabels(Dp->X, Maxlab, Pol ^ 1 << 7);
        }
      }
      Dp = &Dict[P + 1];
      if (!Dp->Act) Dp = &Dict[P + 3];
      if (Maxlab > Base) {
        Dp->X = Maxlab;
        Maxlab = Base;
      } else
        Dp->X = 0;
      Dp->Y = Lab;
      Dp->Act = Dp->Act & 127;
    }
    Condnp = Np;
    Polarity = Subatom;
    Condop = 0;
    Getexpression(Cond, Booltype);
    Putact(Condop ^ 1, Item, 0);
    if (Faultnum > 0) return;
    Maxlab = Curlab + 1;
    Assignlabels(Item, Maxlab, 0);
  }
  void Dodynamicarrays(void) {
    Updatesp();
    C.Mode = C.Mode | 0b01000000;
    C.Status = C.Status | Globbed;
    while (C.Dynarray) {
      if (C.Dynarray < 0)
        Putact(Aget, -C.Dynarray, One);
      else
        Putact(Aget, C.Dynarray, 0);
      C.Dynarray = Dict[Imod(C.Dynarray)].Link;
    }
    Compile(Np0);
  }
  void Getstatements(int Stopper) {
    static int Initial_sw;
    static void *Initial[100 /*0:99*/] = {
        &&Initial_default, &&Initial_1,       &&Initial_2,       &&Initial_3,       &&Initial_4,
        &&Initial_5,       &&Initial_6,       &&Initial_7,       &&Initial_8,       &&Initial_9,
        &&Initial_10,      &&Initial_11,      &&Initial_12,      &&Initial_13,      &&Initial_14,
        &&Initial_15,      &&Initial_16,      &&Initial_default, &&Initial_18,      &&Initial_default,
        &&Initial_default, &&Initial_21,      &&Initial_22,      &&Initial_23,      &&Initial_24,
        &&Initial_25,      &&Initial_26,      &&Initial_27,      &&Initial_28,      &&Initial_29,
        &&Initial_30,      &&Initial_31,      &&Initial_32,      &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_36,      &&Initial_default, &&Initial_default, &&Initial_39,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_43,      &&Initial_44,
        &&Initial_45,      &&Initial_default, &&Initial_47,      &&Initial_48,      &&Initial_default,
        &&Initial_default, &&Initial_51,      &&Initial_default, &&Initial_53,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_57,      &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_63,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_74,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_85,      &&Initial_86,      &&Initial_default, &&Initial_88,      &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
        &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default, &&Initial_default,
    };
    int Forinf;
    int Endval;
    int Loopstart;
    void Thisisinst(void) {
      if (C.Status < Hadinst) {
        C.Status = C.Status + Hadinst;
        if (!Stopper) Fault(Ordererr);
      }
      if (C.Access == 0 && Np == Np0) Fault(Accesserr + Warn);
      if (C.Dynarray) Dodynamicarrays();
    }
    void Putact2(int Act, int Item1) { Putact(Act, Item1, Normitem()); }
    void Getresult(void) { Getvalue(C.Type); }
    void Getinstruction(void) {
      int Item1;
      Identinfo *Tp;
      Thisisinst();
      do
        if (A(Ident) == True) {
          if (Item <= 0) Nameerror();
          if (Ditem->Flags & (Writable | Typeid)) {
            Matched = 0;
            Getexpression(Simple, 0);
            Item1 = Item;
            if (A(Equals) == True) {
              Jammy = 0;
              Getvalue(Type);
              Putact2(Okass + Jammy, Item1);
            } else if (A(Eqeq) == True) {
              if (Ditem->Flags >= 0) Syntaxerror();
              Getreference(Type);
              Putact2(Assign, Item1 + Ad);
            } else if (Atom == Less && *Byteinteger(Fp) == '-') {
              Fp++;
              Matched = 1;
              Jammy = 1;
              Getvalue(Type);
              Putact2(Jamass + Jammy, Item1);
            } else {
              if (A(Arrow) != True) Syntaxerror();
              Getresolution(Type, Item1);
              Putact(Bne, 0, Curlab);
              Putact(Signal, Litref(7), Undef);
              Putact(0, Undef, Undef);
            }
          } else {
            if (!(Ditem->Flags & Proc)) Error(Classerr + Point);
            Tp = Typecell(Ditem->Type);
            if (Tp->Type) {
              Getparlist(Tp->Type);
              Putact2(Assign, Value);
            } else
              Getparlist(0);
          }
        } else {
          if (Np == Np0) C.Access = 0;
          if (A(Keymonitor) == True) {
            C.Access = 1;
          } else if (A(Exit) == True) {
            if (!C.Looplab)
              Fault(Notinloop + Point);
            else
              Putact(Jumpout, C.Looplab, C.Looplab + Subatom);
            break;
          } else if (A(Keyreturn) == True) {
            Item = 0;
            Value = 0;
            if (C.Type) Getresult();
            Putact2(Return, 0);
            break;
          } else if (A(Keyresult) == True) {
            if (!C.Type) Error(Notinfun + Point);
            if (Aassop(C.Type) != True) Syntaxerror();
            Getresult();
            Putact2(Return, 0);
            break;
          } else if (A(Tf) == True) {
            if (C.Type != Booltype)
              Fault(Notinpred + Point);
            else
              Putact(Return, 0, Litref(Subatom));
            break;
          } else if (A(Arrow) == True || A(Keygoto) == True) {
            if (Atom == Keygoto) Nonstandard(5);
            Get(Ident);
            if (*Byteinteger(Fp) != '(') {
              if (Item < C.Localdpos || Ditem->Type != 0) Declare(Forwardlabel);
              Putact2(Goto, 0);
            } else {
              if (Item < C.Localdpos) Nameerror();
              if (Ditem->Mode != Labmode || Ditem->Type == 0) Error(Classerr + Point);
              Item1 = Item;
              Get(Left);
              Getvalue(*Typecell(Ditem->Type)(Ditem->Type).Xtype);
              Get(Right);
              Putact2(Swgoto, Item1);
            }
            break;
          } else if (A(Keystop) == True) {
            Putact(Stop, 0, 0);
            break;
          } else if (A(Keysignal) == True) {
            C.Access = 1;
            Allow(Keyevent);
            Getliteral(Inttype);
            if (0 > Value || Value > 15) Expfault(Rangerr);
            Item1 = Litref(Value);
            Item = Undef;
            if (A(Comma) == True) {
            L1:
              if (A(Comma) == True)
                Matched = 0;
              else
                Getvalue(Bytetype);
            }
            Putact2(Signal, Item1);
            Item = Undef;
            if (A(Comma) == True) {
            L2:
              if (A(Comma) == True)
                Matched = 0;
              else
                Getvalue(Inttype);
            }
            Item1 = Normitem();
            Item = Undef;
            if (A(Comma) == True) Getvalue(Stringtype);
            Putact2(0, Item1);
            break;
          } else
            Syntaxerror();
        }
      while (A(Keyand) == True);
    }
    void Getforclause(void) {
      int Loopvar;
      int Lvtype;
      int K;
      int S;
      int Start;
      int Sval;
      int I;
      int Inc;
      int Ival;
      int E;
      int N;
      int End;
      Identinfo *Tp;
      Forinf = 0;
      Get(Ident);
      if (Item <= 0) Nameerror();
      Lvtype = Ditem->Type;
      Tp = Typecell(Lvtype);
      if (Tp->Flags & Nonord) Fault(Typerr + Point);
      Loopvar = Item;
      Get(Equals);
      Getvalue(Lvtype);
      Start = Item;
      Sval = Value;
      Get(Comma);
      Getvalue(Lvtype);
      Inc = Item;
      Ival = Value;
      if (Inc == 0 && 0 == Ival) {
        Expfault(Rangerr);
        Ival = 1;
      }
      K = Undef;
      if (Start >= Np0 && Dict[Start].Act == Add) K = Dict[Start].Y;
      if (!Inc) {
        I = Litref(Ival);
        if (!Start) {
          Sval -= Ival;
          Item = Litref(Sval);
        } else if (K <= 0) {
          K = Litval(K) - Ival;
          Item = Dict[Start].X;
          if (K) Putexp(Add, Item, Litref(K), Inttype);
        } else
          Putexp(Add, Start, Litref(-Ival), Inttype);
      } else {
        I = Inc;
        if (Control & Volbit) {
          Declaretemp(Inttype);
          I = Item;
          Putact(Assign, I, Inc);
          Forinf -= 4;
        }
        if (Start == Inc) {
          Item = 0;
          Sval = 0;
        } else if (K == Inc)
          Item = Dict[Start].X;
        else {
          Item = Start;
          if (!Item) Item = Litref(Sval);
          Putexp(Sub, Item, I, Inttype);
        }
      }
      S = Item;
      Get(Comma);
      Getvalue(Lvtype);
      End = Item;
      if (!End) {
        E = Litref(Value);
        Endval = Value;
      } else {
        E = Item;
        if (Control & Volbit) {
          Declaretemp(Inttype);
          E = Item;
          Putact(Assign, E, End);
          Forinf -= 4;
        }
      }
      if ((Start | Inc | End) != 0 && (Control & Loopbit) != 0) {
        Putact(Forass, Loopvar, S);
        Putact(Forass, I, E);
      } else
        Putact(Assign, Loopvar, S);
      Putact(Label, Curlab, 0);
      if (!(Start | Inc | End)) {
        K = Endval - Sval;
        N = K / Ival;
        if (!N) {
          Fault(Dubious + Warn);
          Putact(Else, 0, Curlab + 1);
          return;
        }
        if (N < 0) Fault(Boundserr);
        if (N * Ival != K) Fault(Unending);
        Forinf = Loopvar;
      } else {
        Putact(Compare, Loopvar, E);
        Putact(Beq, 0, Curlab + 1);
      }
      Putact(Incass, Loopvar, I);
    }
    void Getloopbody(void) {
      int Hold;
      Hold = C.Looplab;
      C.Looplab = Curlab;
      Curlab += 2;
      Getstatements(Keyrepeat);
      Curlab -= 2;
      C.Looplab = Hold;
    }
    void Getswitchindex(void) {
      int I;
      int Lo;
      int Hi;
      Identinfo *Dp;
      Identinfo *Tp;
      void Setlabel(short *P) {
        Value = *P;
        if (Value > 0) Expfault(Duperr);
        Setuserlabel(Value);
        *P = Value;
      }
      Dp = Ditem;
      Tp = Typecell(Ditem->Type);
      Get(Left);
      if (A(Star) == True)
        Setlabel(Dp->Link);
      else {
        Getvalue(Tp->Xtype);
        if (Tp->Xtype > Inttype && Faultnum == 0) {
          Getbounds(Tp->Xtype, Lo, Hi);
          I = Value - Lo + Dp->Val;
          if (I < Pc) C.Forward = C.Forward - 1;
          Setlabel(Prog[I]);
        }
      }
      Get(Right);
    }
    if (_imp_on_event(1, 11, 12)) {
      if (!Event.Event()) {
        if (Event.Sub) exit(0);
        _imp_signal(14, 0, 0, _imp_str_literal(""));
      }
      if (Event.Event() == Done) {
        if (Stopper) Croak(_imp_str_literal("Premature end of input"));
        Closeblock();
        C.Dpid = 0;
        return;
      }
      if (Event.Event() == Oflow) Fault(Rangerr + Now);
      goto Ignore;
    }
  Next:;
    Statements++;
    if (Np > Np0) Compile(Startnp);
    if (Dict[Curlab].Val < 0) Definelabel(Curlab);
    if (Dict[Curlab + 1].Val < 0) Definelabel(Curlab + 1);
  Next1:;
    if (Faultnum) Report(Faultnum, 0, 0);
    Dlim0 = Dlim;
    Speccing = 0;
    Subbed = 0;
    Literal = 0;
    Jammy = 0;
    Condop = 0;
    Dict[Curlab].Val = 0;
    Dict[Curlab + 1].Val = 0;
    Np = Np0;
    Startnp = Np0;
    Maxcalldreg = Maxdreg;
    Maxcallareg = Maxareg;
    if (Explo < Np0 + 50) {
      Zaps++;
      Forgetall();
    }
    if (Litpos > Litmax - 40) {
      Zaps += 1000;
      Forgetall();
    }
    Value = 0;
  Initial_51:;
    Atom = Nextatom();
    Matched = 1;
    goto *Initial[Initial_sw = Atom];
  Initial_45:
  Initial_85:
  Initial_86:;
    Comments++;
    Readline(0);
    goto Next1;
  Term:;
    Get(Terminator);
    goto Next;
  Ignore:;
    C.Access = -1;
    if (Atom != Terminator) {
      do {
        Subatom = Atom;
        Atom = Nextatom();
      } while (Atom != Terminator);
      if (Subatom == Keystart) Starts++;
      if (Subatom == Keycycle) Cycles++;
    }
    goto Next1;
  Initial_63:;
    Syntaxerror();
  Initial_default:;
    Error(Nonstarter + Point);
  Initial_53:;
    if (*Byteinteger(Fp) == ':') {
      Fp++;
      Declare(Definedlabel);
      Setuserlabel(Ditem->Val);
      goto Next;
    }
    if (Item <= 0) Nameerror();
    if (Ditem->Mode == Labmode && Ditem->Type != 0) {
      Literal = 1;
      Getswitchindex();
      Get(Colon);
      goto Next;
    }
  Initial_7:
  Initial_9:
  Initial_8:;
  Initial_10:
  Initial_12:
  Initial_13:;
  Initial_6:
  Initial_11:
  Initial_74:;
    Matched = 0;
    Getinstruction();
    if (A(Terminator) == True) goto Next;
    C.Access = 1;
    if (A(Iu) == True) {
      Startnp = Np;
      Getcondition();
    } else if (A(Keywhile) == True) {
      Putact(Repeat, Curlab, 0);
      Startnp = Np;
      Definelabel(Curlab);
      Getcondition();
    } else if (A(Keyfor) == True) {
      Putact(0, 0, 0);
      Putact(0, 0, 0);
      Putact(Repeat, Curlab, 0);
      Startnp = Np;
      Getforclause();
      Value = Np;
      Np = Startnp - 3;
      if (Forinf > 0) {
        Putact(Compare, Forinf, Litref(Endval));
        Putact(Beq, 0, Curlab);
      } else
        Np += 2;
      Putact(Repeat, Curlab, Forinf);
      Np = Value;
    } else {
      if (A(Keyuntil) != True) Syntaxerror();
      Getcondition();
      Putact(Repeat, Curlab, 0);
      Definelabel(Curlab);
    }
    goto Term;
  Initial_15:;
    Thisisinst();
    do {
      Getcondition();
      if (A(Keythen) == True && A(Keystart) != True)
        Getinstruction();
      else {
        Matched = 0;
        Get(Keystart);
        for (;;) {
          Get(Terminator);
          Curlab += 2;
          Getstatements(Keyelse);
          Curlab -= 2;
          if (Atom != Keyelse) break;
          Putact(Else, Curlab + 1, Curlab);
          if (A(Iu) != True) goto Exit2;
          Getcondition();
        }
        if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
      }
      if (A(Keyelse) != True) goto Term;
      Putact(Else, Curlab + 1, Curlab);
    } while (A(Iu) == True);
    if (A(Keystart) != True)
      Getinstruction();
    else {
    Exit2:;
      Get(Terminator);
      Curlab += 2;
      Getstatements(Keyfinish);
      Curlab -= 2;
      if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
    }
    goto Term;
  Initial_21:;
    Thisisinst();
    if (A(Terminator) == True) {
      Definelabel(Curlab);
      Getloopbody();
      if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
      if (A(Keyuntil) == True) Getcondition();
      Putact(Repeat, Curlab, 0);
      goto Term;
    }
    Nonstandard(22);
    Getforclause();
    goto For1;
  Initial_16:;
    Thisisinst();
    Definelabel(Curlab);
    Getcondition();
    Get(Keycycle);
    Get(Terminator);
    Compile(Np0);
    Getloopbody();
    if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
    if (A(Keyuntil) == True) {
      Nonstandard(6);
      Getcondition();
    }
    Putact(Repeat, Curlab, 0);
    goto Term;
  Initial_18:;
    Thisisinst();
    Getforclause();
    Get(Keycycle);
  For1:;
    Get(Terminator);
    Compile(Np0);
    if (Forinf > 0) {
      Loopstart = Dict[Curlab].Val;
      Dict[Curlab].Val = 0;
    }
    Getloopbody();
    if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
    if (Forinf > 0) {
      Definelabel(Curlab);
      Dict[Curlab].Val = Loopstart;
      Putact(Compare, Forinf, Litref(Endval));
      Putact(Beq, 0, Curlab);
    }
    Putact(Repeat, Curlab, Forinf);
    goto Term;
  Initial_14:;
    if (C.Status >= Hadon || Stopper == 0) Fault(Ordererr + Point);
    if (C.Dynarray) Dodynamicarrays();
    C.Status = C.Status | Hadon;
    Matched = 1;
    Allow(Keyevent);
    Dump = 0;
    do {
      Getliteral(Inttype);
      if (0 > Value || Value > 15) Expfault(Rangerr);
      Dump = Dump | 1 << Value;
    } while (A(Comma) == True);
    Get(Keystart);
    Putact(Settrap, 0, Litref(Dump));
    Curlab += 2;
    Getstatements(Keyfinish);
    Curlab -= 2;
    if (Atom == Keyend) goto *Initial[Initial_sw = Keyend];
    goto Term;
  Initial_4:;
    if (Starts) goto Ignore;
    if (Stopper == Keyelse) return;
    if (Stopper == Keyfinish) Error(Noif);
  Initial_3:;
    if (Starts) {
      Starts--;
      goto Ignore;
    }
    if (Stopper == Keyfinish || Stopper == Keyelse) return;
    Error(Nostart);
  Initial_2:;
    if (Cycles) {
      Cycles--;
      goto Ignore;
    }
    if (Stopper == Keyrepeat) return;
    Error(Nocycle);
  Initial_88:;
    if (!(Control & Lowbit)) {
      Fault(Lowlevel + Warn + Point);
      Control = Control | Lowbit;
    }
    Matched = 1;
    if (*Byteinteger(Fp) == '=') {
      Fp++;
      Getliteral(Inttype);
      Plant(Dc, 0, Temp(Absmode, Value));
    } else
      Getmcode();
    goto Term;
    void Declarelitrange(int Basetype, int Lo, int Hi) {
      static Objinfo D = 0;
      if (Lo > Hi) {
        Fault(Boundserr);
        Hi = Lo;
      }
      Item = Ranges;
      do {
        Ditem = &Dict[Item];
        if (Ditem->Val == Hi && Ditem->Type == Basetype && Dict[Item - 1].Val == Lo) {
          Item -= 2;
          return;
        }
        Item = Ditem->Hlink;
      } while (Item);
      Declareanon(D);
      Declarerange(Basetype, Lo, Hi);
    }
    void Declarestringtype(int Size) {
      if (Size == -256) {
        Item = Stringtype;
        return;
      }
      if (Size == -2) {
        Item = String1;
        return;
      }
      Item = Ranges;
      do {
        Ditem = &Dict[Item];
        if (Ditem->Size == Size && Ditem->Type == Chartype) return;
        Item = Ditem->Hlink;
      } while (Item);
      Declareanon(*Details(Typeid + Stringy, Chartype, 0, 0));
      Ditem->Size = Size;
      Ditem->Hlink = Ranges;
      Ranges = Item;
    }
    void Getlitrange(int Basetype) {
      int Holdval;
      Getliteral(Basetype);
      Holdval = Value;
      Get(Colon);
      Getliteral(Basetype);
      Declarelitrange(Basetype, Holdval, Value);
    }
    void Getidentlist(Objinfo * D) {
      Dlim0 = Dlim;
      do {
        Get(Ident);
        Declare(*D);
      } while (A(Comma) == True);
    }
    void Recalign(int *Val) {
      Align(*Val, 2);
      if (*Val > 4) *Val = -*Val;
    }
    void Getdeclaration(int Flags, int Mode, int *Disp, int Depth) {
      Objinfo Decl;
      Identinfo *Dfhold;
      static int Itemtype = 0;
      static int Itemsize = 0;
      static int Adim = 0;
      int Base;
      int Hold;
      int Max;
      int Stmax;
      int Dreg;
      int Areg;
      auto void Getvarbound(void);
      void Getdatatype(void) {
        static int S_sw;
        static void *S[7 /*27:33*/] = {
            &&S_27, &&S_28, &&S_29, &&S_30, &&S_31, &&S_32, &&S_33,
        };
        if (Matched) Atom = Nextatom();
        if (Kattrib > Atom || Atom > Keyname) Syntaxerror();
        Matched = 1;
        goto *S[S_sw = (Atom)-27];
      S_27:;
        Itemtype = Inttype + Subatom;
        Itemsize = Size(Itemtype);
        if (Itemtype >= Mitetype) Nonstandard(7);
        Allow(Keyinteger);
        return;
      S_28:;
        Itemtype = Inttype;
        Itemsize = 4;
        if (A(Left) == True) {
          Nonstandard(8);
          Getlitrange(Inttype);
          Get(Right);
          Itemtype = Item;
          Itemsize = *Typecell(Itemtype)(Itemtype).Size();
        }
        return;
      S_29:;
        Itemtype = Inttype;
        Itemsize = 4;
        if (A(Keyinteger) == True)
          Fault(Notin + Point + Warn);
        else {
          Itemtype = Realtype;
          Get(Keyreal);
        }
        return;
      S_30:;
        Itemtype = Realtype;
        Itemsize = 4;
        return;
      S_31:;
        Itemsize = 0;
        if (A(Left) == True) {
          Atom = Nextatom();
          if (A(Star) == True)
            Itemtype = Stringstar;
          else {
            Getliteral(Bytetype);
            Itemsize = -(Value + 1);
            Declarestringtype(Itemsize);
            Itemtype = Item;
          }
          Get(Right);
        } else {
          if (Mode != Constmode) Syntaxerror();
          Itemtype = Stringtype;
        }
        return;
      S_32:;
        Get(Left);
        if (A(Star) != True) {
          if (A(Ident) != True) {
            Declareanon(Typeident);
            Hold = Item;
            Dfhold = Dformat;
            Dformat = Ditem;
            Getdeclaration(Writable + Readable, 0, Dformat->Val, 0);
            Recalign(Dformat->Val);
            Ditem = Dformat;
            Dformat = Dfhold;
            Item = Hold;
          }
          if (Item <= 0) Nameerror();
          if ((Ditem->Flags & (~Spec)) != Typeid + Recy) Error(Classerr + Point);
          Itemtype = Item;
          Itemsize = Ditem->Val;
        } else {
          Itemtype = Recstar;
          Itemsize = 0;
        }
        Get(Right);
        return;
      S_33:;
        Itemtype = 0;
        Matched = 0;
      }
      void Assignaddress(int Size) {
        void Assignstackaddress(void) {
          Align(Stmax, 2);
          Ditem->Val = Stmax;
          Stmax += Imod(Size);
          if (Depth == 1 && Speccing == 0) C.Status = C.Status | Onstack;
        }
        if (Ditem->Flags & (Name + Indirect)) Size = -4;
        if (Depth) {
          Dlink->Link = Item;
          Dlink = Ditem;
          if (Size > 0) {
            if (Dreg > Maxcalldreg) {
              Assignstackaddress();
              return;
            }
            if (!Speccing) C.Reg.Content = Item;
            Ditem->Reg = Dreg - D0;
            Dreg++;
          } else {
            if (Areg > Maxcallareg) {
              Assignstackaddress();
              Ditem->Reg = 8;
              return;
            }
            if (Speccing == 0 && Ditem->Flags < 0) C.Reg.Content = Item + Ad;
            Ditem->Reg = Areg - D0;
            Areg++;
          }
        }
        Size = Imod(Size);
        Align(*Disp, Size);
        Ditem->Val = *Disp;
        if (Constmode != Ditem->Mode && Ditem->Mode != Ownmode) {
          *Disp = *Disp + Size;
          if (Ditem->Mode >= Framemode) {
            Align(*Disp, 2);
            Ditem->Val = C.Sp - *Disp;
          }
        }
      }
      void Getqident(void) {
        Get(Ident);
        if (!Mode) {
          Head = &Dformat->Link;
          Item = *Head;
          if (Item > 0) do {
              Ditem = &Dict[Item];
              if (*String(Ditem->Text + Char0) == *String(Charlim)) Fault(Duperr + Point);
              Head = &Ditem->Hlink;
              Item = *Head;
            } while (Item > 0);
        }
        Declare(Decl);
      }
      void Dumpconst(int V, int N) {
        int I;
        int J;
        int K;
        int Kk;
        int Vv;
        K = Itemsize;
        if (K <= 0) {
          K = -K;
          if (!K) K = Final[V] + 1;
          if (V) Cad = V;
        }
        Kk = K;
        if (N < 1) return;
        if (N > 1) Kk = Kk * N;
        if (Mode == Constmode) {
          I = Cad;
          Cad += Kk;
          if (Cad >= Ownbase) Croak(_imp_str_literal("Program too big"));
        } else {
          if (Ownbase + Ownad + Kk - Finalbound > 0) Makeroom(Ownbase + Ownad + Kk - Finalbound);
          I = Ownbase + Ownad;
          Ownad += Kk;
        }
        if (Itemsize <= 0)
          while (N > 0) {
            N--;
            J = I + K;
            if (V) {
              Vv = V;
              do {
                Final[I] = Final[Vv];
                I++;
                Vv++;
              } while (I != J);
            } else
              while (I < J) {
                Final[I] = 0;
                I++;
              }
          }
        else
          while (N > 0) {
            N--;
            if (Itemsize >= 2) {
              if (Itemsize > 2) {
                Final[I] = (unsigned)V >> 24;
                Final[I + 1] = (unsigned)V >> 16;
                I += 2;
              }
              Final[I] = (unsigned)V >> 8;
              I++;
            }
            Final[I] = V;
            I++;
          }
      }
      void Getvarbound(void) {
        int F;
        F = Decl.Flags;
        Getdatatype();
        Decl.Flags = Okflag + Mflag;
        Decl.Type = Itemtype;
        Get(Ident);
        Declare(Decl);
        Decl.Flags = F;
        Assignaddress(Itemsize);
      }
      void Declarebound(int Mode, int Val) {
        Declareanon(*Details(Okflag, Inttype, Mode, Val));
        if (Depth != 0 && Mode >= Framemode) {
          Ditem->Flags = Ditem->Flags | Mflag;
          Assignaddress(4);
        }
      }
      void Getarraydeclaration(int Dim) {
        int Pos;
        int Dlim1;
        int Holdval;
        int Holdz;
        int Jam;
        int Elements;
        int Tot;
        int Totsize;
        int Lo1;
        int Size1;
        Identinfo *Dp;
        static Objinfo Atype = 0;
        int Xtype(void) {
          Declareanon(*Details(Typeid, Inttype, 0, 0));
          return (Item);
        }
        void Stringstararray(void) {
          if (!Depth) Fault(Notin + Point);
          Declareanon(*Details(Okflag + Mflag + Inty, Inttype, Mode, 0));
          Tot = Item;
          Assignaddress(4);
          Declareanon(*Details(Typeid + Stringy, Inttype, 0, 0));
          Atype.Type = Item;
          Elements = Maxint;
        }
        void Getrest(void) {
          int E;
          int R;
          int Lo;
          int Loval;
          int Hi;
          int Hival;
          R = 0;
          if (Matched) Atom = Nextatom();
          if (Decl.Flags < 0)
            if (Depth > 0 && Ktype <= Atom && Atom <= Keyinteger) {
              R = Xtype();
              Getvarbound();
            } else
              Getliteral(Inttype);
          else
            Getvalue(Inttype);
          Loval = Value;
          Lo = Item;
          if (Lo) Loval = Minint;
          Get(Colon);
          if (Matched) Atom = Nextatom();
          if (Decl.Flags < 0)
            if (Depth > 0 && Ktype <= Atom && Atom <= Keyinteger) {
              if (!R) {
                R = Xtype();
                Declarebound(Litmode, Loval);
              }
              Getvarbound();
            } else if ((Dim | R) == 0 && A(Star) == True) {
              Item = 0;
              Value = Maxint;
            } else {
              Getliteral(Inttype);
              if (R) Declarebound(Litmode, Value);
            }
          else
            Getvalue(Inttype);
          Hival = Value;
          Hi = Item;
          if (Hi) Hival = Maxint;
          E = Maxint;
          if (!R) {
            if (!(Lo | Hi)) {
              if ((Hival ^ Loval) >= 0 || Minint + Hival - Loval < 0) E = Hival - Loval;
              if (E != Maxint) E++;
              if (Hival == Maxint) E = 0;
              Declarelitrange(Inttype, Loval, Hival);
            } else {
              Declareanon(Typeident);
              Declarerange(Inttype, Loval, Hival);
            }
            R = Item;
          }
          Elements = E;
          if (A(Comma) == True) {
            Dim++;
            Getrest();
            if (Elements != Maxint && E != Maxint)
              Elements = Elements * E;
            else
              Elements = Maxint;
          }
          Atype.Xtype() = R;
          Size1 = Totsize;
          Lo1 = Loval;
          if (Atype.Type == Stringstar) Stringstararray();
          if (Elements == Maxint) {
            Atype.Mode = Mode;
            Declareanon(Atype);
            Atype.Type = Item;
            if (Decl.Flags >= 0 || (Depth == 1 && Speccing == 0)) {
              if (!Lo) Lo = Litref(Loval);
              if (!Hi) Hi = Litref(Hival);
              if (!Tot) Tot = Litref(Totsize);
              Putact(Asize, Item, Tot);
              Putact(0, Lo, Hi);
              if (Decl.Flags >= 0) {
                Compile(Np0);
                if (Lo > 0) {
                  Dict[R + 1].Mode = C.Mode;
                  Dict[R + 1].Val = C.Sp + 4;
                }
                if (Hi > 0) {
                  Dict[R + 2].Mode = C.Mode;
                  Dict[R + 2].Val = C.Sp;
                }
              }
            }
            Tot = 0;
            Totsize = 0;
          } else {
            Item = 0;
            for (;;) {
              Ditem = &Dict[Item];
              if (Ditem->Type == Atype.Type && Ditem->Xtype() == Atype.Xtype() && Ditem->Flags == Atype.Flags) break;
              Item++;
              if (Item == Dlim) {
                Declareanon(Atype);
                break;
              }
            }
            Atype.Type = Item;
            Totsize = Totsize * E;
          }
        }
        void Putbounds(void) {
          int I;
          I = Xtype();
          Declarebound(Mode, 0);
          Declarebound(Mode, 0);
          Dim--;
          if (Dim > 0) Putbounds();
          if (Atype.Type == Stringstar) Stringstararray();
          Atype.Xtype() = I;
          Declareanon(Atype);
          if (!Speccing) {
            if (!Tot) Tot = Litref(Totsize);
            Putact(Asize, Item, Tot);
            Putact(0, I + 1, I + 2);
          }
          Tot = 0;
          Totsize = 0;
          Lo1 = Minint;
          Atype.Type = Item;
        }
        Pos = Dlim0;
        Dlim1 = Dlim;
        Dp = Ditem;
        Atype.Flags = Typeid + Arry + Okflag;
        Atype.Type = Itemtype;
        if (Atype.Type < 0) {
          Atype.Flags = Atype.Flags + Name;
          Atype.Type = Atype.Type - Name;
        }
        Atype.Mode = Constmode;
        Tot = 0;
        Totsize = Imod(Itemsize);
        if (Dim > 0) {
          Atype.Mode = Mode;
          Putbounds();
          Elements = Maxint;
        } else {
          Getrest();
          Get(Right);
        }
        Dp->Type = Atype.Type;
        if (Mode != Constmode && Mode != Ownmode) {
          Holdval = D0;
          while (Pos != Dlim1) {
            Dp = &Dict[Pos];
            Dp->Type = Atype.Type;
            if (Mode >= Framemode) {
              if (Lo1 == Minint || Size1 == 0) Dp->Flags = Dp->Flags | Arrflag;
              if (Decl.Flags >= 0) {
                if (Totsize != 0 && (Totsize << 1) - C.Sp + *Disp <= 32000) {
                  *Disp = *Disp + Totsize;
                  Align(*Disp, 2);
                } else {
                  if (C.Mode & 0b01000000) Fault(Ordererr);
                  if (Totsize) {
                    C.Extra = C.Extra + Totsize;
                    Holdval = Litref(Totsize);
                  }
                  Holdz = 0;
                  if (!(Dp->Flags & Arrflag)) Holdz = Litref(-Lo1 * Size1);
                  Putact(Adok, Holdval, Holdz);
                  Compile(Np0);
                  Dp->Flags = Dp->Flags + Indirect;
                  Dp->Link = C.Dynarray;
                  C.Dynarray = Pos;
                  if (Holdz) C.Dynarray = -C.Dynarray;
                  C.Status = C.Status | Unknown;
                  Holdval = 0;
                }
                Dp->Val = C.Sp - *Disp;
              }
            } else {
              Dp->Val = *Disp;
              if (Decl.Flags < 0)
                *Disp = *Disp + 4;
              else
                *Disp = *Disp + Totsize;
            }
            Pos++;
          }
        } else if (Decl.Flags & (Name + Indirect))
          if (Mode == Constmode)
            Fillcode(4);
          else
            Fillown(4);
        else {
          if (Aassop(Itemtype) == True) {
            Jam = Jammy;
            Dp->Flags = Dp->Flags | Okflag;
            Allow(Terminator);
            do {
              Jammy = Jam;
              Getvalue(Itemtype);
              if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
              Holdval = Value;
              Value = 1;
              if (A(Left) == True) {
                Value = Elements;
                if (A(Star) != True) Getliteral(Halftype);
                Get(Right);
              }
              Elements -= Value;
              if (Elements < 0) Value += Elements;
              Dumpconst(Holdval, Value);
            } while (A(Comma) == True);
            if (Faultnum == 0 && Elements != 0)
              if (Elements < 0)
                Report(Counterr, Pos, Elements);
              else
                Report(Counterr + Warn, Pos, Elements);
          }
          if (Elements > 0) Dumpconst(0, Elements);
        }
      }
      void Getproceduredeclaration(void) {
        int Pos;
        int Dlim1;
        int Argmode;
        int Argad;
        int Restype;
        int Stack;
        Identinfo *Headditem;
        Identinfo *Dhold;
        int Dupok(void) {
          Identinfo *Tp;
          if (!(Ditem->Flags & Proc)) return (False);
          Tp = Typecell(Ditem->Type);
          if (!Restype) {
            if (Tp->Type != 0 || Tp->Link == 0) return (False);
          } else {
            if (Restype == Tp->Type) return (False);
          }
          return (True);
        }
        Restype = Itemtype;
        Stack = 0;
        Decl.Flags = Decl.Flags & (~Okflag);
        Decl.Type = Procstar;
        if (Depth) {
          Decl.Flags = Decl.Flags | Proc2;
        } else if (Mode >= Framemode) {
          Decl.Mode = Procmode;
          Decl.Val = 0;
          Decl.Flags = Decl.Flags | Proc1;
          if (A(Keyspec) == True) Decl.Flags = Decl.Flags | Spec;
        } else if (Mode == Ownmode) {
          Decl.Mode = Procmode;
          Decl.Val = 0;
          if (A(Keyspec) == True) {
            Decl.Mode = Ownmode;
            Decl.Flags = Decl.Flags | Spec;
          }
        } else {
          Decl.Flags = Decl.Flags | Proc1;
          Decl.Val = *Disp;
          Stack = 4;
        }
        if ((Decl.Flags & Ext) != 0 && A(Keyalias) == True) {
          Nonstandard(9);
          Get(Ident);
          if (Item <= 0)
            Fault(Namerr + Point);
          else if (Dupok() == True) {
            Item = 0;
            Decl.Flags = Decl.Flags | Alt;
          }
        } else
          Get(Ident);
        Declare(Decl);
        Headditem = Ditem;
        if (Depth) Assignaddress(-6);
        Argmode = (C.Mode & (~0b01000000)) + 1;
        if ((Decl.Flags & Spec) != 0 || Decl.Mode != Procmode)
          Speccing++;
        else {
          if (Ditem->Flags & Rflag) C.Forward = C.Forward - 1;
          Openblock(Item);
          C.Type = Restype;
          if (Decl.Flags & Writable) C.Type = C.Type | Sign16;
        }
        Dlim1 = Dlim;
        Declareanon(*Details(0, Restype, 0, Stack));
        if ((Decl.Flags & Writable) != 0 || Size(Restype) <= 0) Ditem->Reg = 8;
        Argad = C.Sp;
        if (A(Left) == True) {
          Dhold = Dlink;
          Dlink = Ditem;
          Getdeclaration(Okflag + Writable + Readable, Argmode, Argad, 1);
          Dlink = Dhold;
          Get(Right);
        }
        if (Speccing) {
          Speccing--;
          Pos = Crunched(Dlim1);
          if (Pos < Dlim1 || Speccing == 0)
            Headditem->Type = Pos;
          else {
            Fault(Classerr);
            Dlim = Dlim1;
          }
        } else {
          if (C.Dpid & Spec) {
            C.Dpid = C.Dpid - Spec;
            if (Parmatch(C.Dpid, Dlim1) != True)
              if (C.Pid == Dlim1 - 2)
                Fault(Matcherr + Warn);
              else
                Fault(Matcherr);
          }
          Headditem->Type = Dlim1;
          C.Parlim = Dlim;
          C.Sp = -Argad;
          Compile(Np0);
          Get(Terminator);
          Getstatements(Keyend);
        }
      }
      void Getinitialvalue(Identinfo * Dp) {
        int Present;
        Present = 0;
        Jammy = 0;
        if (Aassop(Itemtype) == True) {
          Getvalue(Itemtype);
          Dp.Flags = Dp.Flags | Okflag;
          Present = 1;
        }
        if (Mode >= Framemode) {
          if (Present) {
            if (Item) {
              Atomp = Expp;
              Nonstandard(1);
            }
            if (Itemtype < 0)
              Putact(Okass, Dlim0 + Ad, Normitem());
            else
              Putact(Okass + Jammy, Dlim0, Normitem());
            Compile(Np0);
          }
        } else if (Mode == Constmode) {
          if (!Present) Syntaxerror();
          if (Itemtype < 0) {
            Dp.Flags = Writable + Readable;
            Dp.Mode = Absmode;
            Dp.Val = Value;
          } else {
            if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
            if (Itemsize <= 0)
              Dumpconst(Value, 1);
            else {
              Dp.Mode = Litmode;
              Dp.Val = Value;
            }
          }
        } else if (Present) {
          if (Faultnum == Rangerr + Point) Faultnum = Rangerr + Point + Warn;
          Dumpconst(Value, 1);
        } else if (Itemtype < 0)
          Fillown(4);
        else
          Fillown(Imod(Itemsize));
      }
      Dreg = D0;
      Areg = A0;
      Stmax = 8;
      Max = 0;
      Base = *Disp;
      do {
        *Disp = Base;
        for (;;) {
          Decl = 0;
          Decl.Flags = Flags;
          Decl.Mode = Mode;
          Adim = -1;
          while (A(Kattrib) == True) Decl.Flags = Decl.Flags ^ (1 << Subatom);
          if (Depth == 0 && A(Left) == True) {
            Align(*Disp, 2);
            Getdeclaration(Flags, Mode, *Disp, 0);
            Get(Right);
          } else if (A(Rpred) == True) {
            if (Subatom) {
              Decl.Flags = Decl.Flags & (~(Writable));
              if (Control & Volbit) Decl.Flags = Decl.Flags | Volatile;
              Itemtype = Booltype;
            } else {
              Decl.Flags = Decl.Flags & (~(Writable + Readable));
              Itemtype = 0;
            }
            Getproceduredeclaration();
            if (!Depth) return;
          } else {
            Getdatatype();
            if (A(Fnmap) == True) {
              if (Control & Volbit) Decl.Flags = Decl.Flags | Volatile;
              if (!Subatom) {
                Decl.Flags = Decl.Flags & (~Writable);
                if (!Itemsize) Fault(Illstarred);
              }
              Getproceduredeclaration();
              if (!Depth) return;
            } else {
              Decl.Flags = Decl.Flags & (~Proc);
              Decl.Type = Itemtype;
              if (A(Keyname) == True) {
                Decl.Flags = Decl.Flags + Name;
                Itemtype += Name;
                Itemsize = 4;
              }
              if (A(Keyarray) == True) {
                if (Itemtype == Recstar) Fault(Illstarred);
                Adim = 0;
                Decl.Flags = Decl.Flags & (~Name);
                Decl.Type = Arrstar;
                if (Control & Arrbit) Decl.Flags = Decl.Flags | Arrflag;
                if (A(Left) == True) {
                  if (!Depth) Fault(Notin + Point);
                  Getliteral(Inttype);
                  if (Value & (~7))
                    Expfault(Rangerr);
                  else
                    Adim = Value;
                  Get(Right);
                  Get(Keyname);
                  Matched = 0;
                }
                if (A(Keyname) == True) Decl.Flags = Decl.Flags + Name;
              }
              if (Itemsize == 0 && Decl.Flags >= 0 && Disp != &Jokerad && Decl.Type != Stringtype) Fault(Illstarred);
              if (Disp == &C.Val) {
                if (!Stopper) Fault(Notinblock);
                if (C.Status >= Hadon)
                  if ((C.Forward | C.Return) != 0 || Curlab != C.Lab1)
                    Fault(Ordererr);
                  else if (!(C.Status & Hadordererr)) {
                    Fault(Ordererr + Warn);
                    C.Status = C.Status + Hadordererr;
                  }
              } else if ((Decl.Flags & Ext) != 0 && A(Keyspec) == True)
                Decl.Flags = Decl.Flags | (Spec + Indirect);
              do {
                Dlim0 = Dlim;
                if (Decl.Type != Arrstar) {
                  Getqident();
                  Assignaddress(Itemsize);
                  if (Mode >= Ownmode && Depth == 0)
                    if (!(Decl.Flags & Spec))
                      Getinitialvalue(*Ditem);
                    else {
                      Setownword(0);
                      Setownword(0);
                    }
                } else {
                  for (;;) {
                    Getqident();
                    Assignaddress(0);
                    if (A(Comma) != True) break;
                    Atom = Nextatom();
                    if (Atom != Ident) {
                      if (!Adim) {
                        if (Decl.Flags >= 0) Syntaxerror();
                        Adim = 1;
                      }
                      Getarraydeclaration(Adim);
                      goto Exit22;
                    }
                  }
                  if (Adim != 0 || A(Left) != True) {
                    if (!Adim) {
                      if (Decl.Flags >= 0) Syntaxerror();
                      Adim = 1;
                    }
                    Getarraydeclaration(Adim);
                    goto Exit2;
                  }
                  Getarraydeclaration(Adim);
                }
                if (A(Comma) != True) goto Exit2;
                Atom = Nextatom();
              } while (Atom == Ident);
            Exit22:;
              continue;
            }
          }
          if (A(Comma) != True) break;
        }
      Exit2:;
        if (*Disp > Max) Max = *Disp;
      } while (A(Keyor) == True);
      *Disp = Max;
    }
  Initial_23:;
    Literal = 1;
    Getdeclaration(Okflag + Readable, Constmode, Cad, 0);
    goto Term;
  Initial_57:;
    Dump = 0;
  Atted:;
    if (!(Control & Lowbit)) {
      Fault(Lowlevel + Warn + Point);
      Control = Control | Lowbit;
    }
    Getliteral(Inttype);
    Jokerad = Value;
    if (A(Left) == True) {
      Getmident(A0, A7);
      Get(Right);
      Value = Item + (Dispmode - A0);
    } else
      Value = Absmode;
    Literal = 1;
    Getdeclaration(Dump | (Okflag + Writable + Readable), Value, Jokerad, 0);
    goto Term;
  Initial_24:;
    Literal = 1;
    Getdeclaration(Writable + Readable, Ownmode, Ownad, 0);
    goto Term;
  Initial_25:;
    if (Level) Fault(Ordererr);
    Literal = 1;
    Dump = Subatom << 12;
    if (A(Atsign) == True) goto Atted;
    if (A(Left) == True) {
      Getliteral(Inttype);
      Get(Right);
      Maxcalldreg = (D0 - 1) + (Value & 15);
      Maxcallareg = (A0 - 1) + ((unsigned)Value >> 4 & 15);
      Dump = Dump ^ (Value & (~255));
    }
    Getdeclaration(Dump | (Writable + Readable), Ownmode, Ownad, 0);
    goto Term;
  Initial_32:;
    if (A(Left) != True) {
      Get(Keyformat);
      if (A(Keyspec) == True) {
        Typeident.Flags = Typeid + Spec + Recy;
        Get(Ident);
        Declare(Typeident);
      } else {
        Typeident.Flags = Typeid + Recy;
        Get(Ident);
        Declare(Typeident);
        Get(Left);
        Dformat = Ditem;
        Getdeclaration(Writable + Readable, 0, Dformat->Val, 0);
        Recalign(Dformat->Val);
        Get(Right);
      }
      goto Term;
    }
    Fp--;
    Atom = Keyrecord;
  Initial_27:
  Initial_29:;
  Initial_28:
  Initial_30:;
  Initial_26:
  Initial_31:;
  Initial_36:;
    Matched = 0;
    Getdeclaration(Writable + Readable, C.Mode, C.Val, 0);
    goto Term;
  Initial_22:;
    Getidentlist(Forwardlabel);
    goto Term;
    void Getswitchdeclaration(void) {
      int I;
      int Lo;
      int Hi;
      int Dlim1;
      static Objinfo D = 0;
      Matched = 1;
      do {
        D.Type = Arrstar;
        if (Control & Arrbit) D.Flags = D.Flags + Arrflag;
        D.Mode = Labmode;
        Getidentlist(D);
        Dlim1 = Dlim;
        Declareanon(*Details(Typeid + Arry, 0, 0, 0));
        Get(Left);
        Getlitrange(Inttype);
        Get(Right);
        Dict[Dlim1].Xtype = Item;
        Getbounds(Item, Lo, Hi);
        do {
          for (I = Lo; I <= Hi; I++) {
            Swpc--;
            Prog[Swpc] = 0;
            if (Swpc <= Pc) Croak(_imp_str_literal("Code space exhausted"));
          }
          Dict[Dlim0].Val = Swpc;
          Dict[Dlim0].Type = Dlim1;
          Dlim0++;
        } while (Dlim0 != Dlim1);
      } while (A(Comma) == True);
    }
  Initial_39:;
    Literal = 1;
    Getswitchdeclaration();
    C.Status = C.Status | Hadswitch;
    goto Term;
    void Opt(void) {
      int C;
      C = Control;
      Setoptions(*String(Final0 + Value));
      Selectoutput(Listout);
      if (!(Initcon & List)) Control = Control & (~List);
      if (Control & (~C) & (Ttlist + Codelist + Explist + Dictlist)) Control = Control | List;
    }
  Initial_48:;
    Getlitstring();
    Get(Terminator);
    if (!Faultnum) Opt();
    goto Next;
  Initial_47:;
    Getlitstring();
    Get(Terminator);
    if (!Faultnum) {
      if (Curfile == 3) Croak(_imp_str_literal("Too many nested includes"));
      if (Sym == Nl) Line++;
      Cur->Fp = Fp;
      Cur->Line = Line;
      Fcontrol[Curfile] = Control;
      if (!(Control & (Codelist + Explist + Dictlist))) Control = Control & (~List);
      Curfile++;
      if (Curfile == Lastfile) Lastfile = -1;
      Cur = &File[Curfile];
      *Cur = 0;
      Time1 -= Cputime;
      Opt();
      Time1 += Cputime;
      if (Cur->Flag) _imp_signal(14, 0, 0, _imp_str_literal(""));
      Line = 0;
      Sym = Nl;
      Curstart = Cur->Start2;
      Curlim = Cur->Lim2;
      Fp = Cur->Start2;
    }
    goto Next;
  Initial_44:;
    Getliteral(Inttype);
    if (!Value) Control = 0;
    Control = Control ^ Value;
    if (Control & Dictlist) Showdict(0);
    goto Term;
  Initial_43:;
    Control = Control | List;
    goto Term;
  Initial_5:;
    Get(Terminator);
    if (!Stopper) {
      C.Localdpos = Dlim;
      C.Parlim = Dlim;
      C.Access = 1;
      Getstatements(Keyend);
      return;
    }
    Declareanon(Beginblock);
    Openblock(Dlim0);
    Getstatements(Keyend);
    Updatesp();
    Thisisinst();
    Srcall(Dlim - 1);
    goto Term;
  Initial_1:;
    if (Stopper > Keyend)
      if (Stopper == Keyrepeat)
        Fault(Norepeat + Now);
      else
        Fault(Nofinish + Now);
    else {
      if (A(Keyof) == True) {
        if (A(Keylist) == True) {
          Control = Control & (~List);
          goto Term;
        }
        if (A(Keyfile) == True) {
          Fp = Curlim;
          Sym = Nl;
          goto Next;
        }
        Get(Keyprogram);
        if (Level) Fault(Noend + Now);
      }
      if (!Stopper) Fault(Nobegin + Now);
      if (C.Access > 0) {
        if (C.Type) Fault(Noresult + Now);
      }
      Closeblock();
    }
  }
  void Announce(int Value, _imp_string Message) {
    Write(Value, 1);
    Space();
    Printstring(Message);
    if (Value != 1) Printsymbol('s');
  }
  void Outputobjectfile(void) {
    static const int Objout = 1;
    static const int Initsize = 18;
    int I;
    int Reset;
    int Totsize;
    int Ownsize;
    Reset = 0;
    Totsize = Cad;
    Ownsize = Ownad;
    if (Ownsize) {
      if (Ownad & 3) Fillown(4 - (Ownad & 3));
      Ownsize = Ownad;
      Reset = Cad;
      Totsize += Initsize + Ownad;
    }
    Setextension(Objfile, _imp_str_literal(".mob"));
    Time1 -= Cputime;
    Openoutput(Objout, Objfile);
    Selectoutput(Objout);
    Putword(0xFE02);
    Putword((unsigned)Control >> 20 << 4);
    Value = 0;
    if (Externs) Doexternals(Externs, -1);
    Putword(Value);
    Value = 0;
    if (Extspecs) Doexternals(Extspecs, -1);
    Putword(Value);
    Putword((unsigned)Totsize >> 16);
    Putword(Totsize);
    Putword((unsigned)Reset >> 1);
    Putword((unsigned)C.Dpid >> 1);
    Putword((unsigned)Ownsize >> 16);
    Putword(Ownsize);
    Putword((unsigned)C.Totstack >> 16);
    Putword(C.Totstack);
    Putword(0);
    Putword(0);
    Putword(0);
    Putword(0);
    if (Externs) Doexternals(Externs, 0);
    if (Extspecs) Doexternals(Extspecs, 1);
    Final[0] = 0x4E;
    Final[1] = 0x75;
    I = 0;
    do {
      Printsymbol(Final[I]);
      I++;
    } while (I != Cad);
    if (Ownsize) {
      Putword(0x2248 + Mb - A0);
      Putword(0x41FA);
      Putword(0x000E);
      Putword(0x303C);
      Putword(((unsigned)Ownad >> 1) - 1);
      Putword(0x32D8);
      Putword(0x51C8);
      Putword(-4);
      Putword(0x4E75);
      I = 0;
      do {
        Printsymbol(Final[I + Ownbase]);
        I++;
      } while (I != Ownad);
    }
    Time1 += Cputime;
  }
  void Closeedit(void) {
    if (File[Main].Flag >= 0 && 0 < File[Main].Change && File[Main].Change != 0x7FFFFFFF) {
      File[Main].Name = Mainfile;
      Time1 -= Cputime;
      Printstring(_imp_join(File[Main].Name, _imp_str_literal("  updated")));
      Newline();
      Time1 += Cputime;
    }
  }

  {
    if (_imp_on_event(13, 14))
      if (Event.Event() == Abandon) {
        Closeedit();
        exit(0);
      }
    Time2 = Cputime - Time1;
    Statements = 1;
    Comments = 0;
    Atoms = 0;
    Identatoms = 0;
    Litatoms = 0;
    Faults = 0;
    Others = 0;
    Faultnum = 0;
    Zaps = 0;
    Steps = 0;
    Jumps = 0;
    Shorts = 0;
    Rep = _imp_str_literal("");
    Forgettriples();
    Char0 = Addr(Char[0]);
    Final0 = Addr(Final[0]);
    Preset();
    Dint = &Dict[Inttype];
    Dtemp = &Dict[Lablim];
    Dtemp2 = &Dict[Lablim + 1];
    Dtsprel = &Dict[Lablim + 2];
    Dmin = Dictlim;
    Dmin0 = Dmin;
    Inclim = 0;
    Accounted = 0;
    Firstentry = Finalbound;
    Firstpos = Dictlim;
    Pc = 1;
    Swpc = Progbound + 1;
    Cad = 2;
    Final[0] = 0;
    Ownbase = Finalbound - 4095;
    Ownad = 0;
    Level = Outerlevel;
    Vintage = 1;
    Pendout = 0;
    Pendin = 0;
    Polarity = 0;
    Curlab = Dictlim + 1;
    Resetcontext(Procstar, Defaultfree);
    C.Sp = -4;
    Control = Initcon;
    Lastfile = Main;
    Curfile = Main;
    Cur = &File[Main];
    Curstart = File[Main].Start1;
    Curlim = File[Main].Lim1;
    Fp = File[Main].Start1;
    Line = 0;
    Sym = Nl;
    Np = Np0;
    Getstatements(0);
  }
  Time2 = Cputime - Time2 - Time1;
  Closeedit();
  if (Faults == 0 || (Control & Forcebit) != 0) Outputobjectfile();
  for (;;) {
    Selectoutput(Listout);
    Printstring(File[Main].Name);
    if (Faults == 0 || (Control & Forcebit) != 0) {
      Printstring(_imp_str_literal(" compiled:"));
      Announce(Statements, _imp_str_literal("statement"));
      Printstring(_imp_str_literal(" (+"));
      Announce(Comments, _imp_str_literal("comment"));
      Printstring(_imp_str_literal(") to"));
      Announce(Cad, _imp_str_literal("byte"));
      Printstring(_imp_str_literal(" (+"));
      Write(Ownad, 1);
      Printsymbol(')');
      Newline();
    }
    if (Faults) {
      Printsymbol(':');
      Announce(Faults, _imp_str_literal("fault"));
      Printstring(_imp_str_literal(" reported"));
      if (Others) {
        Printstring(_imp_str_literal(" (+"));
        Announce(Others, _imp_str_literal("other"));
        Printsymbol(')');
      }
      Newline();
    }
    if (Control & Logbit) {
      Printstring(_imp_str_literal("  CODE  OWNS  JUMPS SHORT STEPS  ZAPS | ATOMS LITS IDS  TIME"));
      Newline();
      Write(Cad, 5);
      Write(Ownad, 5);
      Write(Jumps, 6);
      Write(Shorts, 5);
      Write(Steps, 5);
      Write(Zaps, 5);
      Print(Atoms / Statements, 5, 1);
      Print(Litatoms / Statements, 2, 1);
      Print(Identatoms / Statements, 1, 1);
      Print(Time2 / Statements, 2, 3);
      Printsymbol('+');
      Print(Time1 / Statements, 0, 3);
      Newline();
    }
    if (!Listout) break;
    Listout = 0;
  }
  exit(0);
  return (1);
}
