#include <perms.h>
void Debug(_imp_string S);
_imp_string Date(void);
_imp_string Time(void);
int Pass1(int Objecttank) {
  void Put(int N);
  void Putword(int N);
  void Putlong(int N);
  void Putblock(int Len, unsigned char *B);
  void Selectoutputtank(int N);
  extern void Exit(int Status);
  extern _imp_string Errormessage;
  _imp_string Sysmess(int N);
  _imp_string Infilename(void);
  _imp_string Version = _imp_str_literal("V08.02");
  extern int Command;
  static const int Warnbit = 0200;
  static const int Listbit = 0400;
  static const int Maxint = ((unsigned)(-1) >> 1) / 10;
  static const int Maxdig = ((unsigned)(-1) >> 1) - Maxint * 10;
  static const int Bytesize = 8;
  static const int Maxtag = 1200;
  static const int Maxdict = 9000;
  static const int Namebits = 11;
  static const int Maxnames = (1 << Namebits) - 1;
  static int Sparenames = Maxnames;
  static const int Maxgrammar = 1800;
  static const int Litmax = 50;
  static const int Recsize = 260;
  static const int Dimlimit = 6;
  static const int Ff = 12;
  static const int Marker = '^';
  static const int Squote = '"';
  static const int Cquote = '\'';
  static const int Source = 1;
  static const int Prims = 2;
  static const int Report = 0;
  static const int Listing = 2;
  static const int Integer = 1;
  static const int Real = 2;
  static const int Stringv = 3;
  static const int Record = 4;
  static const int Iform = (Integer << 4) + 1;
  static const int Var = 91;
  static const int Const = 93;
  static const int Swit = 105;
  static const int Comment = 22;
  static const int Termin = 20;
  static const int Lab = 3;
  static const int Jump = 54;
  static const int Recfm = 4;
  static const int Proc = 7;
  static const int Escdec = 252;
  static const int Escproc = 253;
  static const int Escarray = 254;
  static const int Escrec = 255;
  typedef struct Arfm {
    int Class;
    int Sub;
    int Link;
    int Ptype;
    int Papp;
    int Pformat;
    int X;
    int Pos;
  } Arfm;
  typedef struct Tagfm {
    int App;
    int Format;
    int Flags;
    int Index;
    int Text;
    int Link;
  } Tagfm;
  static const int Usedbit = 0b1000000000000000;
  static const int Closed = 0b0100000000000000;
  static const int Constbit = 0b0010000000000000;
  static const int Parameters = 0b0001000000000000;
  static const int Subname = 0b0000100000000000;
  static const int Aname = 0b0000010000000000;
  static const int Ownbit = 0b0000001000000000;
  static const int Prot = 0b0000000100000000;
  static const int Spec = 0b0000000010000000;
  static const int Transbit = 0x4000;
  static const int Error = 0x8000;
  static const int Manifest = 120;
  static const int Figurative = 130;
  static const int Actions = 180;
  static const int Phrasal = 200;
  static const unsigned char Amap[16 /*0:15*/] = {89,  91,  92,  104, 94,  93,  105, 100,
                                                  101, 102, 103, 106, 107, 108, 109, 89};
  static const unsigned char Atoms[16 /*0:15*/] = {89, 1, 1, 10, 9, 1, 10, 7, 7, 7, 7, 4, 1, 4, 1, 89};
  Arfm Ar[260 /*1:260*/];
  static int Class = 0;
  static int X = 0;
  static int Atom1 = 0;
  static int Atom2 = 0;
  static int Subatom = 0;
  static int Type = 0;
  static int App = 0;
  static int Format = 0;
  int Hashvalue;
  static int Faulty = 0;
  static int Faultrate = 0;
  static int Lines = 0;
  static int Textline = 0;
  static int Margin = 0;
  static int Errormargin = 0;
  static int Errorsym = 0;
  static int Column = 0;
  static int Stats = 0;
  static int Monpos = 0;
  static int Sym = Nl;
  static int Symtype = 0;
  static int Quote = 0;
  static int Endmark = 0;
  static int Cont = ' ';
  static int Csym = ' ';
  static int Decl = 0;
  static int Dim = 0;
  static int Specgiven = 0;
  static int Escapeclass = 0;
  static int Protection = 0;
  static int Atomflags = 0;
  static int Otype = 0;
  static int Realsln = 1;
  static int Last1 = 0;
  static int Gentype = 0;
  static int Ptype = 0;
  static int Papp = 0;
  static int Pformat = 0;
  static int Force = 0;
  static int G = 0;
  static int Gg = 0;
  static int Mapgg = 0;
  static int Fdef = 0;
  static int This = -1;
  static int Nmin = 0;
  static int Nmax = 0;
  static int Rbase = 0;
  static int Stbase = 0;
  static int Gmin = Maxgrammar;
  static int Dmax = 1;
  static int Tmin = Maxtag;
  static int Ss = 0;
  _imp_string Includefile;
  static int Includelist = 0;
  static int Include = 0;
  static int Perm = 1;
  static int Progmode = 0;
  static int Sstype = 0;
  static int Specmode = 0;
  static int Ocount = -1;
  static int Limit = 0;
  static int Copy = 0;
  static int Order = 0;
  static int Forwarn = 0;
  static int Dubious = 0;
  static int Dp = 1;
  static int Pos1 = 0;
  static int Pos2 = 0;
  static int Pos = 0;
  static int Dimension = 0;
  static int Local = 0;
  static int Fmbase = 0;
  static int Searchbase = 0;
  static int Formatlist = 0;
  int Recid;
  static unsigned char *Currentchar;
  static unsigned char Char[134 /*0:133*/] = {[0 ... 133] = 10};
  int Litpool[51 /*0:50*/];
  static int Lit = 0;
  static int Lp = 0;
  static int Blockx = 0;
  static int List = 2;
  static int Control = 0;
  static int Diag = 0;
  short Hash[2048 /*0:2047*/];
  Tagfm Tag[1201 /*0:1200*/];
  int Dict[9000 /*1:9000*/];
  static const _imp_string Text[256 /*0:255*/] = {
      _imp_str_literal("Z"),        _imp_str_literal("VDEC"),     _imp_str_literal("OWNVDEC"),
      _imp_str_literal("EXTVSPEC"), _imp_str_literal("ADEC"),     _imp_str_literal("OWNADEC"),
      _imp_str_literal("EXTASPEC"), _imp_str_literal("PROC"),     _imp_str_literal("PROCSPEC"),
      _imp_str_literal("FORMDEC"),  _imp_str_literal("SWDEC"),    _imp_str_literal("LDEC"),
      _imp_str_literal("FORMSPEC"), _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal("OPTION"),   _imp_str_literal("COMMA"),    _imp_str_literal("T"),
      _imp_str_literal("COLON"),    _imp_str_literal("COMMENT"),  _imp_str_literal("LB"),
      _imp_str_literal("ALIAS"),    _imp_str_literal("RB"),       _imp_str_literal("SUB"),
      _imp_str_literal("ARRAYD"),   _imp_str_literal("STYPE"),    _imp_str_literal("ARRAY"),
      _imp_str_literal("NAME"),     _imp_str_literal("PROCD"),    _imp_str_literal("FNMAP"),
      _imp_str_literal("SWITCH"),   _imp_str_literal("OWN"),      _imp_str_literal("EXTERNAL"),
      _imp_str_literal("STRING"),   _imp_str_literal("RECORD"),   _imp_str_literal("FORMAT"),
      _imp_str_literal("SPEC"),     _imp_str_literal("MCODE"),    _imp_str_literal("LABEL"),
      _imp_str_literal("OP1"),      _imp_str_literal("OP2"),      _imp_str_literal("OP3"),
      _imp_str_literal("SIGN"),     _imp_str_literal("UOP"),      _imp_str_literal("MOD"),
      _imp_str_literal("DOT"),      _imp_str_literal("COMP"),     _imp_str_literal("ACOMP"),
      _imp_str_literal("EQ"),       _imp_str_literal("EQEQ"),     _imp_str_literal("JAM"),
      _imp_str_literal("JUMP"),     _imp_str_literal("RESOP"),    _imp_str_literal("AND"),
      _imp_str_literal("OR"),       _imp_str_literal("NOT"),      _imp_str_literal("WHILE"),
      _imp_str_literal("UNTIL"),    _imp_str_literal("FOR"),      _imp_str_literal("CWORD"),
      _imp_str_literal("EXIT"),     _imp_str_literal("ON"),       _imp_str_literal("SIGNAL"),
      _imp_str_literal("THEN"),     _imp_str_literal("START"),    _imp_str_literal("ELSE"),
      _imp_str_literal("FINISH"),   _imp_str_literal("FELSE"),    _imp_str_literal("CYCLE"),
      _imp_str_literal("REPEAT"),   _imp_str_literal("PROGRAM"),  _imp_str_literal("BEGIN"),
      _imp_str_literal("END"),      _imp_str_literal("ENDPROG"),  _imp_str_literal("ENDPERM"),
      _imp_str_literal("FRESULT"),  _imp_str_literal("MRESULT"),  _imp_str_literal("BACK"),
      _imp_str_literal("MONITOR"),  _imp_str_literal("STOP"),     _imp_str_literal("LIST"),
      _imp_str_literal(""),         _imp_str_literal("CONTROL"),  _imp_str_literal("INCLUDE"),
      _imp_str_literal("MASS"),     _imp_str_literal("RTYPE"),    _imp_str_literal("ADDOP"),
      _imp_str_literal("IDENT"),    _imp_str_literal("V"),        _imp_str_literal("N"),
      _imp_str_literal("CONST"),    _imp_str_literal("FM"),       _imp_str_literal(""),
      _imp_str_literal("R"),        _imp_str_literal("F"),        _imp_str_literal("M"),
      _imp_str_literal("P"),        _imp_str_literal("RP"),       _imp_str_literal("FP"),
      _imp_str_literal("MP"),       _imp_str_literal("PP"),       _imp_str_literal("L"),
      _imp_str_literal("S"),        _imp_str_literal("A"),        _imp_str_literal("AN"),
      _imp_str_literal("NA"),       _imp_str_literal("NAN"),      _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal("%MSTART"),  _imp_str_literal("%CLEAR"),   _imp_str_literal("%PRED"),
      _imp_str_literal(""),         _imp_str_literal("%DUBIOUS"), _imp_str_literal("%DUP"),
      _imp_str_literal("%PIN"),     _imp_str_literal("%POUT"),    _imp_str_literal("%EDUP"),
      _imp_str_literal(""),         _imp_str_literal("PIDENT"),   _imp_str_literal("CIDENT"),
      _imp_str_literal("OIDENT"),   _imp_str_literal("FNAME"),    _imp_str_literal("SWID"),
      _imp_str_literal("DOTL"),     _imp_str_literal("DOTR"),     _imp_str_literal("ASEP"),
      _imp_str_literal("CSEP"),     _imp_str_literal("OSEP"),     _imp_str_literal("PSEP"),
      _imp_str_literal("ARB"),      _imp_str_literal("BPLRB"),    _imp_str_literal("ORB"),
      _imp_str_literal("PRB"),      _imp_str_literal("CRB"),      _imp_str_literal("RCRB"),
      _imp_str_literal("RECRB"),    _imp_str_literal("RECLB"),    _imp_str_literal("LAB"),
      _imp_str_literal("MLAB"),     _imp_str_literal("SLAB"),     _imp_str_literal("XNAME"),
      _imp_str_literal("OWNT"),     _imp_str_literal("DBSEP"),    _imp_str_literal("PCONST"),
      _imp_str_literal("CMOD"),     _imp_str_literal("CSIGN"),    _imp_str_literal("CUOP"),
      _imp_str_literal("COP1"),     _imp_str_literal("COP2"),     _imp_str_literal("COP3"),
      _imp_str_literal("INDEF"),    _imp_str_literal("XELSE"),    _imp_str_literal("CRESOP"),
      _imp_str_literal("NLAB"),     _imp_str_literal("RUNTIL"),   _imp_str_literal("ACONST"),
      _imp_str_literal("ORRB"),     _imp_str_literal("FMANY"),    _imp_str_literal("OSTRING"),
      _imp_str_literal("FMLB"),     _imp_str_literal("FMRB"),     _imp_str_literal("FMOR"),
      _imp_str_literal("RANGERB"),  _imp_str_literal("FSID"),     _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal(""),         _imp_str_literal("%DUMMY"),   _imp_str_literal("%DECL"),
      _imp_str_literal("%TYPE"),    _imp_str_literal("%ZERO"),    _imp_str_literal("%APPLY"),
      _imp_str_literal("%PROT"),    _imp_str_literal("%SETPROT"), _imp_str_literal("%PTYPE"),
      _imp_str_literal("%GAPP"),    _imp_str_literal("%LOCAL"),   _imp_str_literal("%GUARD"),
      _imp_str_literal("%MCODE"),   _imp_str_literal("%CDUMMY"),  _imp_str_literal("%SETTYPE"),
      _imp_str_literal("%OPER"),    _imp_str_literal("%PARAM"),   _imp_str_literal("%BLOCK"),
      _imp_str_literal("%OTHER"),   _imp_str_literal("%COMPILE"), _imp_str_literal("APP"),
      _imp_str_literal("BASEAPP"),  _imp_str_literal("APP2"),     _imp_str_literal("APP3"),
      _imp_str_literal("APP4"),     _imp_str_literal("APP5"),     _imp_str_literal("APP6"),
      _imp_str_literal("ADEFN"),    _imp_str_literal("NPARM"),    _imp_str_literal("SWDEF"),
      _imp_str_literal("SWIDS"),    _imp_str_literal("CIEXP"),    _imp_str_literal("RCONST"),
      _imp_str_literal("SCONST"),   _imp_str_literal("ARRAYP"),   _imp_str_literal("XIMP"),
      _imp_str_literal("IMP"),      _imp_str_literal("COND"),     _imp_str_literal("SCOND"),
      _imp_str_literal("EXP1"),     _imp_str_literal("EXP2"),     _imp_str_literal("SEXP"),
      _imp_str_literal("IEXP"),     _imp_str_literal("IEXP1"),    _imp_str_literal("IEXP2"),
      _imp_str_literal("ISEXP"),    _imp_str_literal("SEQ"),      _imp_str_literal("FDEF"),
      _imp_str_literal("EXP"),      _imp_str_literal("NARRAYP"),  _imp_str_literal("STRUCT"),
      _imp_str_literal("RESEXP"),   _imp_str_literal("BPL"),      _imp_str_literal("CONSTB"),
      _imp_str_literal("FITEM"),    _imp_str_literal("MOREA"),    _imp_str_literal("CLIST"),
      _imp_str_literal("FPP"),      _imp_str_literal("FPP0"),     _imp_str_literal("FPP1"),
      _imp_str_literal("FPP2"),     _imp_str_literal("INITVAR"),  _imp_str_literal("RECEXP"),
      _imp_str_literal("EIMP"),     _imp_str_literal("IDENTS"),   _imp_str_literal("RANGE"),
      _imp_str_literal("RCONSTB"),  _imp_str_literal("VARP"),     _imp_str_literal("INITDEC"),
      _imp_str_literal(""),         _imp_str_literal(""),         _imp_str_literal(""),
      _imp_str_literal("ESCDEC"),   _imp_str_literal("ESCPROC"),  _imp_str_literal("ESCARRAY"),
      _imp_str_literal("ESCREC")};
  static const int Gmax1 = 718;
  static int Gmax = 718;
  static const int Impphrase = 24;
  static short Phrase[56 /*200:255*/] = {0,   563, 564, 566, 568, 570, 572, 561, 613, 202, 199, 601, 477, 479,
                                         623, 297, 205, 307, 317, 432, 425, 436, 443, 457, 452, 460, 466, 481,
                                         401, 626, 628, 602, 520, 510, 485, 501, 574, 526, 527, 542, 549, 577,
                                         396, 286, 196, 635, 515, 620, 166, 0,   0,   0,   639, 692, 700, 708};
  static const unsigned char Atomic[50 /*130:179*/] = {
      90, 90, 90, 90, 90, 48, 48, 19, 19, 19, 19,  25, 25, 25, 25, 25, 25, 25, 23, 104, 104, 105, 30,  20,  21,
      93, 47, 45, 46, 42, 43, 44, 40, 68, 55, 104, 60, 93, 25, 40, 93, 23, 25, 57, 25,  90,  176, 177, 178, 179};
  static const short Initial[120 /*0:119*/] = {
      23,     0,      0,      0, 0,  0,  0,      0,      0,      0,      0,      0,      0, 0,  0,  0,  0, 0,
      22,     0,      0,      0, 0,  0,  0,      0,      0,      0,      0,      0,      0, 0,  0,  0,  0, 0,
      0,      0,      0,      0, 20, 0,  0,      0,      0,      0,      0,      0,      0, 0,  0,  0,  0, 0,
      -32552, 0,      0,      0, 0,  13, 0,      14,     4,      -32558, 16,     -32551, 0, 0,  5,  6,  3, 12,
      15,     8,      7,      9, 10, 11, -32559, -32555, -32560, -32553, -32554, 18,     0, 17, 21, 19, 0, 0,
      0,      -32563, -32561, 0, 0,  0,  -32562, 0,      0,      0,      0,      0,      0, 0,  1,  2,  0, -32557,
      0,      -32556, 0,      0, 0,  0,  0,      0,      0,      0,      0,      0};
  static short Gram[1801 /*0:1800*/] = {
      0,      -28523, -28521, -28602, -32706, -28509, -28603, -24502, -24503, -20405, -20404, -28595,
      -32697, -32709, -16323, -28600, -32704, -28587, -28589, -32681, -16344, -28586, -16366, -32586,
      216,    -12287, -16380, -8185,  -8184,  -12285, -12286, -12283, -12282, -12279, -12276, -16373,
      20490,  -32706, -32701, 216,    -16364, -28610, -28613, -28612, 16445,  217,    -16364, 62,
      -32701, 16450,  -16364, 5346,   -16364, 166,    -16344, 4332,   130,    -16360, -16361, 126,
      217,    -32701, 216,    -16364, 16450,  -32700, 16404,  -32701, -32706, 216,    16405,  16407,
      -16222, 8414,   130,    217,    -32697, 16450,  1250,   4307,   4318,   192,    93,     170,
      90,     207,    -16365, 16404,  90,     -16360, -16365, 16404,  241,    -16365, 16404,  132,
      132,    -16360, 4329,   -16365, 16404,  133,    175,    90,     -16365, 16404,  209,    -16365,
      16404,  4313,   217,    16451,  4263,   16384,  16384,  120,    216,    -32700, 16404,  -32706,
      16404,  243,    16409,  454,    -32685, 16404,  454,    248,    -16365, 16404,  4263,   194,
      -16360, 4329,   -32717, 16404,  4263,   16407,  454,    237,    127,    215,    454,    4263,
      16384,  -16364, 1502,   -32629, -16361, 153,    -32606, 222,    143,    -32629, 153,    454,
      126,    16409,  454,    16384,  234,    -16365, -32595, 147,    -32678, 234,    193,    -32677,
      -32676, -32661, 109,    -32717, 53,     52,     52,     52,     194,    194,    194,    -28581,
      4188,   194,    -28566, 4203,   194,    -28564, 4205,   4580,   16429,  183,    183,    186,
      186,    -28583, 0,      9437,   90,     -16365, 0,      134,    -16365, 0,      210,    4329,
      199,    -32677, -32672, -32676, -32688, -32690, -32705, -32661, -32659, -32689, -32686, -32687,
      -16330, 65,     -32716, 186,    -28583, -32717, -32715, -32713, 52,     -32664, 4201,   186,
      -32717, -32715, 55,     -16328, 0,      197,    197,    52,     52,     197,    -28581, -28580,
      186,    -28581, 4188,   4318,   194,    -28581, 4188,   9437,   194,    194,    454,    16407,
      216,    194,    -28566, -28565, 186,    -28566, 4203,   194,    -28564, -28563, 186,    -28564,
      4205,   183,    183,    186,    183,    -16365, 0,      183,    4580,   16429,  5095,   9444,
      5348,   186,    -28583, -16328, 0,      16409,  -16365, 0,      9437,   5348,   217,    -32701,
      16450,  -32701, 216,    -32700, 0,      -32701, -32706, 216,    243,    217,    -16318, 0,
      -32552, 0,      -32700, 0,      -32706, 0,      215,    -32550, 228,    -28616, -28615, 0,
      4096,   218,    218,    -28616, 0,      -32677, -32676, -16361, -32710, -32669, -32662, -32661,
      -32660, -32659, 740,    -32039, 740,    -32719, 4096,   194,    -32719, -32718, -32604, -32726,
      -32725, -32724, -32720, 4096,   710,    6116,   -32719, 0,      710,    6116,   -28581, 4188,
      218,    122,    50,     16409,  -32726, -32725, -32724, -32719, 4096,   710,    454,    195,
      195,    195,    454,    -28581, 4188,   194,    -28566, -28565, -28564, 4205,   195,    195,
      195,    710,    4836,   5095,   4829,   -32726, -32725, -32724, -32719, 4096,   4827,   4828,
      454,    -32720, -32719, 4096,   4829,   4827,   4828,   194,    -32719, 0,      710,    4836,
      -16291, -32677, 92,     184,    121,    -28581, -28580, -32722, -32723, 4317,   -32726, -32725,
      -32724, 0,      183,    -32726, -32725, -32724, -32720, 0,      4316,   195,    195,    195,
      454,    -28581, 4188,   4315,   183,    4317,   -32726, -32725, 0,      195,    195,    4315,
      4317,   -32726, 0,      195,    -32677, -32676, -16361, 16431,  228,    228,    47,     -32610,
      -32611, 5345,   -32609, -32608, -32607, 0,      4320,   4319,   5345,   -32609, -32608, 0,
      4319,   5345,   -32609, 0,      -32613, -16361, 16431,  222,    222,    156,    -32677, 92,
      183,    186,    1222,   16435,  228,    16403,  4324,   138,    8420,   -32723, 4189,   93,
      454,    148,    -32674, 16546,  16409,  -32597, 182,    -16383, 16388,  234,    -16365, -32595,
      172,    -32678, 234,    90,     244,    246,    -16365, 0,      235,    -32678, 234,    -16365,
      246,    -16365, 0,      -32678, 234,    90,     16407,  222,    16405,  222,    145,    16407,
      222,    16405,  222,    146,    16407,  1252,   154,    5348,   -16365, 142,    126,    182,
      -16383, 16391,  90,     -16365, 127,    -32678, 238,    90,     125,    239,    -16365, 8319,
      8430,   128,    126,    -16361, 127,    190,    240,    189,    16409,  182,    -16383, 16391,
      90,     -16365, 0,      -32678, 240,    90,     16623,  -16365, 0,      244,    232,    1252,
      1252,   137,    1252,   137,    1252,   137,    1252,   137,    1252,   137,    222,    -16365,
      0,      131,    194,    -16360, -16333, -16332, 124,    181,    -16292, -16277, 16493,  -31802,
      5342,   -28581, 4188,   4263,   181,    186,    454,    16475,  183,    -28583, 199,    5598,
      9438,   222,    -32677, -32676, 16407,  186,    228,    135,    16409,  -32632, 0,      -32677,
      92,     -32677, -32676, -32662, -32661, -32660, -32659, 165,    -32677, 92,     188,    -32662,
      107,    188,    -32660, 109,    -32732, 37,     -16344, 4318,   148,    -32674, 16424,  222,
      16405,  222,    174,    -28644, -32734, -32680, -28641, -32733, -32730, -32735, -32727, -32738,
      4326,   -32738, -32739, -32741, -32736, 199,    -28644, -32680, -28641, 4326,   -32739, -32741,
      199,    -32738, -32739, -32741, -32736, -32729, 199,    -32616, 199,    -32739, -32741, -32729,
      199,    -32616, -32729, 199,    -28644, -32680, 4326,   -32738, -32739, -32741, 199,    245,
      4318,   245,    16409,  152,    4318,   16409,  152,    245,    -32672, -32671, -32670, 99,
      16407,  200,    144,    185,    -32677, 92,     16407,  -32582, 200,    200,    187,    141,
      -32677, 92,     16410,  191,    -32677, -32676, -32662, -32661, -32660, 109,    198,    [719 ... 1800] = 0};
  static short Glink[1801 /*0:1800*/] = {
      -1,  70,  71,  37,  45,  46,  66,  66,  74,  66,  0,   66,  50,  75,  78,  52,  54,  79,
      66,  80,  81,  82,  83,  25,  40,  84,  85,  56,  56,  88,  92,  95,  96,  101, 102, 103,
      106, 45,  66,  66,  0,   109, 109, 110, 51,  48,  0,   60,  66,  61,  0,   66,  0,   110,
      111, 111, 57,  112, 113, 114, 63,  66,  65,  115, 116, 67,  0,   66,  121, 66,  0,   72,
      122, 122, 66,  76,  66,  39,  76,  66,  66,  0,   123, 126, 127, 86,  85,  0,   89,  130,
      88,  0,   93,  92,  0,   131, 97,  136, 99,  96,  0,   137, 66,  104, 103, 0,   107, 106,
      0,   66,  66,  66,  138, 139, 140, 0,   117, 119, 115, 141, 115, 66,  70,  124, 66,  0,
      66,  128, 84,  0,   142, 132, 143, 134, 144, 0,   155, 156, 58,  157, 66,  118, 90,  158,
      145, 144, 147, 145, 150, 0,   152, 152, 153, 145, 0,   98,  159, 66,  133, 160, 161, 164,
      160, 140, 161, 161, 167, 171, 173, 174, 175, 176, 177, 178, 181, 184, 187, 188, 179, 189,
      189, 182, 190, 190, 185, 190, 190, 0,   187, 191, 192, 193, 0,   195, 0,   0,   197, 196,
      0,   200, 199, 0,   203, 204, 0,   227, 231, 218, 233, 234, 0,   235, 236, 237, 0,   231,
      225, 243, 244, 220, 247, 248, 249, 250, 244, 0,   251, 228, 248, 249, 250, 252, 0,   0,
      187, 253, 259, 238, 268, 268, 241, 190, 190, 269, 245, 271, 271, 228, 272, 273, 274, 275,
      0,   254, 265, 265, 257, 266, 266, 260, 265, 265, 263, 266, 266, 231, 267, 231, 0,   276,
      0,   277, 231, 272, 231, 281, 282, 278, 284, 252, 0,   0,   285, 0,   231, 0,   287, 0,
      289, 0,   291, 293, 0,   0,   296, 0,   0,   298, 300, 0,   302, 0,   304, 0,   306, 0,
      0,   309, 312, 313, 314, 0,   0,   315, 310, 313, 0,   331, 331, 327, 348, 349, 350, 350,
      350, 350, 329, 281, 351, 357, 0,   332, 340, 346, 358, 359, 360, 361, 362, 0,   341, 342,
      344, 0,   345, 0,   268, 268, 0,   0,   365, 352, 370, 371, 372, 373, 0,   374, 375, 376,
      382, 383, 363, 384, 384, 366, 268, 268, 268, 268, 388, 389, 390, 391, 392, 0,   377, 359,
      360, 361, 340, 0,   378, 379, 385, 362, 340, 0,   352, 353, 354, 374, 394, 0,   395, 0,
      399, 268, 268, 400, 0,   410, 410, 405, 416, 406, 417, 418, 419, 0,   411, 417, 418, 419,
      420, 0,   408, 405, 423, 416, 421, 424, 424, 407, 414, 426, 429, 430, 0,   425, 431, 427,
      433, 435, 0,   432, 268, 268, 440, 441, 281, 442, 0,   445, 450, 446, 445, 451, 450, 0,
      448, 447, 453, 452, 456, 0,   454, 458, 457, 0,   268, 463, 464, 281, 465, 0,   468, 468,
      469, 470, 471, 472, 473, 474, 475, 476, 0,   478, 268, 480, 0,   482, 484, 484, 204, 489,
      487, 495, 496, 490, 493, 489, 0,   490, 490, 0,   497, 498, 500, 0,   0,   503, 505, 509,
      498, 507, 0,   505, 505, 503, 511, 512, 513, 514, 0,   516, 517, 518, 519, 0,   521, 522,
      523, 524, 521, 0,   527, 528, 530, 535, 531, 533, 0,   531, 0,   536, 537, 538, 540, 541,
      541, 0,   543, 545, 0,   546, 547, 548, 532, 550, 552, 557, 553, 555, 0,   553, 0,   558,
      559, 556, 0,   562, 204, 0,   565, 563, 567, 564, 569, 566, 571, 568, 573, 570, 575, 574,
      0,   578, 579, 591, 592, 583, 204, 584, 587, 587, 587, 589, 204, 593, 593, 594, 595, 596,
      580, 599, 597, 600, 0,   204, 204, 204, 605, 605, 606, 607, 608, 604, 609, 611, 0,   192,
      192, 192, 192, 192, 192, 192, 192, 0,   622, 622, 191, 625, 625, 0,   625, 625, 630, 632,
      281, 281, 633, 281, 281, 636, 637, 638, 0,   649, 676, 683, 665, 654, 204, 204, 204, 204,
      649, 658, 667, 684, 665, 0,   661, 685, 665, 661, 667, 684, 0,   669, 673, 688, 665, 204,
      0,   204, 0,   673, 688, 204, 0,   665, 204, 0,   679, 691, 679, 658, 667, 684, 0,   649,
      686, 661, 687, 204, 689, 690, 665, 679, 696, 696, 696, 696, 697, 698, 699, 0,   702, 702,
      703, 705, 706, 707, 707, 699, 710, 710, 711, 712, 718, 718, 718, 718, 718, 718, 0,   [719 ... 1800] = 0};
  static const short Kdict[565 /*32:596*/] = {
      0,      511,    131,    531,    131,    551,    559,    131,    567,    575,    583,    603,    623,    631,
      663,    671,    129,    129,    129,    129,    129,    129,    129,    129,    129,    129,    691,    698,
      707,    751,    795,    131,    131,    824,    900,    960,    1076,   1120,   1280,   128,    128,    1392,
      128,    128,    1460,   1556,   1592,   1660,   1748,   128,    1828,   2000,   2196,   2228,   128,    2268,
      128,    128,    128,    2287,   2295,   2327,   2335,   2355,   131,    131,    131,    131,    131,    131,
      131,    131,    131,    131,    131,    131,    131,    131,    131,    131,    131,    131,    131,    131,
      131,    131,    131,    131,    131,    131,    131,    131,    2363,   131,    2335,   -32351, 16428,  25,
      16428,  29,     -32349, 16433,  1,      16434,  1,      -16127, 0,      16427,  21,     16407,  0,      16409,
      0,      -32323, -10840, 40,     16471,  0,      -32341, -10580, 32,     16473,  117,    16384,  19,     -31955,
      -32322, -10580, 36,     -9290,  0,      16473,  113,    16432,  13,     -32337, 16427,  46,     16427,  17,
      16405,  0,      16404,  0,      -31556, -31939, -32322, -9551,  2,      16433,  1,      16433,  5,      16426,
      5,      -31606, -32323, -9807,  0,      -32374, -9678,  0,      16436,  0,      16435,  0,      -31939, -32322,
      16433,  4,      16426,  9,      16433,  3,      -30772, -31666, 10578,  11457,  -32344, 16413,  2,      16411,
      2,      68,     -32374, 16440,  0,      16440,  0,      8393,   83,     16408,  0,      -31291, 10841,  69,
      -32311, 16412,  18,     10830,  9157,   10565,  16412,  18,     9415,   78,     16458,  0,      -32049, 8665,
      8908,   16455,  0,      -30131, 78,     -31277, 84,     -32055, 10194,  76,     16469,  0,      10958,  69,
      16447,  32,     84,     -32319, 16418,  2,      10830,  16418,  2,      8909,   10830,  16406,  0,      -31927,
      10073,  9921,   8649,   16419,  5,      9153,   10190,  8915,   16469,  1,      -27956, -31282, 88,     -31927,
      8916,   10066,  9793,   16419,  3,      84,     16447,  4,      68,     -32305, 16459,  2,      70,     -30650,
      -31284, 80,     -31931, 10194,  10567,  9921,   16460,  1,      9938,   16461,  0,      10697,  84,     16467,
      3,      9801,   69,     16460,  0,      8915,   16452,  0,      -29631, -30903, -31282, -31793, 10069,  10819,
      10185,  78,     16416,  9,      82,     16445,  0,      16416,  9,      9422,   9299,   -32315, 16453,  0,
      10700,  69,     16454,  0,      10700,  69,     16464,  1210,   -30778, 78,     -31549, 8916,   8903,   82,
      -32344, 16412,  17,     16472,  17,     10956,  8900,   16470,  0,      16446,  44,     -30143, -30647, 10063,
      71,     -31671, -32302, 16412,  20,     8389,   76,     16412,  36,     10830,  9157,   10565,  16412,  20,
      10835,  16467,  1,      8898,   76,     16425,  6,      -31935, 10063,  10825,  10575,  16465,  109,    80,
      16416,  10,     -32191, 10831,  16442,  0,      8909,   -32314, 16414,  1,      -31794, 10069,  10819,  10185,
      78,     16416,  10,     16416,  10,     -30770, -31408, -32174, 10071,  16418,  1,      -32374, 16441,  2,
      16441,  2,      9428,   10063,  16402,  0,      -32315, 16448,  0,      8918,   10830,  16448,  0,      -30523,
      82,     -31419, -31927, 9167,   8402,   77,     16457,  0,      77,     16419,  6,      9412,   8387,   8916,
      16415,  123,    9938,   16419,  7,      -31931, 10959,  9428,   8910,   16415,  104,    -28351, -30397, -31024,
      -32045, 10964,  10066,  16464,  1319,   9813,   7892,   -32323, 16462,  1384,   16463,  1241,   8389,   84,
      16456,  0,      10575,  68,     -32314, 16421,  64,     10575,  8397,   84,     -32301, 16422,  9,      8912,
      67,     16422,  12,     76,     16412,  33,     -27704, -28983, -29488, -31276, -31913, 10713,  8916,   77,
      16419,  4,      10825,  9283,   16417,  12,     -31423, -31921, 9426,   9166,   40,     16420,  48,     80,
      16466,  115,    10834,  16451,  0,      8645,   16423,  0,      10055,  9793,   -32315, 16449,  0,      8918,
      10830,  16449,  0,      10575,  84,     -32311, 16412,  19,     10830,  9157,   10565,  16412,  19,     -32056,
      10962,  69,     16464,  1354,   10053,  16450,  0,      78,     -32052, 9428,   76,     16444,  182,    10693,
      83,     16446,  46,     9416,   8908,   16443,  180,    16407,  0,      -31939, -32292, -10454, 51,     16426,
      13,     16433,  1,      16409,  0,      -32290, -10454, 51,     16426,  13,     16410,  0,      16431,  14,
      -32323, 16430,  51,     16433,  1};
  void Printident(int P, int Mode) {
    int J;
    int Ad;
    P = Tag[P].Text;
    if (!P) {
      if (!Mode)
        Printsymbol('?');
      else
        Put('?');
      return;
    }
    Ad = Addr(Dict[P + 1]);
    if (!Mode)
      Printstring(*String(Ad));
    else
      Putblock(*Byteinteger(Ad), *Byteinteger(Ad + 1));
  }
  void Abandon(int N) {
    static int Reason_sw;
    static void *Reason[10 /*0:9*/] = {
        &&Reason_0, &&Reason_1, &&Reason_2, &&Reason_3, &&Reason_4,
        &&Reason_5, &&Reason_6, &&Reason_7, &&Reason_8, &&Reason_9,
    };
    int Stream;
    Stream = Listing;
    for (;;) {
      if (Sym != Nl) Newline();
      Printsymbol('*');
      Write(Lines, 4);
      Space();
      Printsymbol('[');
      Write(N, 0);
      Printsymbol(']');
      goto *Reason[Reason_sw = N];
    Reason_default:
      Debug(
          _imp_join(_imp_str_literal("* Switch label not set: reason("), _imp_join(Itos(N, 0), _imp_str_literal(")"))));
      exit(0);
    Reason_0:
      Printstring(_imp_str_literal("compiler error!"));
      goto More;
    Reason_1:
      Printstring(_imp_str_literal("switch vector too large"));
      goto More;
    Reason_2:
      Printstring(_imp_str_literal("too many names"));
      goto More;
    Reason_3:
      Printstring(_imp_str_literal("program too complex"));
      goto More;
    Reason_4:
      Printstring(_imp_str_literal("feature not implemented"));
      goto More;
    Reason_5:;
      if (Event.Sub != 1) {
        Printstring(_imp_join(_imp_str_literal("error message=\""),
                              _imp_join(Errormessage, _imp_join(_imp_str_literal("\" event_event="),
                                                                _imp_join(Itos(Event.Event(), 0),
                                                                          _imp_join(_imp_str_literal("  event_sub="),
                                                                                    Itos(Event.Sub, 0)))))));
        goto More;
      }
      if (Quote)
        if (Quote < 0)
          Printsymbol(Cquote);
        else
          Printsymbol(Squote);
      else {
        Printstring(_imp_str_literal("%endof"));
        if (Progmode >= 0)
          Printstring(_imp_str_literal("program"));
        else
          Printstring(_imp_str_literal("file"));
      }
      Printstring(_imp_str_literal(" missing?"));
      goto More;
    Reason_6:
      Printstring(_imp_str_literal("too many faults!"));
      goto More;
    Reason_7:
      Printstring(_imp_str_literal("string constant too long"));
      goto More;
    Reason_8:
      Printstring(_imp_str_literal("dictionary full"));
      goto More;
    Reason_9:
      Printstring(
          _imp_join(_imp_str_literal("Included file "), _imp_join(Includefile, _imp_str_literal(" does not exist"))));
    More:
      Newline();
      Printstring(_imp_str_literal("***  compilation abandoned ***"));
      Newline();
      if (!Stream) break;
      Closeoutput();
      Stream = Report;
      Selectoutput(Report);
    }
    if (Diag & 4096) _imp_monitor();
    Exit(0x1000002C);
  }
  void Op(int Code, int Param) {
    Put(Code);
    Putword(Param);
  }
  void Setconst(int M) {
    int V;
    V = M;
    if (V < 0) V = -M;
    Put('N');
    Putlong(V);
    if (M < 0) Put('U');
  }
  void Compileblock(int Level, int Blocktag, int Dmin, int Tmax, int Id) {
    auto int Gapp(void);
    auto void Deletenames(int Quiet);
    auto void Analyse(void);
    auto void Compile(void);
    int Open;
    Open = Closed;
    int Dbase;
    Dbase = Dmax;
    int Tbase;
    Tbase = Tmax;
    int Tstart;
    Tstart = Tmax;
    int Label;
    Label = 4;
    int Lastarray;
    Lastarray = 0;
    int Access;
    Access = 1;
    int Inhibit;
    Inhibit = 0;
    int *Bflags;
    Bflags = &Tag[Blocktag].Flags;
    int Blocktype;
    Blocktype = (unsigned)*Bflags >> 4 & 7;
    int Blockform;
    Blockform = *Bflags & 15;
    int Blockfm;
    Blockfm = Tag[Blocktag].Format;
    int Blockotype;
    Blockotype = Otype;
    int *Blockapp;
    Blockapp = &Tag[Blocktag].App;
    int L;
    int Newapp;
    void Fault(int N) {
      static int Fm_sw;
      static void *Fm[28 /*-5:22*/] = {
          &&Fm_M5, &&Fm_M4, &&Fm_M3, &&Fm_M2, &&Fm_M1, &&Fm_0,  &&Fm_1,  &&Fm_2,  &&Fm_3,  &&Fm_4,
          &&Fm_5,  &&Fm_6,  &&Fm_7,  &&Fm_8,  &&Fm_9,  &&Fm_10, &&Fm_11, &&Fm_12, &&Fm_13, &&Fm_14,
          &&Fm_15, &&Fm_16, &&Fm_17, &&Fm_18, &&Fm_19, &&Fm_20, &&Fm_21, &&Fm_22,
      };
      int St;
      void Printss(void) {
        int S;
        int P;
        if (!Pos) return;
        Space();
        P = 1;
        for (;;) {
          if (P == Pos1) Printsymbol(Marker);
          if (P == Pos) break;
          S = Char[Margin + P];
          P++;
          if (S == Nl || (S == '%' && P == Pos)) break;
          if (S < ' ')
            if (S == Ff)
              S = Nl;
            else
              S = ' ';
          Printsymbol(S);
        }
        if (List <= 0) Pos = 0;
      }
      if (Pos2 > Pos1) Pos1 = Pos2;
      if (N >= 0 || (Command & Warnbit) != 0) {
        if (Sym != Nl) Newline();
        St = Report;
        if (N == -3) St = Listing;
        for (;;) {
          Selectoutput(St);
          if (N < 0) {
            Printsymbol('?');
            Pos1 = 0;
          } else
            Printsymbol('*');
          if (St) {
            if (List <= 0 && Pos1 != 0) {
              Spaces(Pos1 + Margin);
              Printstring(_imp_str_literal("      ! "));
            }
          } else {
            if (Include) Printstring(Includefile);
            Write(Lines, 4);
            Printsymbol(Csym);
            Space();
          }
          if (-5 <= N && N <= 22) goto *Fm[Fm_sw = (N) - -5];
          Printstring(_imp_str_literal("fault"));
          Write(N, 2);
          goto Ps;
        Fm_default:
          Debug(
              _imp_join(_imp_str_literal("* Switch label not set: fm("), _imp_join(Itos(N, 0), _imp_str_literal(")"))));
          exit(0);
        Fm_M5:
          Printstring(_imp_str_literal("Dubious statement"));
          Dubious = 0;
          goto Psd;
        Fm_M4:
          Printstring(_imp_str_literal("Non-local"));
          Pos1 = Forwarn;
          Forwarn = 0;
          goto Ps;
        Fm_M3:
          Printident(X, 0);
          Printstring(_imp_str_literal(" unused"));
          goto Nps;
        Fm_M2:
          Printstring(_imp_str_literal("\"}\""));
          goto Miss;
        Fm_M1:
          Printstring(_imp_str_literal("access"));
          goto Psd;
        Fm_0:
          Printstring(_imp_str_literal("form"));
          goto Ps;
        Fm_1:
          Printstring(_imp_str_literal("atom"));
          goto Ps;
        Fm_2:
          Printstring(_imp_str_literal("not declared"));
          goto Ps;
        Fm_3:
          Printstring(_imp_str_literal("too complex"));
          goto Ps;
        Fm_4:
          Printstring(_imp_str_literal("duplicate"));
          goto Ps;
        Fm_5:
          Printstring(_imp_str_literal("type"));
          goto Ps;
        Fm_6:
          Printstring(_imp_str_literal("match"));
          goto Psd;
        Fm_7:
          Printstring(_imp_str_literal("context"));
          goto Psd;
        Fm_21:
          Printstring(_imp_str_literal("context "));
          Printident(This, 0);
          goto Ps;
        Fm_8:
          Printstring(_imp_str_literal("%cycle"));
          goto Miss;
        Fm_9:
          Printstring(_imp_str_literal("%start"));
          goto Miss;
        Fm_10:
          Printstring(_imp_str_literal("size"));
          if (!Pos1) Write(Lit, 1);
          goto Ps;
        Fm_11:
          Printstring(_imp_str_literal("bounds"));
          if (Ocount >= 0) Write(Ocount, 1);
          goto Ps;
        Fm_12:
          Printstring(_imp_str_literal("index"));
          goto Ps;
        Fm_13:
          Printstring(_imp_str_literal("order"));
          goto Psd;
        Fm_14:
          Printstring(_imp_str_literal("not a location"));
          goto Ps;
        Fm_15:
          Printstring(_imp_str_literal("%begin"));
          goto Miss;
        Fm_16:
          Printstring(_imp_str_literal("%end"));
          goto Miss;
        Fm_17:
          Printstring(_imp_str_literal("%repeat"));
          goto Miss;
        Fm_18:
          Printstring(_imp_str_literal("%finish"));
          goto Miss;
        Fm_19:
          Printstring(_imp_str_literal("result"));
          goto Miss;
        Fm_22:
          Printstring(_imp_str_literal("format"));
          goto Ps;
        Fm_20:
          Printsymbol('"');
          Printident(X, 0);
          Printsymbol('"');
        Miss:
          Printstring(_imp_str_literal(" missing"));
          goto Nps;
        Psd:
          Pos1 = 0;
        Ps:
          Printss();
        Nps:
          Newline();
          if (St == Listing) break;
          St = Listing;
        }
      }
      if (N >= 0) {
        if (Diag & 4096) _imp_monitor();
        if (N != 13) {
          Ocount = -1;
          Gg = 0;
          Copy = 0;
          Quote = 0;
          Searchbase = 0;
          Escapeclass = 0;
          Gg = 0;
        }
        Faulty++;
        Faultrate += 3;
        if (Faultrate > 30) Abandon(6);
        if (Faultrate <= 0) Faultrate = 3;
      }
      Tbase = Tstart;
      if (List <= 0 && Sym != Nl) {
        Errormargin = Column;
        Errorsym = Sym;
        Sym = Nl;
      }
    }
    Dmin--;
    Dict[Dmin] = -1;
    if (Dmax == Dmin) Abandon(2);
    if (List > 0 && Level > 0) {
      Write(Lines, 5);
      Spaces(Level * 3 - 1);
      if (!Blocktag)
        Printstring(_imp_str_literal("Begin"));
      else {
        Printstring(_imp_str_literal("Procedure "));
        Printident(Blocktag, 0);
      }
      Newline();
    }
    if (Blocktag) {
      Analyse();
      if (Ss) Compile();
      if (Blockotype)
        if (!(*Bflags & Spec)) {
          if (Progmode <= 0 && Level == 1)
            Progmode = -1;
          else
            Fault(7);
        }
      Newapp = Gapp();
      if (Specgiven) {
        if (Newapp != *Blockapp) Fault(6);
      }
      *Blockapp = Newapp;
      if (Level < 0) {
        Deletenames(0);
        return;
      }
    } else {
      Open = 0;
    }
    for (;;) {
      Analyse();
      if (!Ss) continue;
      Compile();
      if (Dubious) Fault(-5);
      if (Sstype > 0) {
        if (Sstype == 2) break;
        Compileblock(Specmode, Blockx, Dmin, Tmax, Id);
        if (Ss < 0) break;
      }
    }
    if (List > 1 && Level > 0) {
      Write(Lines, 5);
      Spaces(Level * 3 - 1);
      Printstring(_imp_str_literal("End"));
      Newline();
    }
    Deletenames(0);
    return;
    int Gapp(void) {
      static const int Comma = 140;
      auto void Setcell(int G, int Tt);
      auto void Class(Tagfm * V);
      Tagfm *V;
      int P;
      int Link;
      int Tp;
      int C;
      int Ap;
      int T;
      if (Tmax == Local) return (0);
      P = Gmax1;
      Link = 0;
      T = Tmax;
      for (;;) {
        V = &Tag[T];
        T--;
        Class(*V);
        if (C < 0) {
          C = -C;
          Setcell(196, Tp);
          Tp = -1;
        }
        Setcell(C, Tp);
        if (T == Local) break;
        Setcell(Comma, -1);
      }
      if (Gmax > Gmin) Abandon(3);
      return (Link);
      void Setcell(int G, int Tt) {
        while (P != Gmax) {
          P++;
          if (Glink[P] == Link && Gram[P] == G)
            if (Tt < 0 || (Gram[P + 1] == Tt && Glink[P + 1] == Ap)) {
              Link = P;
              return;
            }
        }
        Gmax++;
        Gram[Gmax] = G;
        Glink[Gmax] = Link;
        Link = Gmax;
        if (Tt >= 0) {
          Gmax++;
          Gram[Gmax] = Tt;
          Glink[Gmax] = Ap;
        }
        P = Gmax;
      }
      void Class(Tagfm * V) {
        static const int Err = 89;
        static const int Rtp = 100;
        static const int Fnp = 101;
        static const int Mapp = 102;
        static const int Predp = 103;
        static const int Classmap[16 /*0:15*/] = {89, 1764, 247, [3 ... 6] = 89, -100, -101, -102, -103, 89, 214,
                                                  89, 229,  89};
        int Tags;
        int Type;
        int Form;
        Ap = 0;
        Tags = V.Flags;
        Type = (unsigned)Tags >> 4 & 7;
        Form = Tags & 15;
        Tp = V.Format << 3 | Type;
        C = Classmap[Form];
        if (Type == 0 && Form == 2) {
          C = 208;
          Tp = 0;
        }
        if (Tags & Parameters) Ap = V.App;
      }
    }
    void Deletenames(int Quiet) {
      int Flags;
      Tagfm *Tx;
      while (Tmax > Tbase) {
        X = Tmax;
        Tmax--;
        Tx = &Tag[X];
        Flags = Tx->Flags;
        if ((Flags & Spec) != 0 && (Flags & Ownbit) == 0) Fault(20);
        if ((Flags & Usedbit) == 0 && Level > 0 && List <= 0) {
          if (!Quiet) Fault(-3);
        }
        Dict[Tx->Text] = Tx->Link;
      }
    }
    void Analyse(void) {
      static const int Orderbits = 0x3000;
      static const int Orderbit = 0x1000;
      static const int Escape = 0x1000;
      int Strp;
      int Mark;
      int Flags;
      int Proterr;
      int K;
      int S;
      int C;
      static int Key = 0;
      int Node;
      int *Z;
      Arfm *Arp;
      static int Act_sw;
      static void *Act[21 /*180:200*/] = {
          &&Act_default, &&Act_181, &&Act_182, &&Act_183, &&Act_184, &&Act_185, &&Act_186,
          &&Act_187,     &&Act_188, &&Act_189, &&Act_190, &&Act_191, &&Act_192, &&Act_193,
          &&Act_194,     &&Act_195, &&Act_196, &&Act_197, &&Act_198, &&Act_199, &&Act_default,
      };
      static int Paction_sw;
      static void *Paction[16 /*0:15*/] = {
          &&Paction_0,       &&Paction_1,       &&Paction_2,       &&Paction_3,
          &&Paction_4,       &&Paction_5,       &&Paction_6,       &&Paction_7,
          &&Paction_default, &&Paction_default, &&Paction_default, &&Paction_default,
          &&Paction_default, &&Paction_default, &&Paction_default, &&Paction_default,
      };
      void Traceanalysis(void) {
        int A;
        void Show(int A) {
          if (0 < A && A < 130) {
            Space();
            Printstring(Text[A]);
          } else
            Write(A, 3);
        }
        static int La1 = 0;
        static int La2 = 0;
        static int Lsa = 0;
        static int Lt = 0;
        if (Monpos != Pos && Sym != Nl) Newline();
        Monpos = Pos;
        Write(G, 3);
        Space();
        Printstring(Text[Class]);
        if (Gg & Transbit) Printsymbol('"');
        A = (unsigned)Gg >> 8 & 15;
        if (A) {
          Printsymbol('{');
          Write(A, 0);
          Printsymbol('}');
        }
        if (Atom1 != La1 || Atom2 != La2 || Lsa != Subatom || Lt != Type) {
          Printstring(_imp_str_literal(" ["));
          La1 = Atom1;
          Show(La1);
          La2 = Atom2;
          Show(La2);
          Lsa = Subatom;
          Write(Lsa, 3);
          Lt = Type;
          Write(Lt, 5);
          Printsymbol(']');
        }
        Newline();
      }
      void Readsym(void) {
        void Getnextsourcechar(void) {
          void Readrecord(int *Len, unsigned char *B);
          static int Len = 0;
          if (Sym == Nl) {
            Currentchar = &Char[1];
            Readrecord(Len, *Currentchar);
            Len++;
            Char[Len] = Nl;
            Pos = 0;
            Column = 0;
          }
          Pos++;
          Sym = *Currentchar;
          Currentchar = Currentchar;
          if (List <= 0) Printsymbol(Sym);
          Column++;
        }
        static const unsigned char Mapped[128 /*0:127*/] = {
            0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   10,  0,   3,   0,   0,   0,   0,    0,   0,
            0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   '!', '"', '#',  '$', 1,
            '&', 39,  '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6',  '7', '8',
            '9', ':', ';', '<', '=', '>', '?', '@', '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', '[', '\\', ']', '^',
            '_', '`', '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', 2,   '|', '}', '~', 0};
        if (Sym == Nl) {
        S1:
          Lines++;
          if (Endmark) Printsymbol(Endmark);
        S11:
          Pos = 0;
          Pos1 = 0;
          Pos2 = 0;
          Margin = 0;
          Column = 0;
          Endmark = 0;
          if (List <= 0) {
            if (Include) {
              Printstring(_imp_str_literal(" &"));
              Write(Lines, -4);
            } else
              Write(Lines, 5);
            Csym = Cont;
            Printsymbol(Csym);
            Space();
            if (Errormargin) {
              Lines--;
              Spaces(Errormargin);
              Errormargin = 0;
              if (Errorsym) {
                Printsymbol(Errorsym);
                Pos = 1;
                Char[1] = Errorsym;
                Sym = Errorsym;
                Errorsym = 0;
                goto S5;
              }
            }
          }
        S2:
          Symtype = 1;
        }
      S3:
        Getnextsourcechar();
      S5:
        if (Sym != Nl) {
          if (Quote) return;
          Sym = Mapped[Sym & 127];
          if (Sym <= 3) {
            if (!Sym) goto S2;
            if (Sym == 1) {
              Symtype = 2;
              goto S3;
            }
            if (Sym == 3) {
              Cont = '+';
              goto S11;
            }
            for (;;) {
              Getnextsourcechar();
              if (Sym == '}') goto S3;
              if (Sym == Nl) goto S4;
            }
          }
          Key = Kdict[Sym];
          if ((Key & 3) == 0 && Symtype == 2) {
            if (Sym == 'C' && *Currentchar == Nl) {
              Getnextsourcechar();
              Cont = '+';
              goto S1;
            }
          } else
            Symtype = (Key & 3) - 2;
          return;
        }
      S4:
        Cont = '+';
        Symtype = Quote;
      }
      int Formatselected(void) {
        Formatlist = Tag[Format].App;
        if (Formatlist < 0) {
          Atom1 = Error + 22;
          return (0);
        }
        if (Sym == '_') {
          Escapeclass = Escrec;
          Searchbase = Tag[Format].Format;
        }
        return (1);
      }
      void Codeatom(int Target) {
        int Dbase;
        int Da;
        int Base;
        int N;
        int Mul;
        int Pendquote;
        int J;
        int K;
        int L;
        int Pt;
        void Lookup(int D) {
          static const int Magic = 6700421;
          int Newname;
          int Vid;
          int K1;
          int K2;
          int Form;
          Tagfm *T;
          int New;
          New = Addr(Dict[Dmax + 1]);
          K2 = Hashvalue * Magic;
          K2 = (unsigned)K2 >> (32 - 2 * Namebits) | 1;
          K1 = (unsigned)K2 >> Namebits;
          for (;;) {
            Newname = Hash[K1];
            if (!Newname) break;
            if (*String(Addr(Dict[Newname + 1])) == *String(New)) goto In;
            K1 = (K1 + K2) & Maxnames;
          }
          Sparenames--;
          if (Sparenames <= 0) Abandon(2);
          Hash[K1] = Dmax;
          Dict[Dmax] = -1;
          Newname = Dmax;
          Dmax = Dp;
          goto Notin;
        In:
          if (This >= 0 && D != 0) Searchbase = Rbase;
          if (Searchbase) {
            New = -1;
            X = Searchbase;
            for (;;) {
              if (X < Formatlist) goto Notin;
              if (Tag[X].Text == Newname) break;
              X--;
            }
          } else {
            X = Dict[Newname];
            if (X <= Limit) goto Notin;
          }
          Subatom = X;
          T = &Tag[X];
          Atomflags = T->Flags;
          Format = T->Format;
          App = T->App;
          Protection = Atomflags & Prot;
          Type = (unsigned)Atomflags >> 4 & 7;
          Atom1 = Amap[Atomflags & 15];
          if (Diag & 8) {
            Printstring(_imp_str_literal("lookup:"));
            Write(Atom1, 3);
            Write(Type, 1);
            Write(App, 3);
            Write(Format, 5);
            Write(Atomflags, 3);
            Newline();
          }
          if (!D) {
            T->Flags = T->Flags | Usedbit;
            Searchbase = 0;
            if ((Atomflags & Subname) != 0 && Format != 0)
              if (!Formatselected()) return;
            if (Atomflags & Parameters) {
              if (!App) {
                Atom2 = Atom1;
                Atom1 -= 4;
                if (97 <= Atom1 && Atom1 <= 98) {
                  Mapgg = Atom1;
                  Atom1 = Var;
                }
              } else if (Sym == '(') {
                Searchbase = 0;
                if (Atom1 >= 106) {
                  App = Phrase[App + 200];
                  Escapeclass = Escarray;
                  Atom1 = ((unsigned)(Atom1 - 106) >> 1) + 91;
                } else {
                  Escapeclass = Escproc;
                  Atom1 -= 4;
                }
                Phrase[200] = App;
              }
              Pos2 = Pos;
              return;
            }
            if ((Atomflags & Constbit) != 0 && Atom1 == Var) {
              Mapgg = Const;
              Atom2 = Const;
              if (Type == Integer) Subatom = -Subatom;
            }
            return;
          }
          if (Tbase != Tstart) goto Notin;
          if (D == Lab + Spec + Usedbit) {
            T->Flags = T->Flags | Usedbit;
            return;
          }
          if (Atomflags & Spec) {
            if (D == Lab) {
              T->Flags = Lab | Usedbit;
              return;
            }
            if (7 <= (Decl & 15) && (Decl & 15) <= 10 && (Decl & Spec) == 0) {
              if (!((Decl ^ Atomflags) & 0b1111111)) {
                T->Flags = T->Flags - Spec;
                Specgiven = 1;
                return;
              }
            }
            if ((Decl & 15) == Recfm) {
              T->Flags = (Record << 4) + Recfm;
              T->Format = Fdef;
              return;
            }
          }
          if (Last1 == Jump && Atom1 == Swit) return;
          if (!Copy) Copy = Pos1;
        Notin:
          App = 0;
          Vid = 0;
          Atom1 = Error + 2;
          if (!D) return;
          Type = (unsigned)D >> 4 & 7;
          Form = D & 15;
          Atom1 = Amap[Form];
          if (This < 0) {
            New = Newname;
            Tmax++;
            X = Tmax;
          } else {
            New = -1;
            Recid--;
            Vid = Recid;
            Tmin--;
            X = Tmin;
            Formatlist = Tmin;
          }
          if (11 <= Form && Form <= 14) {
            if (!Dim) Dim = 1;
            App = Dim;
          }
          if ((Otype > 2 && (D & Spec) == 0) || Perm != 0) D = D | Usedbit;
          T = &Tag[X];
          if (Form == Lab) {
            Id++;
            Vid = Id;
          }
          T->Index = Vid;
          T->Text = Newname;
          T->Flags = D;
          T->App = App;
          T->Format = Fdef;
          Format = Fdef;
          Subatom = X;
          if (New >= 0) {
            T->Link = Dict[New];
            Dict[New] = X;
            if (Gmin == Maxgrammar) {
              Tmin--;
              Subatom = Tmin;
              Tag[Tmin] = *T;
            }
          }
          if (Tmax >= Tmin) Abandon(3);
        }
      Top:
        Pos1 = Pos;
        Subatom = 0;
        Pendquote = 0;
        if (Symtype == -2) goto Name;
        if (Symtype < 0) goto Number;
        if (!Symtype) {
          Atom1 = Termin;
          Atom2 = 0;
          return;
        }
        if (Symtype != 2) {
          if (Quote) goto Text;
          if (Sym == Squote) goto Strings;
          if (Sym == Cquote) goto Symbols;
          if (Sym == '.' && '0' <= *Currentchar && *Currentchar <= '9') goto Number;
        }
        K = (unsigned)Key >> 2;
        Readsym();
        for (;;) {
          J = Kdict[K];
          if (J & 0x4000) break;
          if ((J & 127) != Sym || Symtype < 0) {
            if (J >= 0) goto Err;
            K++;
          } else {
            L = (unsigned)J >> 7 & 127;
            Readsym();
            if (J > 0) {
              if (L) {
                if (L != Sym || Symtype < 0) goto Err;
                Readsym();
              }
              L = 1;
            }
            K += L;
          }
        }
        Atom1 = J & 127;
        if (!Atom1) {
          Atom1 = 19;
          Subatom = 19;
          Atom2 = 0;
          if (Sym == Nl) {
            if (Ocount >= 0) return;
            Readsym();
          }
          return;
        }
        Atom2 = (unsigned)J >> 7 & 127;
        Subatom = Kdict[K + 1] & 0x3FFF;
        return;
      Err:
        Atom1 = Error + 1;
        Atom2 = 0;
        if (Pos - Pos1 > 2) Pos1 = Pos;
        return;
      Symbols:
        Atom1 = Var;
        Atom2 = Const;
        Type = Integer;
        Mapgg = Const;
        Protection = Prot;
        Subatom = Lp;
        if (Lp >= Litmax) Abandon(3);
        Quote = ~Pendquote;
        return;
      Chars:
        N = 0;
        Cont = Cquote;
        for (;;) {
          Readsym();
          if (Sym == Cquote) {
            if (*Currentchar != Cquote) break;
            Readsym();
          }
          if (N & (~((unsigned)(-1) >> Bytesize))) {
            Pos1 = Pos;
            Atom1 = Error + 10;
            return;
          }
          if (!Quote) goto Err;
          N = (N << Bytesize) + Sym;
          Quote++;
        }
        Quote = 0;
        Cont = ' ';
        if (Sym != Nl) Readsym();
        Litpool[Lp] = N;
        Lp++;
        goto Top;
      Strings:
        Atom1 = Var;
        Atom2 = Const;
        Type = Stringv;
        Subatom = (Strp - Stbase) | 0x4000;
        Mapgg = Const;
        Protection = Prot;
        Quote = Subatom;
        Textline = Lines;
        return;
      Text:
        if (Quote < 0) goto Chars;
        L = Strp;
        N = Strp;
        J = Addr(Glink[Gmin - 1]);
        K = L + 256;
        if (J < K) K = J;
        for (;;) {
          Cont = Squote;
          Quote = 1;
          for (;;) {
            Readsym();
            if (Sym == Squote) {
              if (*Currentchar != Squote) break;
              Readsym();
            }
            L++;
            *Byteinteger(L) = Sym;
            if (L >= K) {
              Lines = Textline;
              Abandon(7);
            }
          }
          *Byteinteger(N) = L - N;
          Strp = L + 1;
          Quote = 0;
          Cont = ' ';
          Readsym();
          Codeatom(Target);
          if (Atom1 != 48 || Sym != Squote) return;
        }
        void Get(int Limit) {
          int S;
          int Shift;
          Shift = 0;
          if (Base != 10)
            if (Base == 16)
              Shift = 4;
            else if (Base == 8)
              Shift = 3;
            else if (Base == 2)
              Shift = 1;
          N = 0;
          for (;;) {
            if (Symtype == -1)
              S = Sym - '0';
            else if (Symtype < 0)
              S = Sym - 'A' + 10;
            else
              return;
            if (S >= Limit) return;
            Pt++;
            *Byteinteger(Pt) = Sym;
            if (Base == 10)
              if (N >= Maxint && (S > Maxdig || N > Maxint)) {
                Base = 0;
                Type = Real;
                N = 0;
              }
            if (!Shift)
              N = N * Base + S;
            else
              N = (N << Shift) + S;
            Readsym();
          }
        }
      Number:
        Base = 10;
      Bxk:
        Atom1 = Var;
        Atom2 = Const;
        Type = Integer;
        Subatom = Lp;
        Mapgg = Const;
        Protection = Prot;
        if (Lp >= Litmax) Abandon(3);
        Pt = Strp;
        Mul = 0;
        for (;;) {
          Get(Base);
          if (Sym != '_' || Base == 0 || Pendquote != 0) break;
          Readsym();
          Base = N;
        }
        if (Pendquote) {
          if (Sym != Cquote) goto Err;
          Readsym();
        }
        if (Sym == '.') {
          Pt++;
          *Byteinteger(Pt) = '.';
          Readsym();
          Type = Real;
          Base = 0;
          Get(10);
        }
        if (Sym == '@') {
          Pt++;
          *Byteinteger(Pt) = '@';
          K = Pt;
          Readsym();
          Type = Integer;
          Base = 10;
          if (Sym == '-') {
            Readsym();
            Get(10);
            N = -N;
          } else
            Get(10);
          Pt = K + 1;
          *Byteinteger(Pt) = Lp;
          Litpool[Lp] = N;
          Lp++;
          if (!Base) Atom1 = Error + 10;
          Type = Real;
        }
        if (Type == Real) {
          *Byteinteger(Strp) = Pt - Strp;
          Subatom = (Strp - Stbase) | 0x2000;
          Strp = Pt + 1;
        } else {
          Litpool[Lp] = N;
          Lp++;
        }
        return;
      Name:
        if (27 <= Target && Target <= 41) {
          Atom1 = 0;
          return;
        }
        Hashvalue = 0;
        Dp = Dmax + 1;
        Da = Addr(Dict[Dp]);
        Dbase = Da;
        for (;;) {
          Hashvalue += Hashvalue + Sym;
          Da++;
          *Byteinteger(Da) = Sym;
          Readsym();
          if (Symtype >= 0) break;
        }
        if (Sym == Cquote) {
          Pendquote = 100;
          if (Hashvalue == 'M') goto Symbols;
          Readsym();
          if (Hashvalue == 'X') {
            Base = 16;
            goto Bxk;
          }
          if (Hashvalue == 'K' || Hashvalue == 'O') {
            Base = 8;
            goto Bxk;
          }
          if (Hashvalue == 'B') {
            Base = 2;
            goto Bxk;
          }
          goto Err;
        }
        N = Da - Dbase;
        *Byteinteger(Dbase) = N;
        Dp += (unsigned)(N + 2) >> 1;
        if (Dp >= Dmin) Abandon(8);
        Atom2 = 90;
        if (Last1 == 0 && Sym == ':') {
          Limit = Local;
          Lookup(Lab);
          return;
        }
        if (Last1 == Jump) {
          Limit = Local;
          Lookup(Lab + Spec + Usedbit);
          return;
        }
        if (Decl != 0 && Target == 90) {
          Searchbase = Fmbase;
          Limit = Local;
          Lookup(Decl);
          Searchbase = 0;
        } else {
          Limit = 0;
          Lookup(0);
        }
      }
      int Parsedmachinecode(void) {
        void Octal(int N) {
          int M;
          M = (unsigned)N >> 3;
          if (M) Octal(M);
          Put((N & 7) + '0');
        }
        if (Symtype != -2) {
          Atom1 = Error;
          return (0);
        }
        Put('w');
        for (;;) {
          Put(Sym);
          Readsym();
          if (Symtype >= 0) break;
        }
        Put('_');
        if (Symtype) {
          if (Sym != '_') {
            Atom1 = Error;
            return (0);
          }
          Readsym();
          while (Symtype)
            if (Symtype < 0) {
              Codeatom(0);
              if (Atom1 & Error) return (0);
              if (Atom2 == Const && Type == Integer)
                if (Subatom < 0)
                  Octal(Tag[-Subatom].Format);
                else
                  Octal(Litpool[Subatom]);
              else if (91 <= Atom1 && Atom1 <= 109) {
                Put(' ');
                Octal(Tag[Subatom].Index);
              } else {
                Atom1 = Error;
                return (0);
              }
            } else {
              Put(Sym);
              Readsym();
            }
        }
        Put(';');
        return (1);
      }
      if (!Gg) Cont = ' ';
      Last1 = 0;
      Mapgg = 0;
      S = 0;
      Ss = 0;
      Sstype = -1;
      Fdef = 0;
      Fmbase = 0;
      App = 0;
      Margin = Column;
      Pos = 0;
      Stbase = Addr(Glink[Gmax + 1]);
      Strp = Stbase;
      Lp = 0;
      Tbase = Tstart;
      Local = Tbase;
      if (Gg == 0 || Ocount >= 0) {
      Again:
        while (!Symtype) {
          C = Cont;
          Cont = ' ';
          if (Ocount >= 0) Cont = '+';
          Readsym();
          Cont = C;
        }
        if (Sym == '!') goto Skip;
        This = -1;
        Codeatom(0);
        if (Atom1 == Comment) {
        Skip:
          Quote = 1;
          C = Cont;
          while (Sym != Nl) {
            Readsym();
            Cont = C;
          }
          Quote = 0;
          Symtype = 0;
          goto Again;
        }
      }
      Decl = 0;
      Mark = 0;
      Gentype = 0;
      Force = 0;
      Dim = 0;
      Proterr = 0;
      Node = 0;
      Nmax = 0;
      Nmin = Recsize + 1;
      Order = 1;
      Gmin = Maxgrammar + 1;
      if (Gg) {
        Sstype = 0;
        goto More;
      }
      Ptype = 0;
      Specgiven = 0;
      Stats++;
      if (!Perm) Op('O', Lines);
      if (Atom1 & Error) goto Fail1;
      if (Escapeclass) {
        G = Impphrase;
        Sstype = -1;
        goto A3;
      }
      G = Initial[Atom1];
      if (!G) {
        G = Initial[0];
        Sstype = 0;
        goto A3;
      }
      if (G < 0) {
        G = G & 255;
        Nmax = 1;
        Ar[1].Class = 0;
        Ar[1].Link = 0;
        Ar[1].Sub = Impphrase;
      }
      Gg = Gram[G];
      Class = Gg & 255;
      Sstype = ((unsigned)Gg >> 12 & 3) - 1;
      goto A1;
    Act_194:
      Ptype = Type;
      Papp = App;
      Pformat = Format;
      goto More;
    Act_196:
      K = G + 1;
      goto A610;
    Act_188:
      K = Ar[Nmax].Sub + 1;
    A610:
      Papp = Glink[K];
      K = Gram[K];
      if (!K) goto More;
      Ptype = K & 7;
      Pformat = (unsigned)K >> 3;
    Act_183:
      K = Type;
      if (Gentype == 0 || K == Real) Gentype = K;
      if (Pformat < 0) {
        App = Papp;
        Format = Pformat;
        if (Ptype == Real && Type == Integer) K = Real;
        if (Force) {
          K = Force;
          Force = 0;
        }
      }
      if (Papp != App || (Ptype != K && Ptype != 0)) goto Fail2;
      if (Pformat == Format || Pformat == 0 || Format == 0) goto More;
      goto Fail2;
    Act_197:
      Arp = &Ar[Nmin];
      K = Arp->Sub;
      if (Blockform != (K & 15)) goto Fail3;
      Arp->Sub = (unsigned)K >> 4;
      Type = Blocktype;
      Ptype = Blocktype;
      Pformat = Blockfm;
      Papp = App;
      if (Ptype != Record) Pformat = -1;
      goto More;
    Act_195:
      Arp = &Ar[Nmin];
      K = Arp->Sub;
      Arp->Sub = (unsigned)K >> 2;
      K = K & 3;
      if (!K) goto More;
      if (K == 1) {
        Force = Integer;
        if (Type == Integer || Type == 0) goto More;
        goto Fail2;
      }
      if (Ptype != Real && Ptype != 0) goto Fail2;
      if (K == 3) Force = Integer;
      goto More;
    Act_198:;
      K = (unsigned)Gg >> 8 & 15;
      if (!K) {
        Atom1 = Last1;
        goto More;
      }
      if (K == 1) {
        if (Type != Stringv) goto Fail2;
        goto More;
      }
      if (K == 2) {
        if (Type == Record) goto Fail2;
        goto More;
      }
      if (K == 3) {
        Codeatom(0);
        if (!(Atomflags & Ownbit)) goto A7;
        goto More;
      }
      if (X <= Local) Forwarn = Pos1;
      goto More;
    Paction_1:
      if (Type == Record)
        G = Phrase[242];
      else
        Pformat = -1;
      goto A3;
    Paction_2:
      Ptype = Real;
      Pformat = -1;
      goto A3;
    Paction_3:
      Ptype = Stringv;
      Pformat = -1;
      goto A3;
    Paction_4:
      Ptype = Integer;
      Pformat = -1;
      goto A3;
    Paction_5:
      if (Ptype == Integer) goto A3;
      if (Ptype == Real) {
        G = Phrase[212];
        Pformat = -1;
      }
      if (Ptype == Stringv) G = Phrase[213];
      goto A3;
    Paction_6:
      Ptype = Gram[Ar[Nmax].Sub + 1] & 7;
      Pformat = -1;
      goto A3;
    Paction_7:
      if (Ptype == Integer) Ptype = Real;
      Pformat = -1;
      goto A3;
    A1:
      Last1 = Class;
      Atom1 = 0;
      S = Subatom;
    A2:
      if (!(Gg & Transbit)) {
        Z = &Node;
        for (;;) {
          K = *Z;
          if ((Gg & Orderbits) == 0 || K == 0) break;
          Gg -= Orderbit;
          Z = &Ar[K].Link;
        }
        if (Mapgg != 0 && (Gg & 255) == Var) Gg = Mapgg;
        Nmin--;
        if (Nmin == Nmax) goto Fail0;
        *Z = Nmin;
        Arp = &Ar[Nmin];
        Arp->Sub = S;
        Arp->Class = (Gg & 255) | Mark;
        Arp->Link = K;
      }
      Mark = 0;
      Mapgg = 0;
    More:
      G = Glink[G];
    Paction_0:;
    A3:
      Gg = Gram[G];
      Class = Gg & 255;
      if (Gg == -1)
        Debug(_imp_join(_imp_str_literal("gg = gram(g) = -1 ... g="),
                        _imp_join(Itos(G, 0), _imp_join(_imp_str_literal(" gg="), Itos(Gg, 0)))));
      if (Diag & 1) Traceanalysis();
      if (!Class) goto A5;
      if (Class < Actions) {
        if (Class >= Figurative) Class = Atomic[Class];
        if (Class >= Manifest) goto A2;
        if (!Atom1) Codeatom(Class);
        if (Escapeclass) {
          Class = Escapeclass;
          Escapeclass = 0;
          G += Escape;
        Esc:
          Gg = 0;
          Arp = &Ar[Nmax + 1];
          Arp->Papp = Papp;
          Arp->X = X;
          goto A4;
        }
        if (Class == Atom1 || Class == Atom2) goto A1;
      A7:
        if (Gg >= 0) goto Fail1;
        G++;
        goto A3;
      }
      if (Class >= Phrasal) {
      A4:
        Nmax++;
        if (Nmax == Nmin) goto Fail0;
        Arp = &Ar[Nmax];
        Arp->Ptype = Ptype;
        Arp->Pos = Pos1;
        Arp->Pformat = Pformat;
        Arp->Link = Gentype;
        Arp->Class = Node;
        Arp->Sub = G;
        Node = 0;
        G = Phrase[Class];
        if (Force) {
          Ptype = Force;
          Force = 0;
        }
        Gentype = 0;
        goto *Paction[Paction_sw = (unsigned)Gg >> 8 & 15];
      Paction_default:
        Debug(
            _imp_join(_imp_str_literal("* Switch label not set: paction("),
                      _imp_join(Itos((unsigned)Gg >> 8 & 15, 0),
                                _imp_join(_imp_str_literal(") {gg="), _imp_join(Itos(Gg, 0), _imp_str_literal("}"))))));
        exit(0);
      }
      goto *Act[Act_sw = (Class)-180];
    Act_default:
      Debug(_imp_join(_imp_str_literal("* Switch label not set: act("),
                      _imp_join(Itos(Class, 0), _imp_str_literal(")"))));
      exit(0);
    A5:;
      S = 0;
      while (Node) {
        Z = &Ar[Node].Link;
        K = *Z;
        *Z = S;
        S = Node;
        Node = K;
      }
      Ss = S;
    A6:
      if (Nmax) {
        K = Gentype;
        Arp = &Ar[Nmax];
        Nmax--;
        Node = Arp->Class;
        Gentype = Arp->Link;
        Ptype = Arp->Ptype;
        Pformat = Arp->Pformat;
        G = Arp->Sub;
        if (G & Escape) {
          G -= Escape;
          Papp = Arp->Papp;
          Mark = 255;
          Subatom = S;
          goto A3;
        }
        if (Gentype == 0 || K == Real) Gentype = K;
        Type = Gentype;
        K = Gg;
        for (;;) {
          Gg = Gram[G];
          if (!K) goto A2;
          if (Gg >= 0) goto Fail1;
          K -= Orderbit;
          G++;
        }
      }
      if (Copy) {
        Pos1 = Copy;
        Fault(4);
      }
      if (!Order) Fault(13);
      if (Forwarn) Fault(-4);
      Pos1 = 0;
      Faultrate--;
      return;
    Act_193:
      if (Sym != '=' && Sym != '<') {
        Gg = 0;
        goto A5;
      }
    Act_181:
      Atom1 = Amap[Decl & 15];
      goto More;
    Act_182:
      Class = Escdec;
      G = Glink[G] | Escape;
      Decl = 0;
      Otype = 0;
      goto Esc;
    Act_199:;
      S = 0;
      while (Node) {
        Z = &Ar[Node].Link;
        K = *Z;
        *Z = S;
        S = Node;
        Node = K;
      }
      Ss = S;
      if (Quote) Codeatom(28);
      Compile();
      if (!(Atom1 & Error)) goto More;
      goto Fail1;
    Act_184:
      if (Type != Integer) goto Fail4;
      if (Subatom < 0)
        Lit = Tag[-Subatom].Format;
      else
        Lit = Litpool[Subatom];
      if (Lit) goto Fail4;
      goto More;
    Act_185:;
      S = 0;
      while (Node) {
        Z = &Ar[Node].Link;
        K = *Z;
        *Z = S;
        S = Node;
        Node = K;
      }
      Ss = S;
      Atom1 = Ar[S].Class;
      Atom2 = 0;
      if (Atom1 == 97 || Atom1 == 98) Atom1 = Var;
      Arp = &Ar[Nmax];
      X = Arp->X;
      Pos1 = Arp->Pos;
      Pos2 = 0;
      App = 0;
      Format = Tag[X].Format;
      Flags = Tag[X].Flags;
      Type = (unsigned)Flags >> 4 & 7;
      Protection = Flags & Prot;
      if (Flags & Aname) Protection = 0;
      if ((Flags & Subname) != 0 && Format != 0)
        if (!Formatselected()) goto Fail1;
      goto A6;
    Act_187:
      Protection = Prot;
      goto More;
    Act_186:
      if (!(Protection & Prot)) goto More;
      Proterr = Nmin;
      goto A7;
    Act_191:
      K = Protection;
      Codeatom(0);
      if (!(Atomflags & Aname)) Protection = K;
      goto More;
    Act_192:
      if (!Parsedmachinecode()) goto Fail1;
      goto More;
    Act_189:
      K = Gapp();
      Deletenames(1);
      Tmax = Tbase;
      Tbase = Gram[Gmin];
      Local = Tbase;
      Gmin++;
      X = Ar[Ar[Nmax].Class].Sub;
      Tag[X].App = K;
      goto More;
    Act_190:
      Gmin--;
      if (Gmin <= Gmax) Abandon(2);
      Gram[Gmin] = Tbase;
      Tbase = Tmax;
      Local = Tbase;
      goto More;
    Fail4:
      K = Error + 10;
      goto Failed;
    Fail3:
      K = Error + 7;
      goto Failed;
    Fail2:
      K = Error + 5;
      Pos2 = 0;
      goto Failed;
    Fail0:
      K = Error + 3;
      goto Failed;
    Fail1:
      K = Atom1;
      Pos2 = 0;
    Failed:;
      if (Diag & 32) {
        Printstring(_imp_str_literal("Atom1 ="));
        Write(Atom1, 3);
        Printstring(_imp_str_literal("  Atom2 ="));
        Write(Atom2, 3);
        Printstring(_imp_str_literal("  subatom ="));
        Write(Subatom, 3);
        Newline();
        Printstring(_imp_str_literal("Type ="));
        Write(Type, 1);
        Printstring(_imp_str_literal("   Ptype ="));
        Write(Ptype, 1);
        Newline();
        Printstring(_imp_str_literal("App ="));
        Write(App, 1);
        Printstring(_imp_str_literal("   Papp ="));
        Write(Papp, 1);
        Newline();
        Printstring(_imp_str_literal("Format ="));
        Write(Format, 1);
        Printstring(_imp_str_literal("   Pformat ="));
        Write(Pformat, 1);
        Newline();
        _imp_monitor();
      }
      while (Sym != Nl && Sym != ';') {
        Quote = 0;
        Readsym();
      }
      if (K & Error)
        Fault(K & 255);
      else if (Proterr == Nmin)
        Fault(14);
      else
        Fault(0);
      Gg = 0;
      Ss = 0;
      Symtype = 0;
    }
    void Compile(void) {
      static const int Then = 4;
      static const int Else = 8;
      static const int Loop = 16;
      static int C_sw;
      static void *C[181 /*0:180*/] = {
          &&C_0,       &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
          &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
          &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
          &&C_default, &&C_default, &&C_default, &&C_27,      &&C_28,      &&C_29,      &&C_30,      &&C_31,
          &&C_32,      &&C_33,      &&C_34,      &&C_35,      &&C_36,      &&C_37,      &&C_38,      &&C_39,
          &&C_default, &&C_41,      &&C_42,      &&C_43,      &&C_44,      &&C_45,      &&C_46,      &&C_47,
          &&C_48,      &&C_49,      &&C_50,      &&C_51,      &&C_52,      &&C_53,      &&C_default, &&C_55,
          &&C_56,      &&C_57,      &&C_58,      &&C_59,      &&C_60,      &&C_default, &&C_62,      &&C_63,
          &&C_64,      &&C_65,      &&C_default, &&C_67,      &&C_68,      &&C_69,      &&C_70,      &&C_71,
          &&C_72,      &&C_default, &&C_74,      &&C_75,      &&C_76,      &&C_77,      &&C_78,      &&C_79,
          &&C_80,      &&C_81,      &&C_82,      &&C_83,      &&C_84,      &&C_85,      &&C_86,      &&C_87,
          &&C_88,      &&C_89,      &&C_90,      &&C_91,      &&C_92,      &&C_93,      &&C_default, &&C_default,
          &&C_96,      &&C_97,      &&C_98,      &&C_99,      &&C_100,     &&C_101,     &&C_102,     &&C_103,
          &&C_104,     &&C_105,     &&C_106,     &&C_107,     &&C_108,     &&C_109,     &&C_default, &&C_default,
          &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
          &&C_120,     &&C_121,     &&C_122,     &&C_default, &&C_124,     &&C_125,     &&C_126,     &&C_127,
          &&C_128,     &&C_default, &&C_130,     &&C_131,     &&C_132,     &&C_133,     &&C_134,     &&C_135,
          &&C_136,     &&C_137,     &&C_138,     &&C_139,     &&C_140,     &&C_141,     &&C_142,     &&C_143,
          &&C_144,     &&C_145,     &&C_146,     &&C_147,     &&C_148,     &&C_149,     &&C_default, &&C_151,
          &&C_152,     &&C_153,     &&C_154,     &&C_155,     &&C_156,     &&C_157,     &&C_158,     &&C_159,
          &&C_160,     &&C_161,     &&C_162,     &&C_163,     &&C_164,     &&C_165,     &&C_166,     &&C_167,
          &&C_168,     &&C_default, &&C_170,     &&C_171,     &&C_172,     &&C_173,     &&C_174,     &&C_175,
          &&C_default, &&C_default, &&C_default, &&C_default, &&C_default,
      };
      static int Litop_sw;
      static void *Litop[12 /*1:12*/] = {
          &&Litop_1, &&Litop_2, &&Litop_3, &&Litop_4,  &&Litop_5,  &&Litop_6,
          &&Litop_7, &&Litop_8, &&Litop_9, &&Litop_10, &&Litop_11, &&Litop_12,
      };
      static const unsigned char Operator[14 /*1:14*/] = {'[', ']', 'X', '/', '&', '!', '%',
                                                          '+', '-', '*', 'Q', 'x', '.', 'v'};
      static const unsigned char Cc[8 /*0:7*/] = {'#', '=', ')', '<', '(', '>', 'k', 't'};
      static const unsigned char Anyform[16 /*0:15*/] = {1, 0, 1, [3 ... 6] = 1, 1, 0, 1, 1, 0, 1, 1, 1, 1};
      static const short Decmap[16 /*0:15*/] = {1,      2,      0x100B, 0x100D, 0x140C, 0x140E, 3, 4,
                                                0x1007, 0x1008, 0x1009, 0x100A, 6,      0,      0, 0};
      static unsigned char Cnest[16 /*0:15*/];
      int Lmode;
      int Clab;
      int Dupid;
      int Resln;
      static int Lastdef = 0;
      static int Lb;
      static int Ub;
      int Cp;
      int Ord;
      int Next;
      int Link;
      int J;
      int K;
      int N;
      int Done;
      int Class;
      int Lit2;
      int Defs;
      int Decs;
      int Cident;
      int Pending;
      static int Pstack[40 /*1:40*/];
      static _imp_string Name = _imp_str_literal("");
      static int Count = 0;
      void Deflab(int L) {
        Op(':', L);
        Access = 1;
      }
      void Getnext(void) {
        Arfm *P;
      Gn:
        if (!Next) {
          if (!Link) {
            Class = 0;
            return;
          }
          P = &Ar[Link];
          Next = P->Link;
          Link = P->Sub;
        }
        for (;;) {
          P = &Ar[Next];
          X = P->Sub;
          Class = P->Class;
          if (Class < Actions) break;
          if (!X) {
            Next = P->Link;
            goto Gn;
          }
          if (P->Link) {
            P->Sub = Link;
            Link = Next;
          }
          Next = X;
        }
        Next = P->Link;
        if (Diag & 2) {
          if (_imp_strcmp(Name, _imp_str_literal("")) != 0) Spaces(8 - *Length(Name));
          Name = Text[Class];
          Write(X, 2);
          Space();
          Printstring(Name);
          Space();
          Count--;
          if (Count <= 0) {
            Count = 5;
            Name = _imp_str_literal("");
            Newline();
          }
        }
      }
      void Setsubs(int N) {
        int P;
        P = Tmax;
        while (N > 0) {
          if (P < Tbase) _imp_signal(15, 15, 0, _imp_str_literal(""));
          Tag[P].App = Dimension;
          P--;
          N--;
        }
      }
      void Setbp(void) {
        Pending -= 2;
        Lb = Pstack[Pending + 1];
        Ub = Pstack[Pending + 2];
        if (Ub < Lb - 1) {
          Pos1 = 0;
          Next = Link;
          Fault(11);
          Ub = Lb;
        }
        Setconst(Lb);
        Setconst(Ub);
        if (Class != 146) Put('b');
      }
      void Compileend(int Type) {
        if (Access) {
          Open = 0;
          if (Blockform > Proc) Fault(19);
        }
        while (Dict[Dmin] >= 0) {
          Fault(17 + (Dict[Dmin] & 1));
          Dmin++;
        }
        Put(';');
        if (Type == 1) Put(';');
        *Bflags = *Bflags | Open;
        if (Blocktag != 0 && Level != 1) Deflab(0);
        if (Type != 2) {
          if (Level != Type) Fault(16);
        } else if (!Level) {
          Fault(15);
        }
      }
      void Def(int P) {
        int T;
        int F;
        int Type;
        Tagfm *V;
        Defs++;
        V = &Tag[P];
        T = 0;
        Put('$');
        if (V->Index >= 0) {
          if (!V->Index) {
            Id++;
            V->Index = Id;
          }
          Lastdef = V->Index;
          Putword(Lastdef);
        } else
          Putword(0);
        Printident(P, 1);
        T = V->Flags;
        Type = T;
        if ((Type & (7 << 4)) >= 6 << 4) Type = Type & (~(7 << 4));
        Put(',');
        Put(Type & 0b1111111);
        F = V->Format;
        if ((T & 0x70) == Record << 4) F = Tag[F].Index;
        if (F < 0) F = V->Index;
        Op(',', F);
        F = Otype + ((unsigned)T >> 4 & 0b1111000);
        if (Class == 125) F = F | 8;
        Dim = V->App;
        if (0 >= Dim || Dim > Dimlimit) Dim = 0;
        Put(',');
        Putlong(F + (Dim << 8));
        if (!(T & Parameters)) Defs = 0;
        F = T & 15;
        if (V->Flags & Spec) {
          if (3 > F || F > 10) V->Flags = V->Flags & (~Spec);
          Ocount = -1;
        }
        Dimension = 0;
        if (Otype == 2 && (F == 2 || F == 12 || F == 14)) {
          V->Flags = V->Flags - 1;
        }
      }
      void Defslab(int N) {
        int P;
        int L;
        int B;
        int W;
        int Bit;
        P = Tag[X].Format;
        L = Dict[P];
        if (L <= N && N <= Dict[P + 1]) {
          B = N - L;
          W = ((unsigned)B >> 4) + P;
          Bit = 1 << (B & 15);
          if (Dict[W + 2] & Bit) {
            if (Pending) Fault(4);
            return;
          }
          if (Pending) Dict[W + 2] = Dict[W + 2] | Bit;
          Setconst(N);
          Op('_', Tag[X].Index);
        } else
          Fault(12);
        Access = 1;
      }
      void Call(void) {
        Tagfm *T;
        T = &Tag[X];
        Op('@', T->Index);
        if (T->Flags & Closed) Access = 0;
        if (!T->App) Put('E');
      }
      void Popdef(void) {
        Setconst(Pstack[Pending]);
        Pending--;
      }
      void Poplit(void) {
        if (!Pending)
          Lit = 0;
        else {
          Lit = Pstack[Pending];
          Pending--;
        }
      }
      if (Sstype < 0)
        if (!Level) {
          Fault(13);
        } else if (!Access) {
          Access = 1;
          Fault(-1);
        }
      if (Diag & 2) {
        if (Sym != Nl) Newline();
        Printstring(_imp_str_literal("ss ="));
        Write(Ss, 1);
        Newline();
        Count = 5;
        Name = _imp_str_literal("");
      }
      Next = Ss;
      Pending = 0;
      Lmode = 0;
      Link = 0;
      Decs = 0;
      Defs = 0;
      Resln = 0;
      Done = 0;
      Ord = Level;
      if (This >= 0) Ord = 1;
    C_0:;
    Top:
      if (Next != Link) {
        Getnext();
        goto *C[C_sw = Class];
      C_default:
        Debug(_imp_join(_imp_str_literal("* Switch label not set: c("),
                        _imp_join(Itos(Class, 0), _imp_str_literal(")"))));
        exit(0);
      }
      if ((Diag & 2) != 0 && Count != 5) Newline();
      if (Lmode & (Loop | Then | Else)) {
        if (Lmode & Loop) Op('B', Label - 1);
        if (Lmode & Then) Deflab(Label);
        if (Lmode & Else) Deflab(Label - 1);
      }
      if (!Decs) return;
      if (Atom1) {
        Atom1 = Error;
        return;
      }
      Order = Ord;
      Decl = (Decl & (~15)) + Decmap[Decl & 15];
      Atom1 = Atoms[Decl & 15];
      if (Otype) {
        if (Atom1 != Proc) Atom1++;
        if (Otype == 2) {
          N = Decl & 15;
          if (N & 1) {
            Decl = Decl | Prot;
            if ((Decl & 0b1111111) == Iform) Decl = Decl | Constbit;
          }
        } else
          Decl = Decl | Ownbit;
      }
      if (Sstype == 0 && Atom1 == Proc) Sstype = 1;
      if (Decl & Spec) Atom1++;
      if (Atom1 == 5) {
        Ocount = 0;
        Cont = '+';
      }
      if (!Anyform[Decl & 15]) {
        if (((unsigned)Decl >> 4 & 7) == Record) {
          if (Tag[Fdef].Flags & Spec) This = Fdef;
          if (Fdef == This) Atom1 = Error + 21;
        }
        if (!Fdef) Atom1 = Error + 10;
      }
      return;
    Atop:
      Access = 0;
      goto Top;
    C_88:;
    C_28:
      Decl = X & (~7);
      Fdef = X & 7;
      if ((X & 0b1110001) == (Real << 4) + 1) Fdef = Realsln;
      Decs = 1;
      goto Top;
    C_34:;
    C_35:
      Otype = X;
      Ord = 1;
      goto Top;
    C_152:
      Decl += X << 1;
      goto Top;
    C_31:;
    C_32:
      Specmode = Level + 1;
      if (X == 9) Decl = Decl | Prot;
    C_29:
      Ord = 1;
      Dim = 0;
    C_30:
      Decl += X;
      Decs = 1;
      goto Top;
    C_27:
      Lit = 0;
      if (Pending) {
        Poplit();
        if (0 >= Lit || Lit > Dimlimit) {
          Atom1 = Error + 11;
          return;
        }
      }
      Dim = Lit;
      Decl += X;
      Decs = 1;
      goto Top;
    C_37:
      X = X | Subname;
    C_36:
      Lit = 0;
      if (Pending) {
        Poplit();
        if (0 >= Lit || Lit > 255) {
          Atom1 = Error + 10;
          return;
        }
      }
      Fdef = Lit;
    C_33:
      Decl = X;
      Decs = 1;
      goto Top;
    C_39:
      Decl = Decl | Spec;
      Ocount = -1;
      Specmode = -1;
      goto Top;
    C_38:
      Decl = 64 + 4;
      Order = 1;
      Atom1 = X;
      if (Atom1 == 12) Decl = Decl | Spec;
      Fdef = Tmax + 1;
      return;
    C_175:
      Id++;
      Tag[X].Index = Id;
      return;
    C_41:
      Decs = 1;
      Decl = X | Spec;
      goto Top;
    C_133:
      Recid = 0;
      Rbase = Tmin - 1;
      This = X;
      Fmbase = Fdef;
      Formatlist = Tmin;
      Def(This);
      goto Top;
    C_148:
      if (!Next) {
        Fdef = 0;
        goto Top;
      }
      Getnext();
      Fdef = X;
      goto Top;
    C_127:
      Put('}');
      goto Top;
    C_126:
      Put('{');
      goto Top;
    C_174:
      Setbp();
    C_171:;
    C_172:;
    C_173:
      Put('~');
      Put(Class - 171 + 'A');
      goto Top;
    C_168:
      Rbase = -Rbase;
      Sstype = 0;
      Specmode = 0;
    C_147:
      Searchbase = 0;
      Tag[This].App = Tmin;
      Tag[This].Format = Rbase;
      goto Top;
    C_45:
      if (X == 36) Put('U');
      goto Top;
    C_46:
      Put('\\');
      goto Top;
    C_47:;
    C_48:;
    C_42:;
    C_43:;
    C_44:
      Put(Operator[X]);
      goto Top;
      void Push(int X) {
        if ((Cnest[Cp] & 2) != X) {
          Cnest[Cp] = Cnest[Cp] | 1;
          X += 4;
        }
        if (Cnest[Cp] & 1) Clab++;
        Cnest[Cp + 1] = X;
        Cp++;
      }
      void Poplabel(int Mode) {
        Lmode = Dict[Dmin];
        if (Lmode < 0 || (Lmode & 1) != Mode)
          Fault(Mode + 8);
        else {
          Dmin++;
          Label -= 3;
        }
      }
    C_56:;
    C_57:
      Push(X);
      goto Top;
    C_58:
      Cnest[Cp] = Cnest[Cp] ^ 2;
      goto Top;
    C_138:
      X = 128 + 32 + 16 + 4;
    C_59:;
    C_60:
      if (Class == 138)
        Op('f', Label - 1);
      else
        Deflab(Label - 1);
    C_166:;
    C_62:
      Lmode = (Lmode & (Else | Loop)) | ((unsigned)X >> 3);
      Clab = Label;
      Cp = 1;
      Cnest[1] = X & 7;
      goto Top;
    C_72:
      Poplabel(0);
      if (Lmode & 32) Deflab(Label + 1);
      goto Atop;
    C_69:
      Poplabel(1);
      goto Top;
    C_163:;
    C_70:
      Poplabel(1);
      if ((Lmode & 3) == 3) Fault(7);
    C_68:
      Lmode = (Lmode & Else) | 3;
      if (Access) {
        Op('F', Label - 1);
        Lmode = Else | 3;
      }
      Deflab(Label);
      if (Next) goto Top;
    C_120:;
    C_67:;
    C_71:;
    Stcy:
      if (!Lmode) {
        Deflab(Label - 1);
        Lmode = Loop;
      }
      Dmin--;
      if (Dmin <= Dmax) Abandon(3);
      Dict[Dmin] = Lmode;
      Label += 3;
      return;
    C_64:
      if (Dict[Dmin] >= 0 || Inhibit != 0) Fault(13);
      Inhibit = 1;
      Lastarray = Tmax - 1;
      N = 0;
      if (!Pending) N = 0xFFFF;
      while (Pending > 0) {
        Poplit();
        if (Lit & (~15)) Fault(10);
        J = 1 << Lit;
        if (N & J) Dubious = 1;
        N = N | J;
      }
      Op('o', N);
      Op(',', Label);
      Lmode = Then | 1;
      goto Stcy;
    C_104:
      Op('J', Tag[X].Index);
      Inhibit = 1;
      goto Atop;
    C_149:
      Stats--;
      Access = 1;
      Inhibit = 1;
      if (X < Lastarray) Fault(13);
      Op('L', Tag[X].Index);
      goto Top;
    C_63:
      J = Dmin;
      L = Label - 3;
      for (;;) {
        if (Dict[J] < 0) {
          Fault(7);
          goto Top;
        }
        if (!(Dict[J] & 1)) break;
        J++;
        L -= 3;
      }
      if (X == 32) L++;
      Op('F', L);
      Dict[J] = Dict[J] | X;
      goto Atop;
    C_50:
      Put('C');
      goto Cop;
    C_49:;
      if (Next) {
        Put('"');
        Push(0);
      } else
        Put('?');
    Cop:
      if (Cnest[Cp] & 2) X = X ^ 1;
      J = Cp;
      L = Clab;
      while (!(Cnest[J] & 4)) {
        J--;
        L -= Cnest[J] & 1;
      }
      Op(Cc[X], L);
      if (Cnest[Cp] & 1) Deflab(Clab + 1);
      Cp--;
      Clab -= Cnest[Cp] & 1;
      goto Top;
    C_78:;
    C_79:;
    C_80:
      Open = 0;
    C_82:
      Access = 0;
    C_89:;
    C_81:
      Put(X);
      goto Top;
    C_65:
      Poplit();
      Op('e', Lit);
      goto Atop;
    C_51:
      Put('S');
      goto Top;
    C_53:
      Put('j');
      goto Top;
    C_52:
      Put('Z');
      goto Top;
    C_74:
      if (!Level) {
        if (Progmode <= 0)
          Progmode = 1;
        else
          Fault(7);
      }
      Specmode = Level + 1;
      Blockx = 0;
      Put('H');
      return;
    C_77:
      Perm = 0;
      Lines = 0;
      Stats = 0;
      Debug(_imp_join(_imp_str_literal("close input    {input stream="),
                      _imp_join(Itos(Inputstream(), 0), _imp_str_literal("}"))));
      Closeinput();
      Debug(_imp_join(_imp_str_literal("select input(source="), _imp_join(Itos(Source, 0), _imp_str_literal(")"))));
      Selectinput(Source);
      Sym = Nl;
      List--;
      if (Command & Listbit) List--;
      Tbase = Tmax;
      Tstart = Tmax;
      return;
    C_76:
      if (Include != 0 && X == 0) {
        Lines = Include;
        Sstype = 0;
        Debug(_imp_join(_imp_str_literal("close input    {input stream="),
                        _imp_join(Itos(Inputstream(), 0), _imp_str_literal("}"))));
        Closeinput();
        List = Includelist;
        Include = 0;
        Debug(_imp_join(_imp_str_literal("select input(source="), _imp_join(Itos(Source, 0), _imp_str_literal(")"))));
        Selectinput(Source);
        Sym = Nl;
        return;
      }
      Ss = -1;
    C_75:
      Compileend(X);
      return;
    C_85:
      if (!X)
        Control = Lit;
      else if (((unsigned)Lit >> 14 & 3) == 1)
        Diag = Lit & 0x3FFF;
      Op('z' - X, Lit);
      goto Top;
    C_83:
      List = List + X - 2;
      goto Top;
    C_84:
      Realsln = X;
      goto Top;
    C_86:
      if (Include) {
        Fault(7);
        return;
      }
      Getnext();
      Includefile = *String(X - 0x4000 + Stbase);
      Openinput(3, Includefile);
      Include = Lines;
      Lines = 0;
      Includelist = List;
      Debug(_imp_str_literal("select input(3)"));
      Selectinput(3);
      Sym = Nl;
      goto Top;
    C_154:
      Dimension++;
      if (Dimension == Dimlimit + 1) Fault(11);
      goto Top;
    C_145:
      Setbp();
      goto Top;
    C_146:
      Setbp();
    C_142:;
      if (!Dimension) Dimension = 1;
      Op('d', Dimension);
      Op(',', Defs);
      if (Class != 146) {
        Setsubs(Defs);
        Lastarray = Tmax - 1;
        if (Dict[Dmin] >= 0 || Inhibit != 0 || Level == 0) Fault(13);
      }
      Dimension = 0;
      Defs = 0;
      goto Top;
    C_128:
      Id = Dupid;
      goto Top;
    C_130:
      Blockx = X;
      if ((Decl & Spec) == 0 && Level != 0) Op('F', 0);
    C_125:
      Dupid = Id;
    C_90:
      Def(X);
      goto Top;
    C_131:;
      if ((Tag[X].Flags & (0b1111111 + Constbit)) == Iform + Constbit)
        Tag[X].Format = Lit;
      else {
        if (Pending) Setconst(Lit);
        Def(X);
        Put('A');
        Putlong(1);
      }
      Cident = X;
      goto Top;
    C_124:
      if (Tag[Cident].Flags & Prot) Dubious = 1;
      goto Top;
    C_97:;
    C_98:;
    C_99:;
    C_96:
      Call();
      goto Top;
    C_165:;
    C_100:;
    C_101:;
    C_102:;
    C_103:;
    C_91:;
    C_92:;
    C_106:;
    C_107:;
    C_108:;
    C_109:;
      K = Tag[X].Index;
      if (K < 0)
        Op('n', -K);
      else
        Op('@', K);
      goto Top;
    C_121:
      Setconst(0);
      goto Top;
    C_167:
      Put('G');
      goto Pstr;
    C_93:;
      if (X < 0) {
        Setconst(Tag[-X].Format);
        goto Top;
      }
      if (X & 0x4000) {
        Put('\'');
      Pstr:
        X = X - 0x4000 + Stbase;
        K = *Byteinteger(X);
        Putblock(K + 1, *Byteinteger(X));
        goto Top;
      }
      if (X & 0x2000) {
        X = X - 0x2000 + Stbase;
        K = *Byteinteger(X);
        Op('D', K);
        Put(',');
        K += X;
        for (;;) {
          if (X == K) goto Top;
          X++;
          J = *Byteinteger(X);
          if (J == '@') {
            Op('@', Litpool[*Byteinteger(X + 1)]);
            goto Top;
          }
          Put(J);
        }
      }
      Setconst(Litpool[X]);
      goto Top;
    C_137:
      Put('i');
      goto Top;
    C_141:
      Put('a');
      goto Top;
    C_132:
      Ocount = Ub - Lb + 1;
      Def(X);
      Dimension = 1;
      Setsubs(1);
      if (!Next) {
        if (Ocount > 0) {
          Put('A');
          Putlong(Ocount);
        }
        Ocount = -1;
      } else
        Getnext();
      goto Top;
    C_162:
      Lit = Ocount;
      goto Ins;
    C_143:
      Poplit();
    Ins:
      if (Lit < 0) {
        Fault(10);
        Lit = 0;
      }
      Getnext();
      goto Inst;
    C_139:;
    C_153:
      Lit = 1;
    Inst:
      if (Pending) Popdef();
      Put('A');
      Putlong(Lit);
      Ocount -= Lit;
      if (Ocount >= 0) {
        if (X) goto Top;
        if (!Ocount) {
          Ocount = -1;
          return;
        }
      }
      Fault(11);
      return;
    C_105:
      Op('W', Tag[X].Index);
      Inhibit = 1;
      goto Atop;
    C_134:
      Def(X);
      N = Ub - Lb + 1;
      N = (unsigned)(N + 15) >> 4;
      J = Dmax;
      Dmax = Dmax + N + 2;
      if (Dmax >= Dmin) Abandon(1);
      Tag[X].Format = J;
      Dict[J] = Lb;
      Dict[J + 1] = Ub;
      for (;;) {
        N--;
        if (N < 0) goto Top;
        J++;
        Dict[J + 1] = 0;
      }
    C_151:
      Stats--;
      if (X < Tbase) {
        Fault(7);
        return;
      }
      if (Pending)
        Defslab(Pstack[1]);
      else {
        if (Tag[X].App) {
          Fault(4);
          return;
        }
        Tag[X].App = 1;
        N = Tag[X].Format;
        for (J = Dict[N]; J <= Dict[N + 1]; J++) {
          Defslab(J);
        }
      }
      Inhibit = 1;
      return;
    C_140:
      Put('p');
      goto Top;
    C_144:
      Put('p');
      Put('E');
      goto Top;
    C_155:;
      if (X < 0)
        Lit = Tag[-X].Format;
      else
        Lit = Litpool[X];
      Pending++;
      Pstack[Pending] = Lit;
      goto Top;
    C_156:
      Lit = Pstack[Pending];
      if (Lit < 0) Lit = -Lit;
      Pstack[Pending] = Lit;
      goto Top;
    C_157:
      if (X != 36) goto Top;
      Lit = -Pstack[Pending];
      Pstack[Pending] = Lit;
      goto Top;
    C_158:
      Lit = ~Pstack[Pending];
      Pstack[Pending] = Lit;
      goto Top;
    C_159:;
    C_160:;
    C_161:
      Pending--;
      Lit2 = Pstack[Pending + 1];
      Lit = Pstack[Pending];
      goto *Litop[Litop_sw = ((unsigned)X >> 2) - 1];
    Litop_default:
      Debug(_imp_join(_imp_str_literal("* Switch label not set: litop("),
                      _imp_join(Itos((unsigned)X >> 2, 0),
                                _imp_join(_imp_str_literal(") {x="), _imp_join(Itos(X, 2), _imp_str_literal("}"))))));
      exit(0);
    Litop_10:
      Lit = Lit * Lit2;
      goto Setl;
    Litop_12:;
    Litop_3:
      N = 1;
      if (Lit2 < 0) Fault(10);
      while (Lit2 > 0) {
        Lit2--;
        N = N * Lit;
      }
      Lit = N;
      goto Setl;
    Litop_1:
      Lit = Lit << Lit2;
      goto Setl;
    Litop_2:
      Lit = (unsigned)Lit >> Lit2;
      goto Setl;
    Litop_5:
      Lit = Lit & Lit2;
      goto Setl;
    Litop_11:;
    Litop_4:
      if (!Lit2)
        Fault(10);
      else
        Lit = Lit / Lit2;
      goto Setl;
    Litop_8:
      Lit += Lit2;
      goto Setl;
    Litop_9:
      Lit -= Lit2;
      goto Setl;
    Litop_6:
      Lit = Lit | Lit2;
      goto Setl;
    Litop_7:
      Lit = Lit ^ Lit2;
    Setl:
      Pstack[Pending] = Lit;
      goto Top;
    C_170:;
      Put('~');
      Put('D');
      goto Pstr;
    C_135:
      Resln = 2;
      goto Top;
    C_136:
      Resln++;
      goto Top;
    C_55:
      Op('r', Resln);
      Resln = 0;
      goto Top;
    C_164:
      Op('r', Resln + 4);
      Resln = 0;
    C_122:
      X = 6;
      goto Cop;
    C_87:
      Setconst(Pstack[1]);
      Put('P');
      goto Top;
    }
  }
  Debug(_imp_join(_imp_str_literal("ENTERED PASS1  object tank="),
                  _imp_join(Itos(Objecttank, 0), _imp_str_literal(" *************"))));
  if (_imp_on_event(9)) {
    Debug(_imp_str_literal("[3]%ON 9 %START:"));
    Abandon(5);
  }
  Selectoutput(Listing);
  if (Command & Listbit) {
    Printstring(_imp_join(
        _imp_str_literal("\n      Computer Science VAX-11 IMP77 Compiler.  Version 8.02\n\n            Compiled on "),
        _imp_join(Date(), _imp_join(_imp_str_literal(" at "), Time()))));
    Newlines(2);
    Debug(_imp_str_literal("select input(1)"));
    Selectinput(1);
    Printstring(_imp_join(_imp_str_literal("   Source file: "), Infilename()));
    Newline();
    Newline();
  }
  Debug(_imp_join(_imp_str_literal("select input(prims="), _imp_join(Itos(Prims, 0), _imp_str_literal(")"))));
  Selectinput(Prims);
  Debug(_imp_join(_imp_str_literal("select output tank(object tank="),
                  _imp_join(Itos(Objecttank, 0), _imp_str_literal(")"))));
  Selectoutputtank(Objecttank);
  Tag[Maxtag] = 0;
  Tag[0] = 0;
  Tag[0].Flags = 7;
  for (X = 0; X <= Maxnames; X++) {
    Hash[X] = 0;
  }
  Includefile = _imp_str_literal("");
  Put('l');
  Putword(0);
  Compileblock(0, 0, Maxdict, 0, 0);
  if (Faulty) return (-Faulty);
  return (Stats);
}
