#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  static const int Debug = 0;
  static int Com2 = 20000;
  static int Com24 = 0;
  int Com(int Idx) {
    if (Idx == 24) return (Com24);
    if (Idx == 2) return (Com2);
    exit(0);
  }
  void Setcom(int Idx, int Val) {
    if (Idx == 24) {
      Com24 = Val;
      return;
    }
    if (Idx == 2) {
      Com2 = Val;
      return;
    }
    exit(0);
  }
  void Setshortinteger(int Address, short Value) { Shortinteger = Value; }
  int I;
  int J;
  int K;
  int Ss;
  static unsigned char Clett[425 /*1:425*/] = {
      1,   43,  1,   45,  1,   92,  1,   40,  1,   41,  1,   33,  1,   44,  2,   42,  42,  2,   33,  33,  1,   42,  2,
      47,  47,  1,   47,  1,   38,  2,   62,  62,  2,   60,  60,  1,   46,  1,   63,  2,   201, 198, 6,   213, 206, 204,
      197, 211, 211, 7,   201, 206, 212, 197, 199, 197, 210, 4,   210, 197, 193, 204, 4,   194, 217, 212, 197, 5,   211,
      200, 207, 210, 212, 4,   204, 207, 206, 199, 6,   211, 212, 210, 201, 206, 199, 7,   210, 207, 213, 212, 201, 206,
      197, 2,   198, 206, 3,   205, 193, 208, 4,   206, 193, 205, 197, 6,   210, 197, 195, 207, 210, 196, 4,   211, 212,
      207, 208, 7,   195, 207, 205, 208, 201, 204, 197, 6,   201, 199, 206, 207, 210, 197, 2,   207, 206, 3,   207, 198,
      198, 5,   193, 210, 210, 193, 217, 3,   193, 206, 196, 2,   207, 210, 2,   61,  61,  1,   61,  2,   60,  45,  2,
      45,  62,  4,   211, 208, 197, 195, 6,   206, 207, 210, 205, 193, 204, 6,   214, 197, 195, 212, 207, 210, 1,   58,
      2,   62,  61,  1,   62,  1,   35,  2,   60,  61,  1,   60,  2,   92,  61,  4,   197, 204, 211, 197, 1,   95,  6,
      211, 217, 211, 212, 197, 205, 8,   197, 216, 212, 197, 210, 206, 193, 204, 5,   195, 204, 193, 201, 205, 7,   210,
      197, 204, 197, 193, 211, 197, 1,   80,  3,   80,  85,  84,  1,   64,  9,   208, 210, 201, 206, 212, 212, 197, 216,
      212, 6,   210, 197, 212, 213, 210, 206, 7,   210, 197, 211, 213, 204, 212, 61,  7,   205, 207, 206, 201, 212, 207,
      210, 5,   211, 212, 193, 210, 212, 7,   209, 213, 197, 210, 201, 197, 211, 5,   195, 217, 195, 204, 197, 6,   210,
      197, 208, 197, 193, 212, 4,   212, 200, 197, 206, 3,   197, 206, 196, 7,   195, 207, 205, 205, 197, 206, 212, 5,
      210, 197, 193, 204, 211, 5,   194, 197, 199, 201, 206, 2,   207, 198, 7,   208, 210, 207, 199, 210, 193, 205, 6,
      211, 215, 201, 212, 195, 200, 8,   210, 197, 199, 201, 211, 212, 197, 210, 3,   207, 215, 206, 5,   205, 195, 207,
      196, 197, 5,   198, 193, 213, 204, 212, 4,   198, 201, 204, 197, 6,   196, 197, 198, 201, 206, 197, 1,   210, 7,
      211, 208, 197, 195, 201, 193, 204, 4,   204, 201, 211, 212, 7,   195, 207, 206, 212, 210, 207, 204, 6,   198, 201,
      206, 201, 211, 200, 6,   198, 207, 210, 205, 193, 212};
  static short Symbol[849 /*1300:2148*/] = {
      1309, 1303, 1,    1305, 3,    1307, 5,    1309, 1000, 1316, 1312, 1,    1314, 3,    1316, 1000, 1335, 1321, 1001,
      1342, 1706, 1323, 1003, 1329, 7,    1300, 1316, 1335, 9,    1335, 11,   1300, 1316, 1335, 11,   1342, 1340, 1361,
      1316, 1335, 1342, 1000, 1352, 1350, 7,    1300, 1316, 1335, 1352, 9,    1352, 1000, 1361, 1359, 13,   1300, 1316,
      1335, 1352, 1361, 1000, 1388, 1364, 15,   1366, 1,    1368, 3,    1370, 18,   1372, 11,   1374, 21,   1376, 23,
      1378, 26,   1380, 28,   1382, 30,   1384, 33,   1386, 36,   1388, 1000, 1393, 1391, 38,   1393, 1000, 1398, 1396,
      13,   1398, 1000, 1403, 1401, 40,   1403, 43,   1420, 1406, 50,   1408, 58,   1411, 63,   50,   1414, 68,   50,
      1417, 74,   58,   1420, 79,   1883, 1426, 1423, 86,   1426, 1403, 1426, 1431, 1429, 94,   1431, 97,   1445, 1435,
      1420, 1467, 1438, 1403, 1472, 1441, 1462, 101,  1445, 106,  1462, 101,  1450, 1448, 1005, 1450, 1001, 1457, 1453,
      113,  1455, 118,  1457, 126,  1462, 1460, 133,  1462, 136,  1467, 1465, 140,  1467, 1000, 1472, 1470, 101,  1472,
      1000, 1484, 1477, 101,  140,  101,  1480, 140,  101,  1482, 101,  1484, 1000, 1493, 1491, 7,    1431, 1009, 1493,
      9,    1493, 1000, 1501, 1499, 1393, 1431, 1009, 1493, 1501, 1000, 1520, 1513, 1010, 1300, 1316, 1335, 1669, 1300,
      1316, 1335, 1520, 1011, 1520, 7,    1010, 1501, 1528, 1011, 9,    1528, 1526, 1669, 1300, 1316, 1335, 1528, 1000,
      1539, 1533, 146,  1501, 1539, 1537, 150,  1501, 1546, 1539, 1000, 1546, 1544, 146,  1501, 1539, 1546, 1000, 1553,
      1551, 150,  1501, 1546, 1553, 1000, 1562, 1560, 1562, 1300, 1316, 1335, 1388, 1562, 1000, 1571, 1565, 153,  1567,
      156,  1569, 158,  1571, 161,  1576, 1574, 164,  1576, 1000, 1581, 1579, 74,   1581, 169,  1588, 1586, 13,   1714,
      1581, 1588, 1000, 1599, 1592, 1472, 1009, 1596, 1467, 140,  1599, 1599, 176,  1613, 1607, 1607, 1009, 7,    1714,
      1581, 9,    1607, 1613, 1611, 13,   1599, 1613, 1000, 1618, 1618, 1009, 1635, 1618, 1624, 1622, 13,   1613, 1624,
      1000, 1635, 1629, 1001, 1723, 1006, 1635, 140,  1001, 1635, 1890, 1004, 1644, 1644, 7,    1309, 1003, 183,  1309,
      1003, 9,    1651, 1649, 13,   1005, 1644, 1651, 1000, 1661, 1659, 13,   1005, 1644, 161,  1445, 1651, 1661, 1000,
      1669, 1667, 13,   1009, 1635, 1661, 1669, 1000, 1686, 1672, 156,  1674, 185,  1676, 188,  1678, 190,  1680, 192,
      1682, 195,  1684, 197,  1686, 161,  1694, 1689, 1006, 1694, 1398, 1501, 1528, 1006, 1700, 1698, 200,  1902, 1700,
      1000, 1706, 1704, 205,  1001, 1706, 1000, 1714, 1712, 205,  1001, 1342, 1706, 1714, 1000, 1723, 1723, 1300, 1316,
      1335, 183,  1300, 1316, 1335, 1730, 1728, 156,  1300, 1003, 1730, 1000, 1737, 1733, 207,  1735, 214,  1737, 1000,
      1742, 1740, 223,  1742, 229,  1747, 1745, 140,  1747, 106,  1757, 1755, 1393, 1403, 1467, 140,  1599, 1747, 1757,
      1000, 1764, 1762, 1431, 1009, 1493, 1764, 1000, 1772, 1768, 1001, 1857, 1772, 195,  1445, 188,  1785, 1780, 1005,
      7,    1005, 13,   1005, 9,    1785, 1764, 7,    1005, 9,    1792, 1789, 1764, 1883, 1792, 1005, 1792, 1805, 1799,
      7,    1005, 13,   1005, 9,    1803, 7,    1005, 9,    1805, 1000, 1811, 1809, 13,   1003, 1811, 1000, 1817, 1814,
      1764, 1817, 1005, 1883, 1857, 1823, 1012, 1005, 13,   1005, 1828, 1013, 1005, 13,   1785, 1835, 1014, 1005, 13,
      1005, 13,   1811, 1839, 1015, 1811, 1805, 1844, 1016, 1005, 13,   1811, 1849, 1017, 1772, 13,   1811, 1854, 1018,
      1772, 13,   1772, 1857, 1019, 1005, 1863, 1861, 1,    1005, 1863, 1000, 1883, 1872, 21,   1005, 13,   1895, 1001,
      1342, 1706, 1876, 161,  237,  1005, 1879, 1002, 1817, 1883, 239,  205,  1003, 1890, 1888, 7,    1005, 9,    1890,
      1000, 1895, 1893, 156,  1895, 1000, 1902, 1898, 243,  1900, 156,  1902, 1000, 1943, 1910, 1010, 1001, 1342, 1706,
      1011, 1553, 1918, 161,  1001, 7,    1300, 1316, 1335, 9,    1921, 161,  1445, 1924, 245,  1008, 1926, 255,  1931,
      262,  1300, 1316, 1335, 1933, 113,  1936, 270,  113,  1938, 278,  1940, 270,  1943, 284,  1457, 2149, 1949, 1010,
      1902, 1011, 1686, 1967, 292,  1001, 1342, 1706, 156,  1300, 1316, 1335, 13,   1300, 1316, 1335, 13,   1300, 1316,
      1335, 1006, 1970, 298,  1006, 1973, 1445, 183,  1985, 1398, 1010, 1501, 1528, 305,  1011, 1010, 1902, 1011, 1694,
      1006, 1988, 11,   1007, 1992, 1403, 1588, 1006, 1995, 310,  1006, 2004, 1010, 1730, 1420, 1011, 1571, 1001, 1484,
      1006, 2007, 314,  1007, 2011, 322,  1576, 1006, 2014, 328,  1006, 2019, 310,  334,  337,  1006, 2026, 1001, 7,
      1309, 1003, 9,    183,  2032, 345,  1009, 1635, 1661, 1006, 2036, 1450, 284,  1006, 2040, 352,  1001, 1006, 2044,
      361,  1403, 1624, 2050, 1737, 1742, 352,  1001, 1006, 2053, 365,  1006, 2057, 68,   86,   1006, 2061, 21,   1863,
      1006, 2069, 371,  1005, 1644, 161,  1445, 1651, 1006, 2074, 310,  334,  377,  1006, 2079, 310,  334,  365,  1006,
      2084, 382,  118,  389,  1006, 2090, 164,  1001, 1706, 1484, 1006, 2095, 391,  101,  1001, 1006, 2098, 399,  1006,
      2103, 310,  334,  399,  1006, 2107, 404,  1003, 1006, 2111, 412,  1694, 1006, 2120, 106,  419,  1001, 7,    1757,
      1747, 9,    1006, 2129, 106,  1010, 1588, 1011, 7,    1001, 9,    1006, 2136, 1010, 1420, 101,  1011, 1009, 1006,
      2147, 106,  164,  1010, 1001, 1700, 1011, 7,    1001, 9,    1006, 2149, 1006};
  Ss = 1943;
  static unsigned char Opc[121 /*0:120*/] = {
      0,    8,    9,    0x10, 0x11, 0x12, 0x13, 0x20, 0x21, 0x22, 0x23, 0x30, 0x31, 0x32, 0x33, 0x24, 0x34, 0,
      0x45, 0x46, 0x47, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x68, 0x69, 0x6A,
      0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0,    0x70, 0x60, 0x50, 0x4E,
      0x4F, 0x4C, 0x4B, 0x4A, 0x49, 0x48, 0x44, 0x43, 0x42, 0x41, 0x40, 0,    0x90, 0x98, 0x86, 0x87, 0,    0x91,
      0x92, 0x94, 0x95, 0x96, 0x97, 0x9C, 0x9E, 0x9D, 0x9F, 0x82, 0x84, 0x85, 0,    0x88, 0x89, 0x8A, 0x8B, 0x8C,
      0x8D, 0x8E, 0x8F, 0,    0xD0, 0xD1, 0xD2, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xDC, 0xDd, 0xDE, 0xDF, 0xD3, 0,
      0xF1, 0xF2, 0xF3, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0,    10,   4,    0x80};
  static int Nem[121 /*0:120*/] = {
      'CNOP', 'ISK', 'SSK', 'LP',  'LN',  'LT',   'LC',   'LPD',  'LND',  'LTD', 'LCD', 'LPE',  'LNE',  'LTE',
      'LCE',  'HD',  'HE',  0,     'BAL', 'BCT',  'BC',   'N',    'CL',   'O',   'X',   'L',    'C',    'A',
      'S',    'M',   'D',   'AL',  'SL',  'LD',   'CD',   'AD',   'SD',   'MD',  'DD',  'AW',   'SW',   'LE',
      'CE',   'AE',  'SE',  'ME',  'DE',  'AU',   'SU',   0,      'STE',  'STD', 'ST',  'CVD',  'CVB',  'MH',
      'SH',   'AH',  'CH',  'LH',  'EX',  'IC',   'STC',  'LA',   'STH',  0,     'STM', 'LM',   'BXH',  'BXLE',
      0,      'TM',  'MVI', 'NI',  'CLI', 'OI',   'XI',   'SDV',  'HDV',  'TDV', 'CKC', 'PC',   'WRD',  'RDD',
      0,      'SRL', 'SLL', 'SRA', 'SLA', 'SRDL', 'SLDL', 'SRDA', 'SLDA', 0,     'SSP', 'MVN',  'MVC',  'NC',
      'CLC',  'OC',  'XC',  'LSP', 'TR',  'TRT',  'ED',   'EDMK', 'MVZ',  0,     'MVO', 'PACK', 'UNPK', 'ZAP',
      'CP',   'AP',  'SP',  'MP',  'DP',  0,      'SVC',  'SPM',  'IDL'};
  static short Clods[89 /*0:88*/] = {
      4,      0x50CD, 0x001C, 0x58CD, 0x5C,   4,      0x50FB, 0x003C, 0x45FC, 0x4C,   6,      0x5820, 0x2000,
      0x0620, 0x8920, 24,     0x1602, 0,      8,      0x50B0, 0,      0x4AB0, 0x4002, 0x41BB, 0x7,    0x54BD,
      84,     4,      0x581D, 36,     0x9200, 0x1001, 11,     0x0510, 0x2826, 0x6E6D, 0x48,   0x6A6D, 0x28,
      0x2B26, 0x47B0, 0x1014, 0x6A2D, 0x30,   4,      0x9003, 0xB000, 0x41BB, 0x10,   5,      0x4100, 0,
      0x58EC, 186,    0x5FE,  5,      0x904E, 0xB010, 0x98CE, 0xD000, 0x5FE,  7,      0x904E, 0xB010, 0x98CF,
      0,      0x9859, 0xF014, 0x5FE,  5,      0x4100, 255,    0x8900, 0x18,   0x1610, 6,      0x4100, 4,
      0x59BD, 0x44,   0x4720, 0xC054, 6,      0x6000, 0xB040, 0x4100, 12,     0x5000, 0xB048};
  static unsigned char Tsname[51 /*0:50*/] = {[0 ... 7] = 0,
                                              1,
                                              [9 ... 13] = 0,
                                              1,
                                              26,
                                              1,
                                              1,
                                              26,
                                              [19 ... 20] = 0,
                                              2,
                                              1,
                                              [23 ... 30] = 26,
                                              3,
                                              9,
                                              17,
                                              [34 ... 35] = 26,
                                              1,
                                              0,
                                              1,
                                              26,
                                              [40 ... 41] = 0,
                                              5,
                                              [43 ... 50] = 0};
  Newlines(3);
  Spaces(30);
  Printstring(_imp_str_literal("E.R.C.C. IMP(SYS1) COMPILER "));
  Printstring(_imp_str_literal(" RELEASE 5 ALL-IMP VERSION"));
  Printstring(_imp_str_literal("   DATED 1/5/70"));
  Newlines(3);
  static unsigned char Bytes[4 /*0:3*/] = {4, 1, 2, 8};
  static unsigned char Precedence[12 /*1:12*/] = {0, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5};
  static unsigned char Typeflag[6 /*1:6*/] = {1, 2, 0b1001, 0b10001, 0b11010, 5};
  static int Mask1 = 0x0F0F0F0F;
  static int Mask2 = 0x0F0F0F0F;
  static short Maxlevels = 11;
  static int Coder = 12;
  static int Link = 15;
  static int Wspr = 11;
  static int Gla = 13;
  short Ccsize;
  short Arsize;
  short Dsize;
  short Nrouts;
  auto void Sizes(void);
  int Asl;
  int Nnames;
  int Cabuf;
  int Ppcurr;
  int Qpreal;
  int Oldline;
  int Line;
  int Length;
  int Lengthp;
  int N0;
  int Num;
  int Snum;
  int Rlevel;
  int Nmax;
  int Ownlink;
  int Constptr;
  int Plabel;
  int Level;
  int Ca;
  int Marker1;
  int Marker2;
  int Labset;
  int R13;
  int Rp13;
  int Sigfigs;
  unsigned char Aflag;
  unsigned char Fflag;
  unsigned char Checks;
  unsigned char Sbflag;
  unsigned char Faulty;
  unsigned char Mone;
  unsigned char Hit;
  unsigned char Qu;
  unsigned char Perm;
  unsigned char Mcswitch;
  unsigned char List;
  unsigned char Alllong;
  unsigned char Linenos;
  unsigned char Diags1;
  unsigned char Diags2;
  unsigned char Checksp;
  unsigned char Ctype;
  unsigned char Dcomp;
  unsigned char Compiler;
  unsigned char Cprmode;
  unsigned char Unass;
  unsigned char Printmap;
  double Cvalue;
  double Imax;
  int Mask;
  int Rbase;
  int Sflabel;
  int Next;
  int N;
  int Nr;
  int Item;
  int Strinst;
  int P;
  int Q;
  int R;
  int S;
  int T;
  int U;
  int V;
  int Nest;
  int Fname;
  int Xreflink;
  int Ldptr;
  short Neps;
  short Eplink;
  int Sstl;
  int Qmax;
  int Stmts;
  int Register[16 /*0:15*/];
  int St[1301 /*0:1300*/];
  int Set[Maxlevels + 1];
  int Codebase[Maxlevels + 1];
  int Freg[Maxlevels + 1];
  int Ral[Maxlevels + 1];
  short Cycle[Maxlevels + 1];
  short Jump[Maxlevels + 1];
  short Name[Maxlevels + 1];
  short Label[Maxlevels + 1];
  short Flag[Maxlevels + 1];
  short Sbr[Maxlevels + 1];
  short Wsp[Maxlevels + 1];
  short L[Maxlevels + 1];
  short M[Maxlevels + 1];
  short Lwsp[Maxlevels + 1];
  short Mdarr[Maxlevels + 1];
  short Rnext[Maxlevels + 1];
  short Nmdecs[Maxlevels + 1];
  short Strwsp[Maxlevels + 1];
  short Code[193 /*0:192*/];
  short Pagenos[51 /*0:50*/];
  int Uvarreg[4 /*5:8*/];
  Sizes();
  unsigned char Cc[Ccsize + 1];
  unsigned char Aslist[Asl + 1];
  unsigned char Lett[(Dsize + 20) + 1];
  short Ra[Nrouts + 1];
  short A[Arsize - -2 + 1];
  short Word[Nnames + 1];
  short Tags[Nnames + 1];
  auto void Cnop(int I, int J);
  auto void Pconst(int X);
  auto void Psi(int Opcode, int J, int Base, int Disp);
  auto void Pss(int Opcode, int N, int Base, int Disp, int P, int Q);
  auto void Prx(int Opcode, int R1, int R2, int Base, int Disp);
  auto void Paclod(int Ptr, int At, int Value);
  auto void Pclod(int Ptr);
  auto void Plant(int Value);
  auto void Prr(int Opcode, int R1, int R2);
  void Lput(int A, int B, int C, int D);
  auto void Plug(int J, int K);
  auto void Prhex(int Value, int Places);
  auto void Initialise(void);
  auto void Psym(int X);
  auto void Compare(void);
  auto void Pname(void);
  auto void Const(unsigned char Mode);
  auto void Constlist(void);
  auto void Texttext(void);
  auto void Fromar8(int Ptr, double *Value);
  auto void Fromar4(int Ptr, int *Value);
  auto void Toar8(int Ptr, double Value);
  auto void Toar4(int Ptr, int Value);
  auto void Css(int P);
  auto void Fault(unsigned char N);
  auto void Finalise(void);
  auto void Printname(int N);
  void Recode(int Start, int Finish, int Ca);
  auto void Readline(unsigned char N);
  if (_imp_on_event(9)) {
#if 1 /*  !0 */
    goto Inend;

#endif
  }
  Initialise();
  Lput(0, 1, 1, Addr(Lett[1]));
L8:
  Readline(0);
  Q = 1;
L5:
  R = 1;
  P = Ss;
  Oldline = Line;
  Compare();
  if (R > Arsize) Fault(102);
  if (!Hit) goto L6;
  Stmts++;
  Css(1);
  if (Dcomp != 0 && Ca > Cabuf) {
    Recode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
    Newline();
    Lput(1, Ca - Cabuf, Cabuf, Addr(Code[0]));
    Ppcurr = 0;
    Cabuf = Ca;
  }
  if (A[1] == 13) goto L7;
L9:
  if (Q >= Length) goto L8;
  goto L5;
L6:
  Fault(100);
  goto L9;
L7:;
  Finalise();
  if (Compiler == 0 && Faulty == 0) Setcom(24, 0);
  exit(0);
Inend:
  Fault(108);
Subschar:
  Line++;
  Fault(48);
  Spaces(5);
L15:
  Readsymbol(I);
  if (I == 10) goto L8;
  Printsymbol(I);
  goto L15;
  void Finalise(void) {
    if ((N0 & 1) != 1) N0++;
    Cnop(0, 8);
    St[0] = 0x20000;
    St[1] = 0x10100000;
    St[4] = -1;
    St[6] = 255;
    St[8] = Ownlink;
    St[12] = 0x41100000;
    St[14] = 0x41200000;
    St[18] = 0x4E000000;
    St[20] = -4;
    St[21] = -8;
    St[22] = Xreflink;
    Xreflink = 88;
    St[26] = 0x80000000;
    St[27] = 0x06492350;
    St[28] = 'ERMA';
    St[29] = 0x904EB010;
    St[30] = 0x5A10D01C;
    St[31] = 0x07F10700;
    St[32] = 0x80808080;
    St[33] = 0x80808080;
    St[38] = 0x80000000;
    St[39] = 0x06532349;
    St[40] = 'OCP ';
    K = Ca;
    if (Ca != Cabuf) Lput(1, Ca - Cabuf, Cabuf, Addr(Code[0]));
    Lput(2, (N0 << 2) + 4, 0, Addr(St[0]));
    if (N0 > 1023) Fault(99);
    I = 0xE2E2E2E2;
    Lput(4, 4, Sstl, Addr(I));
    if (Constptr & 1) Psym(0);
    if (Faulty) goto L129;
    Newline();
    Write(Stmts, 4);
    Printstring(_imp_str_literal(" STATEMENTS COMPILED SUCCESSFULLY"));
  L120:
    Printstring(_imp_str_literal("\nCODE OCCUPIES"));
    Write(K, 3);
    Printstring(_imp_str_literal(" BYTES      GLAP"));
    Write(N0 << 2, 3);
    Printstring(_imp_str_literal(" +"));
    Write(Constptr << 2, 1);
    Printstring(_imp_str_literal(" BYTES      DIAG TABLES"));
    Write(Sstl + 4, 4);
    Printstring(_imp_str_literal(" BYTES      TOTAL"));
    St[0] = Ca;
    St[1] = (N0 << 2) + 4;
    St[2] = ((Ldptr << 2) + 7) & (-8);
    St[3] = (Sstl + 11) & (-8);
    St[4] = Constptr << 2;
    St[5] = Ca + St[1] + St[2] + St[3] + St[4];
    Write(St[5], 5);
    Printstring(_imp_str_literal(" BYTES"));
    Newline();
    Newline();
    Lput(7, 24, 0, Addr(St[0]));
    return;
  L129:
    Printstring(_imp_str_literal("\nPROGRAM CONTAINS"));
    Write(Faulty, 2);
    Printstring(_imp_str_literal(" FAULTS"));
    goto L120;
  }
  void Readline(unsigned char N) {
    int Del;
    unsigned char Np;  //  ABOUT 30% CPU TIME OF COMPILATION IS SPENT IN THIS
                       //  ROUTINE AS WRITTEN. A HAND CODED VERSION USING I
                       //  ISO CARD NOT READ SYMBOL IS USED IN PRODUCTION VRSN
    Q = 1;
    Line++;
    Length = 0;
    Del = 0;
  L1:
    if (N != 0 || Nextsymbol() != 10) goto Start;
    Skipsymbol();
    goto L1;
  Start:
    if (!List) goto L2;
    Write(Line, 5);
    if (N) Printsymbol('\'');
    Spaces(4 * Level - N);
  L2:
    Readsymbol(I);
    if (List) Printsymbol(I);
    if (N) goto L4;
    if (I != '%') goto L3;
    Del = 128;
    goto L2;
  L3:
    if ('A' > I || I > 'Z') Del = 0;
    if (I == ' ') goto L2;
  L4:
    Length++;
    Cc[Length] = I | Del;
    if (I == '\'') N--;
    if (I != 10) goto L2;
    if (Cc[Length - 1] != 'C' + 128) return;
    Length--;
    if (!List) goto L2;
    Spaces(5);
    Printsymbol('C');
    Spaces(4 * Level);
    goto L2;
  }
  void Fault(unsigned char N) {
    int I;
    int J;
    int Qp;
    Printstring(_imp_str_literal("\n*"));
    Write(Line, 4);
    I = 3;
    if (!List) I = 3 * Level;
    Spaces(I);
    Faulty++;
    if (N == 100) goto L9;
    Printstring(_imp_str_literal("FAULT"));
    Write(N, 2);
    if (N < 100) goto L2;
    Printstring(_imp_str_literal(" DISASTER "));
    _imp_monitor();
    exit(0);
  L2:
    if (7 == N || N == 16) Printname(Fname);
    goto L99;
  L9:
    Printstring(_imp_str_literal("  SYNTAX   "));
    if (Line != Oldline) goto L11;
    Qp = Q;
    for (Q = Q; Q <= Length - 1; Q++) {
      if (Cc[Q] & 128)
        Printsymbol((Cc[Q] & 127) - 'A' + 'a');
      else
        Printsymbol(Cc[Q]);
      if (Cc[Q] == ';') goto L10;
    }
  L10:
    Q++;
    if (I + 20 + Q - Qp > 120) goto L99;
    Newline();
    Spaces(I + Qmax - Qp + 17);
    Printsymbol('!');
    Newline();
    goto L99;
  L11:
    Printstring(_imp_str_literal("\n         TEXT MODE FAILURE "));
    Write(Line - Oldline, 1);
    Printstring(_imp_str_literal(" LINES LOST "));
    Newline();
    Q = Qmax;
  L99:
    Newline();
  }
  void Compare(void) {
    int Ra;
    int Rp;
    int Rq;
    int Rr;
    int Rs;
    int Marker;
    static int Bip_sw;
    static void *Bip[20 /*1000:1019*/] = {
        &&Bip_1000, &&Bip_1001, &&Bip_1002, &&Bip_1003, &&Bip_1004, &&Bip_1005, &&Bip_1006,
        &&Bip_1007, &&Bip_1008, &&Bip_1009, &&Bip_1010, &&Bip_1011, &&Bip_1012, &&Bip_1013,
        &&Bip_1014, &&Bip_1015, &&Bip_1016, &&Bip_1017, &&Bip_1018, &&Bip_1019,
    };
    Rp = Symbol[P];
    Rq = Q;
    Rr = R;
    A[R] = 1;
    P++;
    Ra = Symbol[P];
    Rs = P;  //   ROUTINE REALLY STARTS HERE
  L1:
    R++;
  Bip_1000:
  L2:;
    Rs++;
    if (Rs == Ra) goto L8;
    Item = Symbol[Rs];
    if (Item >= 1300) goto L4;
    if (Item >= 1000) goto L6;
    for (J = 1; J <= Clett[Item]; J++) {
      if (Cc[Q] != Clett[J + Item]) goto L3;
      Q++;
    }
    goto L2;
  L4:;
    P = Item;
    Compare();
    if (Hit) goto L2;
  L3:
    if (Q > Qmax) Qmax = Q;
    Q = Rq;
    R = Rr;
    if (Ra == Rp) goto L7;
    Rs = Ra;
    A[R] = A[R] + 1;
    Ra = Symbol[Ra];
    goto L1;
  L8:;
    Hit = 1;
    return;
  L7:;
    Hit = 0;
    return;
  L6:;
    I = Cc[Q];
    goto *Bip[Bip_sw = (Item)-1000];
  Bip_1001:;
    Pname();
    if (Hit == 1) goto L1;
    goto L3;
  Bip_1002:;
    if ('A' > I || I > 'Z') goto L3;
    S = I;
    J = 1;
  L200:
    Q++;
    I = Cc[Q];
    if ('A' > I || I > 'Z') goto L201;
    S = S << 8 | I;
    J++;
    goto L200;
  L201:
    if (I != '_' || J > 4) goto L3;
    Q++;
    goto L2;
  Bip_1003:;
    Const(0);
    if (!Hit) goto L3;
    if (Ctype == 5) goto L1;
    if (Ctype == 2) goto L26;
    if (!((unsigned)S >> 12)) goto L22;
    A[R] = 1;
    Toar4(R + 1, S);
    R += 3;
    goto L2;
  L22:
    A[R] = 9;
    R++;
    A[R] = S;
    goto L1;
  L26:
    A[R] = 2;
    Toar8(R + 1, Cvalue);
    R += 5;
    goto L2;
  Bip_1005:;
    if ('0' > I || I > '9') goto L3;
    Const(2);
    A[R] = S;
    goto L1;
  Bip_1004:;
    Constlist();
    goto L1;
  Bip_1006:;
    if (I == 10) goto L2;
    if (I != ';') goto L3;
    Q++;
    goto L2;
  Bip_1007:
  L30:;
    if (10 == I || I == ';') goto L1;
    Q++;
    I = Cc[Q];
    goto L30;
  Bip_1008:;
    Texttext();
    if (!Hit) goto L3;
    goto L1;
  Bip_1009:;
    U = R;
    V = 1;
    R++;
    Pname();
    if (!Hit) goto L3;
  L90:
    if (Cc[Q] != ',') goto L91;
    Q++;
    R++;
    I = Cc[Q];
    Pname();
    if (!Hit) goto L92;
    V++;
    goto L90;
  L92:
    R--;
    Q--;
  L91:
    A[U] = V;
    goto L1;
  Bip_1010:;
    Marker = R;
    goto L1;
  Bip_1011:;
    A[Marker] = R - Marker;
    goto L2;
  Bip_1012:;
    if ((S & 255) == 'R') goto L124;
    for (I = 0; I <= 2; I++)
      if (S == Nem[I]) goto L120;
    goto L3;
  L120:
    A[R] = Opc[I] & 63;
    goto L1;
  L124:
    J = (unsigned)S >> 8;
    for (I = 2; I <= 48; I++)
      if (J == Nem[I]) goto L120;
    goto L3;
  Bip_1013:;
    for (I = 18; I <= 64; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  L130:
    A[R] = Opc[I];
    goto L1;
  Bip_1014:;
    for (I = 66; I <= 69; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  Bip_1015:;
    for (I = 71; I <= 83; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  Bip_1016:;
    for (I = 85; I <= 92; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  Bip_1017:;
    for (I = 94; I <= 106; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  Bip_1018:;
    for (I = 108; I <= 116; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  Bip_1019:;
    for (I = 118; I <= 120; I++)
      if (S == Nem[I]) goto L130;
    goto L3;
  }
  int Hash(int Addr) { return (Nnames & (19 * *Byteinteger(Addr) + 31 * *Byteinteger(Addr + 1))); }
  void Pname(void) {
    int Jj;
    int Kk;
    int Ll;
    Hit = 0;
    I = Cc[Q];
    if ('A' > I || I > 'Z') goto L3;
    if (Cc[Q + 1] == '\'' && (I == 'B' || I == 'X' || I == 'M')) goto L3;
    S = 2;
    T = 1;
    goto L10;
  L12:
    Q++;
    I = Cc[Q];
    if (('A' > I || I > 'Z') && ('0' > I || I > '9')) goto L101;
    T++;
    S++;
  L10:
    Lett[Next + T] = I;
    goto L12;
  L101:
    Lett[Next] = T;
    if (Next + S > Dsize) Fault(108);
    Jj = Hash(Addr(Lett[Next]));
    for (Num = Jj; Num <= Jj + Nnames; Num++) {
      Kk = Num & Nnames;
      Ll = Word[Kk];
      if (!Ll) goto L2;
      for (Jj = 1; Jj <= Lett[Ll]; Jj++)
        if (Lett[Next + Jj] != Lett[Ll + Jj]) goto Fail;
      goto L41;
    Fail:;
    }
    Fault(104);
  L2:
    Word[Kk] = Next;
    Next += S;
  L41:
    A[R] = Kk;
    Hit = 1;
  L3:;
  }
  void Const(unsigned char Mode) {  //  MODE=0 FOR NORMAL  MODE=2 FOR EXPONENT ETC
    int Z;
    double X;
    Cvalue = 0;
    I = Cc[Q];
    S = 0;
    if ('0' <= I && I <= '9') goto N;
    if (I == '.' && Mode == 0 && '0' <= Cc[Q + 1] && Cc[Q + 1] <= '9') goto Dot;
    if (I == '$' && Mode == 0) goto Pi;
    if (I == '\'') goto L101;
    if (Cc[Q + 1] != '\'') goto L150;
    Q += 2;
    if (I == 'X') goto L102;
    if (I == 'M') goto Mult;
    if (I == 'B') goto L104;
    Q -= 2;
    goto L150;
  Pi:;
    Cvalue = 3.14159 26535 89793 23846;
    Q++;
    goto L40;
  L101:
    S = R;
    A[R] = 5;
    R++;
    Texttext();
    if (!A[S + 1]) goto L24;
    if (A[S + 1] == 1) goto L27;
    Ctype = 5;
    return;
  L24:
    R = S;
    S = 0;
    goto L99;
  L27:
    R = S;
    S = A[S + 2];
    goto L99;
  L102:
    I = Cc[Q];
    Q++;
    if (I == '\'') goto L99;
    if ('0' <= I && I <= '9') goto L5;
    if ('A' > I || I > 'F') goto L150;
    S = S << 4 | (I - 'A' + 10);
    goto L102;
  L5:
    S = S << 4 | (I - '0');
    goto L102;
  Mult:
    T = 0;
  L28:
    I = Cc[Q];
    Q++;
    if (I == '\'') goto L22;
  L29:
    S = S << 8 | I;
    T++;
    if (T >= 5) goto L150;
    goto L28;
  L22:
    if (Cc[Q] != '\'') goto L99;
    Q++;
    goto L29;
  L104:
    T = Q;
  L32:
    I = Cc[Q];
    Q++;
    if ('1' != I && I != '0') goto L31;
    S = S << 1 | (I - '0');
    if (Q - T >= 33) goto L150;
    goto L32;
  L31:
    if (I == '\'') goto L99;
    goto L150;
  N:
    I = I & 15;
    Cvalue = 10 * Cvalue + I;
    Q++;
    I = Cc[Q];
    if ('0' <= I && I <= '9') goto N;
    if (Mode != 0 || I != '.') goto Alpha;
  Dot:
    Q++;
    X = 10;
  L45:
    I = Cc[Q];
    if ('0' > I || I > '9') goto Alpha;
    I = I & 15;
    Cvalue += I / X;
    X = 10 * X;
    Q++;
    goto L45;
  Alpha:  //  TEST FOR EXPONENT
    if (Mode != 0 || Cc[Q] != '@') goto Fix;
    Q++;
    X = Cvalue;
    Z = 1;
    if ('+' != Cc[Q] && Cc[Q] != '-') goto L39;
    if (Cc[Q] == '-') Z = -1;
    Q++;
  L39:
    Const(2);
    if (!Hit) goto L150;
    S = S * Z;
    if (S == -99)
      Cvalue = 0;
    else
      Cvalue = X * IEXP(10, S);
  Fix:  //  SEE IF IT IS Integer
    if (Cvalue > Imax) goto L40;
    if (Intpt(Cvalue) == Cvalue) goto L41;
  L40:
    Ctype = 2;
    Hit = 1;
    return;
  L41:
    S = Int(Cvalue);
  L99:
    Ctype = 1;
    Hit = 1;
    return;
  L150:
    Hit = 0;
  }
  void Constlist(void) {
    int Precp;
    int Nconst;
    int Rf;
    int J;
    int K;
    int Cpw;
    int Kk;
    int Sign;
    int Sp;
    int Rq;
    int Value;
    int Typep;
    int Acc;
    int Rp;
    int N;
    int Jj;
    double C;
    Value = 0;
    Nconst = 0;
    if (Constptr & 1) Psym(0);
    A[R + 1] = Constptr;
    Rp = R;
    R += 2;
    Acc = 0;
    N = 24;
    Typep = Typeflag[A[2]];
    Precp = (unsigned)Typep >> 3;
    Typep = Typep & 7;
    if (Typep == 5) Acc = A[4];
    if (Typep == 2 && Alllong == 1) Precp = 3;
    Cpw = 4 / Bytes[Precp];
    if (Typep == 5) Cpw = 4;
  L6:
    Rq = Q;
    I = Cc[Q];
    Sign = 1;
    if (I == '-') goto L7;
    if (I == '+') goto L8;
    goto L9;
  L7:
    Sign = -1;
    if (Cpw == 4) goto L99;
  L8:
    Q++;
    I = Cc[Q];
  L9:
    Const(0);
    Rf = 1;
    if (!Hit) goto L98;
    if (Cc[Q] != '(') goto L1;
    J = S;
    Q++;
    C = Cvalue;
    Const(2);
    if (Hit != 1 || S <= 0 || Cc[Q] != ')') goto L98;
    Q++;
    Cvalue = C;
    Rf = S;
    S = J;
  L1:
    if (Typep == 2) goto L21;
    if (Typep == 5) goto L51;
    if (Cpw == 4 && S > 255) goto L99;
    if (Cpw == 2 && (unsigned)abs(S) >> 16 != 0) goto L99;
    S = S * Sign;
    if (Cpw == 2) S = S & 0xFFFF;
    for (Kk = 1; Kk <= Rf; Kk++) {
      J = Nconst / Cpw;
      K = Nconst - Cpw * J;
      Sp = S << (32 * (Cpw - K - 1) / Cpw);
      Value = Sp | Value;
      Nconst++;
      if ((Cpw - 1) & Nconst) goto L5;
      Psym(Value);
      Value = 0;
    L5:;
    }
  L11:
    if (Cc[Q] != ',') goto L99;
    Q++;
    if (Cc[Q] != 10) goto L6;
    Readline(0);
    Q = 1;
    goto L6;
  L21:
    if (Ctype == 1) Cvalue = S;
    Cvalue = Sign * Cvalue;
    J = *Integer(Addr(Cvalue));
    K = *Integer(Addr(Cvalue) + 4);
    for (Kk = 1; Kk <= Rf; Kk++) {
      Nconst++;
      Psym(J);
      if (Precp == 3) Psym(K);
    }
    goto L11;
  L51:
    if (Ctype == 5) goto L52;
    if (Ctype != 1 || S > 127) goto L98;
    A[Rp + 3] = 1;
    A[Rp + 4] = S;
  L52:
    if (Sign != 1 || Acc < A[Rp + 3]) goto L98;
    for (Kk = 1; Kk <= Rf; Kk++) {
      for (Jj = 0; Jj <= Acc; Jj++) {
        S = A[Rp + Jj + 3] & 127;
        Sp = S << N;
        Value = Sp | Value;
        N -= 8;
        if (N >= 0) goto L55;
        Psym(Value);
        N = 24;
        Value = 0;
      L55:;
      }
      Nconst++;
    }
    R = Rp + 2;
    goto L11;
  L98:
    Q = Rq;
  L99:
    R = Rp;
    A[R] = Nconst;
    if ((Typep == 5 && N != 24) || (Typep != 5 && ((Cpw - 1) & Nconst) != 0)) Psym(Value);
  }
  void Texttext(void) {
    int S;
    int J;
    S = R;
    R++;
    if (I != '\'') goto L98;
    Q++;
  L1:
    I = Cc[Q];
    A[R] = I;
    R++;
    if (I == '\'') goto L31;
    if (I == 10) goto L32;
    Q++;
    if (R - S > 256) Fault(106);
    goto L1;
  L32:
    Readline(1);
    Q = 1;
    goto L1;
  L31:
    if (Cc[Q + 1] != '\'') goto L35;
    Q += 2;
    goto L1;
  L35:
    R -= 2;
    J = R - S;
    if (J & 1) goto L36;
    R++;
    A[R] = 0;
  L36:
    A[S] = J;
    Q++;
    Hit = 1;
    goto L99;
  L98:
    Hit = 0;
  L99:;
  }
  void Setuplist(void) {
    int J;
    int K;
    for (J = 0; J <= Asl - 16; J += 8) Setshortinteger(Addr(Aslist[J]) + 14, J);
    *Integer(Addr(Aslist[0])) = -1;
    *Integer(Addr(Aslist[4])) = 0xFFFF0000;
    Asl -= 8;
  }
  void Initialise(void) {
    static unsigned char Ilett[320 /*1:320*/] = {
        11,  'S', 'E', 'L', 'E', 'C', 'T', 'I', 'N', 'P', 'U', 'T', 12,  'S', 'E', 'L', 'E', 'C', 'T', 'O', 'U', 'T',
        'P', 'U', 'T', 7,   'N', 'E', 'W', 'L', 'I', 'N', 'E', 5,   'S', 'P', 'A', 'C', 'E', 10,  'S', 'K', 'I', 'P',
        'S', 'Y', 'M', 'B', 'O', 'L', 6,   'R', 'U', 'N', 'O', 'U', 'T', 8,   'N', 'E', 'W', 'L', 'I', 'N', 'E', 'S',
        6,   'S', 'P', 'A', 'C', 'E', 'S', 10,  'N', 'E', 'X', 'T', 'S', 'Y', 'M', 'B', 'O', 'L', 11,  'P', 'R', 'I',
        'N', 'T', 'S', 'Y', 'M', 'B', 'O', 'L', 10,  'R', 'E', 'A', 'D', 'S', 'Y', 'M', 'B', 'O', 'L', 4,   'R', 'E',
        'A', 'D', 5,   'W', 'R', 'I', 'T', 'E', 7,   'N', 'E', 'W', 'P', 'A', 'G', 'E', 4,   'A', 'D', 'D', 'R', 6,
        'A', 'R', 'C', 'S', 'I', 'N', 3,   'I', 'N', 'T', 5,   'I', 'N', 'T', 'P', 'T', 6,   'F', 'R', 'A', 'C', 'P',
        'T', 5,   'P', 'R', 'I', 'N', 'T', 7,   'P', 'R', 'I', 'N', 'T', 'F', 'L', 4,   'R', 'E', 'A', 'L', 7,   'I',
        'N', 'T', 'E', 'G', 'E', 'R', 3,   'M', 'O', 'D', 6,   'A', 'R', 'C', 'C', 'O', 'S', 4,   'S', 'Q', 'R', 'T',
        3,   'L', 'O', 'G', 3,   'S', 'I', 'N', 3,   'C', 'O', 'S', 3,   'T', 'A', 'N', 3,   'E', 'X', 'P', 9,   'M',
        'A', 'P', 'R', 'E', 'C', 'O', 'R', 'D', 11,  'B', 'Y', 'T', 'E', 'I', 'N', 'T', 'E', 'G', 'E', 'R', 12,  'S',
        'H', 'O', 'R', 'T', 'I', 'N', 'T', 'E', 'G', 'E', 'R', 6,   'R', 'A', 'D', 'I', 'U', 'S', 6,   'A', 'R', 'C',
        'T', 'A', 'N', 6,   'P', 'A', 'R', 'I', 'T', 'Y', 11,  'P', 'R', 'I', 'N', 'T', 'S', 'T', 'R', 'I', 'N', 'G',
        2,   'N', 'L', 8,   'L', 'O', 'N', 'G', 'R', 'E', 'A', 'L', 7,   'P', 'R', 'I', 'N', 'T', 'C', 'H', 6,   'R',
        'E', 'A', 'D', 'C', 'H', 6,   'S', 'T', 'R', 'I', 'N', 'G'};
    static short Iword[43 /*0:42*/] = {1,   13,  26,  34,  40,  51,  58,  67,  74,  85,  97,  108, 113, 119, 127,
                                       132, 139, 143, 149, 156, 162, 170, 175, 183, 187, 194, 199, 203, 207, 211,
                                       215, 219, 229, 241, 254, 261, 268, 275, 287, 290, 299, 307, 314};
    int I;
    Openinput(1, _imp_str_literal("TEST.imp"));
    Selectinput(1);
    Cabuf = 0;
    Ppcurr = 0;
    Qpreal = 0;
    Oldline = 0;
    Line = 0;
    Rlevel = 0;
    Nmax = 0;
    Constptr = 0;
    Level = 0;
    Ca = 0;
    Aflag = 0;
    Fflag = 0;
    Sbflag = 0;
    Faulty = 0;
    Perm = 0;
    Mcswitch = 0;
    Alllong = 0;
    Dcomp = 0;
    Compiler = 0;
    Cprmode = 0;
    Printmap = 0;
    Next = 1;
    Nr = 0;
    Ldptr = 0;
    Neps = 0;
    Eplink = 0;
    Rbase = 0;
    Strinst = 0;
    Imax = (unsigned)(-1) >> 1;
    Plabel = 24999;
    Sstl = 0;
    Stmts = 0;
    Snum = 0;
    Labset = 3 << 30;
    Lett[0] = 0;
    N0 = 41;
    N = 12;
    Checksp = 1;
    Checks = 1;
    Linenos = 1;
    Diags1 = 1;
    Qu = 1;
    Mone = 1;
    List = 1;
    Sflabel = 20999;
    Unass = 1;
    Ownlink = 0;
    Xreflink = 136;
    I = Com(24);
    if (I & 2) List = 0;
    if (I & 4) Linenos = 0;
    if (I & 16) Unass = 0;
    if (I & 32) Checks = 0;
    if (I & 0x8000) Printmap = 1;
    if (I & 64) Diags1 = 0;
    for (I = 0; I <= Maxlevels; I++) {
      Set[I] = 0;
      Codebase[I] = 0;
      Freg[I] = 0;
      Ral[I] = 0;
      Lwsp[I] = 0;
      Mdarr[I] = 0;
      Rnext[I] = 0;
      Strwsp[I] = 0;
      Cycle[I] = 0;
      Jump[I] = 0;
      Name[I] = 0;
      Label[I] = 0;
      Flag[I] = 0;
      Sbr[I] = 0;
      Wsp[I] = 0;
    }
    for (I = 0; I <= 50; I++) {
      St[I] = 0;
      Pagenos[I] = 0;
      if (I < 16) Register[I] = 0;
      if (5 <= I && I <= 8) Uvarreg[I] = 0;
    }
    Pagenos[1] = 10;
    for (I = 0; I <= Nnames; I++) {
      Word[I] = 0;
      Tags[I] = 0;
    }
    Setuplist();
    Pclod(0);
    Pclod(5);
    A[1] = 28;
    for (I = 0; I <= 42; I++) {
      J = Iword[I];
      for (K = 1; K <= Ilett[J]; K++) {
        Cc[K] = Ilett[J + K];
      }
      Cc[K + 1] = ';';
      R = 2;
      Q = 1;
      Pname();
      Css(1);
    }
    A[1] = 12;
    Css(1);
  }
  //  THE NEXT 4 ROUTINES CAN BE MACROISED USING MVC
  void Toar4(int Ptr, int Value) {
    int Ad;
    Ad = Addr(Value);
    A[Ptr] = Shortinteger;
    A[Ptr + 1] = Shortinteger;
  }
  void Toar8(int Ptr, double Value) {
    int Ad;
    Ad = Addr(Value);
    A[Ptr] = Shortinteger;
    A[Ptr + 1] = Shortinteger;
    A[Ptr + 2] = Shortinteger;
    A[Ptr + 3] = Shortinteger;
  }
  void Fromar4(int Ptr, int *Value) {
    int Ad;
    Ad = Addr(*Value);
    Setshortinteger(Ad, A[Ptr]);
    Setshortinteger(Ad + 2, A[Ptr + 1]);
  }
  void Fromar8(int Ptr, double *Value) {
    int Ad;
    Ad = Addr(*Value);
    Setshortinteger(Ad, A[Ptr]);
    Setshortinteger(Ad + 2, A[Ptr + 1]);
    Setshortinteger(Ad + 4, A[Ptr + 2]);
    Setshortinteger(Ad + 6, A[Ptr + 3]);
  }
  void Printname(int N) {
    int J;
    int V;
    if (N >= 0) goto L4;
    N = -N;
    if (16384 > N || N > 16384 + Nnames) goto L5;
    N -= 16384;
    goto L4;
  L5:
    Write(N, 1);
    goto L3;
  L4:
    Space();
    V = Word[N];
    for (J = 1; J <= Lett[V]; J++) Printsymbol(Lett[V + J]);
  L3:;
  }
  void Pclod(int Ptr) {
    int I;
    for (I = Ptr + 1; I <= Ptr + Clods[Ptr]; I++) Plant(Clods[I]);
  }
  void Paclod(int Ptr, int At, int Value) {
    int I;
    int J;
    int K;
    J = Clods[Ptr];
    At += Ptr;
    for (I = Ptr + 1; I <= Ptr + J; I++) {
      K = Clods[I];
      if (I == At) K = K | Value;
      Plant(K);
    }
  }
  void Plant(int Value) {
    Code[Ppcurr] = Value;
    Ppcurr++;
    Ca += 2;
    if (Ppcurr != 192) return;
    Lput(1, 384, Cabuf, Addr(Code[0]));
    Ppcurr = 0;
    Cabuf = Ca;
  }
  void Prr(int Opcode, int R1, int R2) { Plant(Opcode << 8 | R1 << 4 | R2); }
  void Prx(int Opcode, int R1, int R2, int Base, int Disp) {
    Plant(Opcode << 8 | R1 << 4 | R2);
    Plant(Base << 12 | Disp);
  }
  void Psi(int Opcode, int J, int Base, int Disp) {
    Plant(Opcode << 8 | J);
    Plant(Base << 12 | Disp);
  }
  void Pss(int Opcode, int N, int Base, int Disp, int P, int Q) {
    Plant(Opcode << 8 | (N - 1));
    Plant(Base << 12 | Disp);
    Plant(P << 12 | Q);
  }
  void Pconst(int X) {
    Plant((unsigned)X >> 16);
    Plant(X & 0xFFFF);
  }
  void Cnop(int I, int J) {
    J--;
  L1:
    if ((Ca & J) == I) goto L9;
    Plant(0x0700);
    goto L1;
  L9:;
  }
  void Psym(int X) {
    Lput(5, 4, Constptr << 2, Addr(X));
    Constptr++;
  }
  void Plug(int J, int K) {
    if (J >= Cabuf) goto Inbuf;
    Lput(1, 2, J, Addr(K) + 2);
    goto L99;
  Inbuf:
    Code[(unsigned)(J - Cabuf) >> 1] = K;
  L99:;
  }
  void Prhex(int Value, int Places) {
    static unsigned char Hex[16 /*0:15*/] = {'0', '1', '2', '3', '4', '5', '6', '7',
                                             '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    int I;
    for (I = (Places << 2) - 4; I >= 0; I -= 4) Printsymbol(Hex[(unsigned)Value >> I & 15]);
  }
  void Sizes(void) {
    auto void Sum(int I);
    int I;
    int J;
    int Free;
    int Total;
    Free = 20000;
    Sum(5);
#if 0 /* Debug==1 */
Printstring(_imp_str_literal("NNAMES="));Write(Nnames,0);Printstring(_imp_str_literal("  CCSIZE="));Write(Ccsize,0);Printstring(_imp_str_literal("  NROUTS="));Write(Nrouts,0);Printstring(_imp_str_literal("  ASL="));Write(Asl,0);Printstring(_imp_str_literal("  ARSIZE="));Write(Arsize,0);Printstring(_imp_str_literal("  DSIZE="));Write(Dsize,0);Printstring(_imp_str_literal("  TOTAL="));Write(Total,0);Newlines(2);
#endif
    return;
  L1:
    if (J) goto L2;
    Printstring(_imp_str_literal("NOT ENOUGH CORE ALLOCATED FOR IMP"));
    _imp_monitor();
    exit(0);
  L2:
    Sum(J - 1);
    return;
    void Sum(int I) {
      Nnames = 128 * IEXP(2, I) - 1;
      Ccsize = 200 + 40 * I;
      Nrouts = Nnames / 2;
      Asl = 24 * Nnames;
      if (Asl > 32760) Asl = 32760;
      Arsize = 300 + 50 * I;
      Dsize = 6 * Nnames;
      Total = Ccsize + Asl + 2 * (Nrouts + Arsize + Dsize);
    }
  }
  void Css(int P) {
    auto void Redefineep(int Typep, int Params);
    auto void Ciocp(int N);
    auto void Defineep(int Mode, int Name, int Addr);
    auto void Loaddata(void);
    auto void Plocaljump(int Mask, int Lab);
    auto void Filllocaljumps(void);
    auto void Clearlist(short *Ophead);
    auto void Storestring(int Z, int From, int To, int Bml, int Dml);
    auto void Cend(int Kkk);
    auto void Cbpair(int *Lb, int *Ub);
    auto void Undcrf(short *Ophead);
    auto void Ccond(int Iu, int Reg, int Addr);
    auto void Filljumps(int Level);
    auto void Setline(void);
    auto void Cui(unsigned char Code);
    auto void Set80(int Where, int N);
    auto void Cvdecln(void);
    auto void Csexp(int Reg, unsigned char Mode);
    auto void Cstrexp(int Reg);
    auto void Checkrf(void);
    auto void Assign(int P1, int P2);
    auto int Copyrecordtag(void);
    auto int Countaps(void);
    auto int Displacement(int Link);
    auto void Loadad(int Reg, int Base, int X, int Disp);
    auto void Skipapp(void);
    auto void Cquery(int Reg);
    auto void Crformat(void);
    auto void Cadcln(unsigned char Mode);
    auto void Cqn(int P);
    auto void Clt(void);
    auto void Mover(int R, int N);
    auto int Getarrwsp(void);
    auto int Getdblewrd(void);
    auto void Crcall(int Clink);
    auto void Cname(int Z, int Reg);
    auto void Crname(int Z, int Mode, int Clink, int Bs, int Dp);
    auto void Caname(int Z, int Bs, int Dp, int Link, int Bsrf, int Dprf);
    auto void Cename(int Z, int Mode, int Bs, int Dp);
    auto void Insertafter(short *Stad, int S1, int S2);
    auto void Fromlist(int Cell, int *S1, int *S2);
    auto void Pop(short *Cell, int *S1, int *S2);
    auto void Push(short *Cell, int S1, int S2);
    auto int Find(int Lab, int List);
    auto void Mlink(int *Cell);
    auto void Replace2(int Cell, int S2);
    auto void Replace1(int Cell, int S1);
    auto void Replaceboth(int Cell, int S1, int S2);
    auto void From2(int Cell, int *S2);
    auto void From1(int Cell, int *S1);
    auto void Cres(int Mode, int Lab);
    auto int Newcell(void);
    auto void Copytag(int Kk);
    auto void Csname(int Z, int Reg);
    auto void Replacetag(int Kk);
    auto int Park(int Reg);
    auto int Parkf(int Reg, int Prec);
    auto int Claimablereg(void);
    auto int Findpp(void);
    auto int Getstrwsp(void);
    auto void Setex(void);
    auto void Gxref(int Name, int Hash);
    auto void Unpark(int Opcode, int Reg, int Q);
    auto void Storetag(int Kk, int Slink);
    auto int Pageno(int N);
    auto void Testnst(void);
    auto void Cuci(void);
    auto void Skipexp(void);
    auto void Unpack(void);
    auto int Sortconst(int P, int Long, int Type);
    auto void Pack(int *Ptype);
    auto void Crspec(unsigned char M);
    auto void Dump(int Code, int Reg, int Dis, int X, int Level);
    auto void Rhead(int Kk);
    auto void Testass(int Reg);
    auto void Pj(int Mask, int Stad);
    auto void Compileformalparameter(void);
    auto void Ppj(unsigned char N);
    auto void Plab(int M);
    auto void Checkcapacity(int Reg, int Dis, int X, int Level);
    auto int Tsexp(int *Code);
    static int Sw_sw;
    static void *Sw[45 /*1:45*/] = {
        &&Sw_1,       &&Sw_2,       &&Sw_3,       &&Sw_4,       &&Sw_5,       &&Sw_6,       &&Sw_7,       &&Sw_8,
        &&Sw_9,       &&Sw_10,      &&Sw_11,      &&Sw_12,      &&Sw_13,      &&Sw_14,      &&Sw_15,      &&Sw_16,
        &&Sw_17,      &&Sw_18,      &&Sw_19,      &&Sw_20,      &&Sw_21,      &&Sw_22,      &&Sw_23,      &&Sw_24,
        &&Sw_25,      &&Sw_26,      &&Sw_27,      &&Sw_28,      &&Sw_29,      &&Sw_30,      &&Sw_31,      &&Sw_32,
        &&Sw_33,      &&Sw_34,      &&Sw_35,      &&Sw_36,      &&Sw_37,      &&Sw_default, &&Sw_default, &&Sw_default,
        &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_default,
    };
    int Inc;
    int Incp;
    int Bxle;
    int Acc;
    short Ophead;
    int Jj;
    int Jjj;
    int Kk;
    int Kkk;
    int Q;
    int Qq;
    int Extrn;
    int Base;
    int Disp;
    int Value;
    int Index;
    int Localbase;
    int Localaddr;
    short Localjump;
    short Locallabel;
    unsigned char Rout;
    unsigned char Nam;
    unsigned char Arr;
    unsigned char Prec;
    unsigned char Type;
    unsigned char Precp;
    int Ptype;
    int I;
    int J;
    int K;
    int Oldi;
    int Inreg;
    int Ptypep;
    int Save13;
    int Chnge13;
    Localjump = 0;
    Locallabel = 0;
    Localbase = 0;
    Oldi = 0;
    goto *Sw[Sw_sw = (A[P]) - 1];
  Sw_1:
    Marker2 = P + 1 + A[P + 1];
    Setline();
    P += 2;
    if (A[Marker2] == 2) goto L101;
    Mask = 15;
    Cui(0);
    goto L1;
  L101:
    Q = P;
    if (A[P] == 9) Fault(54);
    Save13 = R13;
    Chnge13 = 0;
    if (A[P] == 3) goto L103;
    Plabel -= 2;
    Jjj = Plabel + 1;
    Kkk = Plabel;
    P = Marker2 + 2;
    Ccond(A[P - 1] - 1, Jjj, Kkk);
    Plocaljump(Mask, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Push(Locallabel, Ca, Jjj);
    P = Q;
    Cui(1);
  L104:
    Push(Locallabel, Ca, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
  L102:
    if (Localbase != 10 && Localbase != 0) Register[Localbase] = 0;
    Filllocaljumps();
    goto L1;
  L103:
    Plabel--;
    Jjj = Plabel;
    Nmdecs[Level] = 1;
    Kkk = A[P + 2] + ((A[P + 1] - 1) << 14);
    P = Marker2 + 2;
    Ccond(2 - A[P - 1], Jjj, Kkk);
    Plocaljump(Mask, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Push(Locallabel, Ca, Jjj);
    goto L102;
  Sw_2:
    Setline();
    P++;
    Bxle = 0;
    Cname(3, 4);
    Inc = N;
    N += 12;
    if (Type != 1 || Prec != 0) Fault(25);
    Q = P;
    Skipexp();
    Register[4] = 1;
    Jj = P;
    if (3900 > Ca - Codebase[Level] && 1 <= Tsexp(Jjj) && Tsexp(Jjj) <= 2) Bxle = 1;
    P = Jj;
    Csexp(2, 1);
    Jjj = P;
    Kkk = Tsexp(Qq);
    P = Jjj;
    if (!Kkk) Dump(1, 2, Inc, 0, Rbase);
    Csexp(3, 1);
    if (!Kkk)
      Prx(0x90, 3, 4, Rbase, Inc + 4);
    else
      Prx(0x90, 2, 4, Rbase, Inc);
    P = Q;
    Csexp(1, 1);
    if (!Checksp) goto L202;
    Dump(0, 2, Inc, 0, Rbase);
    Ppj(17);
  L202:
    Plab(-1);
    Register[4] = 0;
    Dump(1, 1, 0, 0, 4);
    Push(Cycle[Level], K, Inc + 4096 * Bxle);
    goto L1;
  Sw_3:;
    Setline();
    Pop(Cycle[Level], J, K);
    if (J != -1) goto L302;
    Fault(1);
    goto L1;
  L302:
    Bxle = (unsigned)K >> 12;
    K = K & 4095;
    Prx(0x98, 2, 4, Rbase, K);
    Dump(2, 1, 0, 0, 4);
    if (Bxle == 1) goto L301;
    Plant(0x1A12);
    Pconst(0x59304000);
    K = J;
    Pj(7, K);
    goto L1;
  L301:
    I = Find(J, Label[Level]);
    Prx(0x87, 1, 2, 10, I - Codebase[Level]);
    goto L1;
  Sw_4:;
    K = A[P + 2] + ((A[P + 1] - 1) << 14);
    if (Find(K, Label[Level]) == -1) goto L402;
    Fault(2);
    goto L1;
  L402:
    Plab(K);
    goto L1;
  Sw_5:
    Q = P + 1;
    Marker2 = P + 3 + A[P + 2];
    Setline();
    P = Marker2;
    Save13 = R13;
    Chnge13 = 0;
    if (A[P] == 3) goto L510;
    if (A[P] == 9) goto L520;
    Plabel -= 2;
    Jjj = Plabel + 1;
    Kkk = Plabel;
    P = Q + 2;
    Ccond(A[Q] - 1, Jjj, Kkk);
    Plocaljump(Mask, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Push(Locallabel, Ca, Jjj);
    P = Marker2;
    Cui(1);
    if (A[P] != 1) goto L104;
    P++;
    if (A[P] == 9) goto L107;
    Plabel--;
    Jjj = Plabel;
    Plocaljump(15, Jjj);
    Push(Locallabel, Ca, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Mask = 15;
    Cui(2);
    Kkk = Jjj;
    goto L104;
  L107:
    Pj(15, Sflabel - 1);
    Cui(2);
    goto L104;
  L510:
    Plabel--;
    Jjj = Plabel;
    Nmdecs[Level] = 1;
    Kkk = A[P + 2] + ((A[P + 1] - 1) << 14);
    P = Q + 2;
    Ccond(2 - A[Q], Jjj, Kkk);
    Plocaljump(Mask, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Push(Locallabel, Ca, Jjj);
    P = Marker2 + 3;
    if (A[P] != 1) goto L102;
    P++;
    Mask = 15;
    Cui(0);
    goto L102;
  L520:
    Plabel--;
    Jjj = Plabel;
    Kkk = Sflabel - 1;
    P = Q + 2;
    Ccond(A[Q] - 1, Jjj, Kkk);
    Plocaljump(Mask, Kkk);
    if (R13 != Save13 || Chnge13 != 0) R13 = 0;
    Push(Locallabel, Ca, Jjj);
    P = Marker2;
    Cui(1);
    P++;
    if (A[P] == 1) Fault(53);
    goto L102;
  Sw_6:
  L1:;
    return;
  Sw_7:;
    if (Level < 2) Fault(57);
    if (Nmdecs[Level]) Fault(40);
    P++;
    Clt();
    Rout = 0;
    if (Type == 5 && Acc == 0) Fault(70);
    if (A[P] == 1) goto Scalar;
    if (A[P] == 3) goto Vector;
    Arr = 1;
    Nam = (2 - A[P + 1]) << 1;
    Pack(Ptype);
    P += 2;
    Setline();
    if (Nam) Acc = 4;
    Cadcln(0);
    goto L1;
  Vector:
    Arr = 2;
    Nam = 0;
    Pack(Ptype);
    P++;
    Setline();
    Cvdecln();
    goto L1;
  Scalar:
    J = 0;
    Rout = 0;
    Cqn(P + 1);
    P += 2;
    Inc = N;
    Qq = Acc;
    if (Type == 5) Acc = 4;
    Jj = 0;
    if (Acc != 8 || (N & 7) == 0) goto L701;
    Push(Wsp[Level], 0, N);
    N += 4;
  L701:
    if (Type == 5) Setline();
    Pack(Ptype);
    for (Kk = 1; Kk <= A[P]; Kk++) {
      K = A[P + Kk];
      Testnst();
      Storetag(K, N);
      if (Type != 5) goto L705;
      Jj += Qq;
      if (Unass == 1) Pss(0xD2, 2, Wspr, 0, Gla, 128);
      Prx(0x50, Wspr, Rbase, 0, N);
      Psi(0x92, Qq - 1, Rbase, N);
      if (Kk == A[P]) Qq = Qq + ((Jj + 7) & (-8)) - Jj;
      Prx(0x41, Wspr, Wspr, 0, Qq);
    L705:
      N += Acc;
    }
    N += 3;
    N = N & (-4);
    if (Unass == 1 && Type != 5) Set80(Inc, N - Inc);
    goto L1;
  Sw_8:;
    Cend(Flag[Level]);
    goto L1;
  Sw_9:
    P++;
    Marker1 = A[P] + P;
  L900:
    Q = P;
    Kkk = A[Marker1 + 1];
    Extrn = A[P + 1];
    if (A[Marker1] == 2) goto L902;
    P++;
    Crspec(0);
    if (Extrn == 3) goto L1;
    N0--;
    Kk = 'S' * (2 - Extrn);
    Gxref(Kkk, Kk);
    Jj = Tags[Kkk];
    From1(Jj, Q);
    Replace1(Jj, Q & (-2));
    goto L1;
  L902:
    Filljumps(Level);
    Kk = Kkk;
    Copytag(Kkk);
    if (Oldi != Level) goto L939;
    if (Extrn != 3) {
      if (!Cprmode) Cprmode = 2;
      if (Cprmode != 2 || Level != 1) Fault(55);
      Defineep(Extrn, Kkk, Ca);
      Pclod(0);
    }
    if (A[P + 2] == 1) goto L908;
    Rout = 1;
    P += 3;
    Clt();
    Arr = 0;
    Nam = (A[P] - 1) << 1;
    Pack(Kkk);
    goto L909;
  L908:
    Kkk = 10000;
  L909:
    if (J == 15 && Ptype == Kkk) goto L940;
    Fname = Kk;
    if ((Ptype & 7) != 7) Fault(7);
  L939:
    P = Q + 1;
    Crspec(0);
    P = Q;
    goto L900;
  L940:
    J = 0;
    Replacetag(Kk);
    Jj = K;
    Plabel--;
    if (Compiler != 1 && (Cprmode != 2 || Level != 1)) Pj(15, Plabel);
    Ral[Level] = Nmax << 16 | Sbflag << 15 | N;
    Rhead(Kk);
    if (Extrn != 3) Ppj(40);
    Flag[Level] = Ptype;
    P = Marker1 + 1;
    if (A[P + 1] == 2) goto L942;
  L943:
    P += 2;
    Compileformalparameter();
    for (Bxle = 1; Bxle <= A[P]; Bxle++) {
      Mlink(Jj);
      if (Jj) goto L945;
      Fault(8);
      goto L946;
    L945:
      Fromlist(Jj, J, Jjj);
      if (J == Ptype && (Ptype != 5 || Jjj == Acc)) goto L946;
      Fault(9);
      Printname(A[P + Bxle]);
    L946:
      K = A[P + Bxle];
      Testnst();
      Ophead = 0;
      Unpack();
      if (Rout == 1) goto L947;
      if (Ptype == 5) goto L9040;
      J = Jjj;
      if (Type == 3) goto L948;
      R = N;
      if (Arr == 1) goto L950;
      if (Prec == 3 && Nam == 0) goto L949;
      N = N + 4 - Acc;
      R = N;
    L950:
      Storetag(K, N);
      N = R + Acc;
      goto L999;
    L947:
      Push(Ophead, N, 1000);
      J = 13;
    L951:
      Kk = Ophead;
      R = N;
      N = Kk;
      goto L950;
    L9040:
      Prx(0x41, 1, 0, Rbase, N + 4);
      Prx(0x50, 1, 0, Rbase, N);
      Psi(0x92, Jjj - 1, Rbase, N);
      Storetag(K, N);
      N += (Acc + 7) & (-4);
      goto L999;
    L948:
      Push(Ophead, 0, N);
      J = 0;
      goto L951;
    L949:
      R = N;
      if (!(N & 7)) goto L950;
      Push(Wsp[Level], 0, N);
      N += 4;
      R = N;
      goto L950;
    L999:;
    }
    P = P + 1 + Bxle;
    if (A[P] == 1) goto L943;
  L942:
    Mlink(Jj);
    if (Jj) Fault(10);
    goto L1202;
  Sw_10:;
    goto L1;
  Sw_11:;
    Alllong = A[P + 1] & 1;
    goto L1;
  Sw_12:;
    Filljumps(Level);
    Ral[Level] = Sbflag << 15 | N;
    Ptype = 0;
    Rhead(-1);
    Flag[Level] = 0;
    if (Level == 1 && 1 == Rlevel) goto L1;
    if (Level != 2) goto L1202;
    if (!Cprmode) Cprmode = 1;
    Defineep(0, 0, 0);
    if (Cprmode != 1) Fault(55);
  L1202:
    Plant(0x05A0);
    Codebase[Level] = Ca;
    goto L1;
  Sw_13:;
    if (Level != 2) Fault(15);
    if (Cprmode != 1) Fault(56);
    Perm = 0;
    Cend(1);
    Loaddata();
    goto L1;
  Sw_14 :

  {
    R13 = 0;
    Mone = 1;
    Copytag(A[P + 1]);
    if (Oldi == Level && Type == 6) goto L1401;
    Fault(4);
    goto L1;
  L1401:
    Fromlist(K, Acc, Kkk);
    Mlink(K);
    Fromlist(K, Qq, Kk);
    if ((A[P + 3] & 7) != 1) goto L1411;
    if (A[P + 3] == 9)
      Jj = A[P + 4];
    else {
      Fromar4(P + 4, Jj);
      P++;
    }
    if (A[P + 2] == 2) Jj = -Jj;
    if (Kkk <= Jj && Jj <= Kk) goto L1402;
  L1411:
    Fault(5);
    goto L1;
  L1402:
    Q = Jj - Kkk;
  L1404:
    if (31 >= Q) goto L1403;
    Mlink(K);
    Q -= 32;
    Fromlist(K, Qq, Jjj);
    goto L1404;
  L1403:
    Jjj = 1 << Q;
    if (Jjj & Qq) Fault(6);
    Replace1(K, Qq | Jjj);
    Q = Ca - Codebase[Level];
    if (Prec) goto L1407;
    Qq = Acc + 8 + ((Jj - Kkk) << 2);
    if ((unsigned)Q >> 16) Plug(Qq, (unsigned)Q >> 16);
  L1406:
    Plug(Qq + 2, Q & 0xFFFF);
    goto L1;
  L1407:
    Qq = Acc + 6 + ((Jj - Kkk) << 1);
    if (Q > 0x7FFF) Fault(99);
    goto L1406;
  L1:;
  }
    goto L1;
  Sw_15 :

  {
    int Bp;
    int Qqq;
    Q = P;
    Cnop(0, 4);
    Pj(15, Plabel - 1);
    if (Level < 2) Fault(56);
  L1528:
    P = Q + A[Q + 1] + 2;
    Cbpair(Kkk, Kk);
    if (abs(Kkk) >= 0x7FFF || 0x7FFF <= abs(Kk)) goto L1501;
    if (Kkk <= Kk) goto L1535;
    Fault(27);
    Kk = Kkk;
  L1535:
    for (Qq = 1; Qq <= A[Q + 1]; Qq++) {
      K = A[Q + Qq + 1];
      Testnst();
      Prec = 0;
      if (Sbflag == 1 || Compiler == 1) Prec = 2;
      Type = 6;
      Rout = 0;
      Nam = 0;
      Arr = 1;
      Pack(Ptype);
      Ophead = Newcell();
      Jj = Ophead;
      J = 0;
      Storetag(K, Ophead);
      R = Kkk;
      Insertafter(Ophead, 0, Kk);
    L1503:
      if (Kk - R < 32) goto L1504;
      Insertafter(Ophead, 0, 0);
      R += 32;
      goto L1503;
    L1504:
      Replaceboth(Jj, Ca, Kkk);
      Pconst(Kkk & 0xFFFFFF | Prec << 24);
      Pconst(Kk);
      Jjj = Kk - Kkk;
      if (Prec == 2) Jjj = (Jjj + 1) / 2;
      for (I = 0; I <= Jjj; I++) Pconst(0);
    }
    Q = P;
    if (A[Q] != 2) goto L1528;
    Plab(-1);
    goto L1;
  L1501:
    Fault(18);
    Kk = 0;
    Kkk = 0;
    goto L1535;
  L1:;
  }
    goto L1;
  Sw_16:
    Qu = ~A[P + 1] & 1;
    P += 2;
    goto L1;
  Sw_17:;
    Kk = Claimablereg();
    if (!Kk) goto L1999;
    Register[Kk] = -Level;
    Uvarreg[Kk] = Level;
    Ptype = 8;
    J = 0;
    K = A[P + 1];
    Testnst();
    Storetag(K, Kk);
    goto L1;
  Sw_18:;
    {
      int Wsp1;
      int Length;
      int Bp;
      int Pp;
      int Sign;
      int *Var;
      if (Nmdecs[Level]) Fault(40);
      P++;
      Clt();
      if (Type == 5 && Acc == 0) Fault(70);
      Nam = 0;
      Rout = 0;
      Arr = A[P] - 1;
      Pack(Ptype);
      Pp = P + 1;
      P += 2;
      if (Arr) goto Nonscalar;
      if (A[P] != 2) goto L1801;
      A[P + 1] = 4;
      A[P + 2] = 9;
      A[P + 3] = 0;
    L1801:
      Sign = A[P + 1];
      if (Type == 5) goto L1820;
      Jj = Sortconst(P + 2, Prec & 1, Type);
      if (Type == 2) goto L1810;
      Var = &St[N0 - 1];
      if ((Prec == 1 && *Var > 255) || (Prec == 2 && (unsigned)abs(*Var) >> 16 != 0)) Fault(44);
      if ((A[P + 2] & 7) == 2) Fault(44);
      if (Sign == 2) *Var = -*Var;
      if (Sign == 3) *Var = ~*Var;
    L1803:
      K = A[Pp];
      Testnst();
      if (Prec != 3) Jj = Jj + 4 - Bytes[Prec];
      Push(Tags[K], Ptype << 16 | Level << 8 | Gla << 4, Jj);
      Push(Name[Level], 0, K);
      goto L99;
    L1810:
      if (Sign == 3) Fault(44);
      if (Sign != 2) goto L1803;
      St[(unsigned)Jj >> 2] = St[(unsigned)Jj >> 2] | 0x80000000;
      goto L1803;
    L1820:;
      if (A[P + 2] != 9 || A[P + 3] >= 127) goto L1822;
      A[P + 2] = 5;
      A[P + 4] = A[P + 3];
      A[P + 3] = 1;
    L1822:
      if (Sign != 4 || A[P + 2] != 5 || A[P + 3] >= Acc) Fault(44);
      Qq = Constptr << 2;
      for (Jj = 0; Jj <= (Acc - 1) & (-4); Jj += 4) {
        Wsp1 = A[P + Jj + 3] << 8 | A[P + Jj + 4] & 255;
        Wsp1 = Wsp1 << 8 | A[P + Jj + 5] & 255;
        Wsp1 = Wsp1 << 8 | A[P + Jj + 6] & 255;
        Psym(Wsp1);
      }
      Prx(0x58, 2, 0, Gla, 8);
      Loadad(1, 2, Gla, Qq);
      Prx(0x50, 1, 0, Rbase, N);
      Psi(0x92, Acc - 1, Rbase, N);
      K = A[Pp];
      Testnst();
      J = 0;
      Storetag(K, N);
      N += 4;
      goto L99;
    Nonscalar:
      Cbpair(Kk, Kkk);
      if (Type == 5)
        Bp = Acc;
      else
        Bp = Bytes[Prec];
      Length = Kkk - Kk + 1;
      if (!A[P + 1]) goto L3;
    L1:
      if (Kkk < Kk || Length != A[P + 1]) Fault(45);
      Qq = Constptr << 2;
      Jj = A[P + 2] << 2;  //  OUTPUT AN ARRAYHEAD RELATIVE TO Qq
      St[N0] = Jj - Kk * Bp;
      St[N0 + 1] = Jj;
      St[N0 + 2] = Qq;
      St[N0 + 3] = Ownlink;  //  NOW OUTPUT DOPE Vector
      Psym(1 << 16 | Bp);
      Psym(Kk);
      Psym(Kkk);  //  NOW PLANT Code
      K = A[Pp];
      J = 1;
      Testnst();
      Ownlink = N0 << 2;
      Rbase = Gla;
      Storetag(K, Ownlink);
      Rbase = 10 - Rlevel;
      N0 += 4;
      goto L99;
    L3:
      A[P + 2] = Constptr;
      A[P + 1] = Length;
      if (Length < 1) goto L1;
      for (Jj = 1; Jj <= (Length * Bp + 3) / 4; Jj++) Psym(0);
      goto L1;
    L99:;
    }
    goto L1;
  Sw_19:;
    Copytag(A[P + 3]);
    if (A[P + 2] == 1) goto L1910;
    if (Arr != 0 || Type != 3) goto L1999;
    From2(K, K);
    goto L1920;
  L1910:
    if (Arr != 1 || Type > 3 || J > 2) goto L1999;
  L1920:
    if (A[P + 1] == 2) goto L1930;
    Kk = Claimablereg();
    if (!Kk) goto L1999;
    Register[Kk] = A[P + 3] + 1;
    Prx(0x58, Kk, 0, I, K);
    Jj = Tags[A[P + 3]];
    From1(Jj, Jjj);
    Jjj = Jjj | Kk << 12;
  L1925:
    Replace1(Jj, Jjj);
    goto L1;
  L1930:
    if (Inreg == 0 || Register[Inreg] != A[P + 3] + 1) goto L1999;
    Register[Inreg] = 0;
    Jj = Tags[A[P + 3]];
    From1(Jj, Jjj);
    Jjj = Jjj & 0xFFFF0FFF;
    goto L1925;
  L1999:
    Fault(58);
    goto L1;
  Sw_26:
    Compiler = 1;
    Unass = 0;
    goto L1;
  Sw_27:;
    P++;
    if (A[P + 1] == 1) goto L2701;
    Crspec(2);
    goto L1;
  L2701:
    Copytag(A[P]);
    if (Ptype != 4 || A[P + 4] != 2 || 2 != A[P + 3]) goto L3901;
    P += 2;
    K = Displacement(Tags[A[P - 2]]);
    if (K == -1) goto L1;
    Ophead = K;
    P += 2;
    Crspec(3);
    goto L1;
  Sw_20:
    Mcswitch = 1;
    Perm = 1;
    goto L1;
  Sw_21:
    Sbflag = 1;
    goto L1;
  Sw_22:
    P = 2;
    Cuci();
    goto L1;
  Sw_23:;
    if (Level != 2 || Cprmode == 2) Fault(26);
    P++;
    Q = P + 1;
  L2302:
    if (A[Q] == 2) goto L2303;
    Q += 2;
    goto L2302;
  L2303:
    K = A[Q + 2] + ((A[Q + 1] - 1) << 14);
    Kkk = A[P];
    Pconst(0x41100000 | Kkk);
    if (Kkk > 32 || Kkk == 0 || Kkk == 29 || 12 <= Kkk && Kkk <= 13) Fault(36);
    Ppj(20);
    Qq = Ca;
    Pj(15, K);
    if (Ca != Qq + 8) Pconst(0x07000700);
    P += 2;
    if (A[P - 1] == 1) goto L2303;
    if (A[P + 2] == 2) goto L1;
    P += 3;
    Q = P + 1;
    goto L2302;
  Sw_24:
    if (Cprmode != 2 || Rlevel != 1) Fault(56);
    Loaddata();
    Finalise();
    exit(0);
  Sw_25:
    Mcswitch = 0;
    Perm = 0;
    goto L1;
  Sw_28:;
    J = 0;
    Ptype = 10006;
    Storetag(A[P + 1], Snum);
    Snum++;
    goto L1;
  Sw_29:
    List = 1;
    goto L1;
  Sw_30:
    List = 0;
    goto L1;
  Sw_31:;
    if (A[P + 1] == 9)
      J = A[P + 2];
    else
      Fromar4(P + 2, J);
    K = J & 15;
    if (K != 15) Linenos = K;
    K = (unsigned)J >> 4 & 15;
    if (K != 15) Diags1 = K;
    K = (unsigned)J >> 8 & 15;
    if (K != 15) Checks = K;
    if (K != 15) Checksp = K & 14;
    K = (unsigned)J >> 12 & 15;
    if (K != 15) Unass = K;
    K = (unsigned)J >> 28;
    if (K != 15) Dcomp = K;
    goto L1;
  Sw_32:
    Pop(Sbr[Level], J, K);
    if (J != -1) goto L321;
    Fault(51);
    goto L1;
  L321:
    Pop(Cycle[Level], Jj, Kk);
    if (0 >= Jj) goto L322;
    Fault(52);
    goto L321;
  L322:
    if (A[2] != 1) goto L402;
    if (J != 1) Fault(47);
    P += 2;
    Kk = K;
    Mone = 0;
    R13 = 0;
    Setline();
    if (A[P] == 9)
      Jj = Sflabel - 1;
    else
      Jj = Plabel - 1;
    Pj(15, Jj);
    Plab(Kk);
    Cui(2);
    Plab(-1);
    goto L1;
  Sw_33:;
    if (Level < 2) Fault(56);
    Setline();
    Crformat();
    goto L1;
  Sw_34:;
    {
      auto void Testandset(void);
      Setline();
      P++;
      Marker1 = P + A[P];
      if (Level < 2) Fault(57);
      if (Nmdecs[Level]) Fault(40);
      Checkrf();
      if (K == -1) goto L1;
      Type = 3;
      Prec = 0;
      Rout = 0;
      if (A[P + 1] == 1) goto Scalar;
      if (A[P + 2] != 2) Fault(41);
      Nam = 0;
      Arr = 1;
      Pack(Ptype);
      P += 3;
    L3401:
      Qq = P + 1;
      Pss(0xD2, 4, Wspr, 0, 4, 0);
      Cadcln(2);
      for (Q = 1; Q <= A[Qq]; Q++) {
        K = A[Q + Qq];
        Testandset();
        Ppj(13);
        Prx(0x90, 0, 3, Rbase, N);
        N += 16;
      }
      if (A[P] == 2) goto L1;
      P++;
      Checkrf();
      goto L3401;
    Scalar:
      Cqn(P + 2);
      P += 3;
      J = 0;
      Pack(Ptype);
      for (Q = 1; Q <= A[P]; Q++) {
        K = A[P + Q];
        Testandset();
        if (Nam == 1)
          Pss(0xD2, 4, Rbase, N, Gla, 128);
        else
          Paclod(18, 2, Rbase << 12 | N);  //  = ST WSP,? - AH WSP,LENGTH - LA WSP,7(WSP) - N WSP,=F'-8'
        N += 4;
      }
      goto L1;
      void Testandset(void) {
        Testnst();
        Jjj = Newcell();
        Storetag(K, Jjj);
        Replaceboth(Jjj, Tags[A[Marker1]], N);
      }
    L1:;
    }
    goto L1;
  Sw_35:;
    P++;
    Marker1 = P + A[P];
    if (A[P + 1] == 1) goto L3801;
    Rout = 1;
    P += 2;
    Clt();
    Arr = 2 - A[P + 1];
    Nam = (A[P + 2] - 1) << 1;
    Pack(Ptype);
    goto L3802;
  L3801:
    Ptype = 11000;
  L3802:
    J = 0;
    for (Kk = 1; Kk <= A[Marker1]; Kk++) {
      K = A[Marker1 + Kk];
      Testnst();
      Ophead = 0;
      Push(Ophead, N, 1000);
      Storetag(K, Ophead);
      N += 40;
    }
    goto L1;
  Sw_36:;
    P++;
    Marker1 = P + A[P];
    Checkrf();
    if (K == -1) goto L1;
    P++;
    Copytag(A[P]);
    if (A[P + 1] == 1) goto L3910;
    if (Type == 3 && Nam == 1) goto L3902;
  L3901:
    Fault(63);
    goto L1;
  L3902:
    From1(K, Q);
    if (Q) Fault(63);
    Replace1(K, Tags[A[Marker1]]);
    goto L1;
  L3910:;
    P += 2;
    K = Displacement(Tags[A[P - 2]]);
    if (K == -1) goto L3901;
    goto L3902;
  Sw_37:
    goto L1;
    void Cend(int Kkk) {
      int Dptr;
      int Lnum;
      int W1;
      int W2;
      int Dd[301 /*0:300*/];
      Setline();
      R13 = 0;
      Mone = 1;
    L1:
      Fromlist(Sbr[Level], J, K);
      if (J == -1) goto L2;
      Fault(53);
      A[2] = 32;
      A[3] = 2;
      Css(2);
      goto L1;
    L2:
      Filljumps(Level);
      if (N > Nmax) Nmax = N;
      Pop(Jump[Level], J, K);
      if (J == -1) goto L3;
      if (K >= Sflabel) goto L2;
      Fault(11);
      if (K < 16384)
        Write(K, 4);
      else
        Printname(K - 16384);
      goto L2;
    L3:
      Clearlist(Label[Level]);
      Clearlist(Wsp[Level]);
      Clearlist(Lwsp[Level]);
      Clearlist(Mdarr[Level]);
      Clearlist(Strwsp[Level]);  //  CLEAR DECLARATIONS -PLANT DIAGNOSTICS IF REQUIRED
      if (!Diags1) goto L10;
      Lnum = Lett[M[Level]];
      Dd[0] = 0xC2C2C2C2;
      Dd[1] = L[Level] << 16 | Rbase << 8 | Lnum;
      Dptr = 3;
      if (Lnum) goto L9;
      Dd[2] = L[Level - 1];
      goto L10;
    L9:
      W1 = M[Level];
      for (W2 = 1; W2 <= Lnum; W2++) {
        *Byteinteger(Addr(Dd[0]) + 7 + W2) = Lett[W1 + W2];
      }
      Dptr += (unsigned)(Lnum - 1) >> 2;
    L10:
      Pop(Name[Level], J, Jj);
      if (J == -1) goto L20;
      Copytag(Jj);
      Pop(Tags[Jj], Kk, Kk);
      if (Ptype == 8) {
        Register[K] = 0;
        Uvarreg[K] = 0;
      }
      if (Inreg) Register[Inreg] = 0;
      if (J != 15) goto L12;
      Fault(28);
      Printname(Jj);
    L12:
      Ophead = K;
      if (Type == 4) goto L13;
      if (Rout != 1 && Type != 3 && Type != 6 && Arr != 2) goto L14;
      Clearlist(Ophead);
      goto L10;
    L13:
      Undcrf(Ophead);
      goto L10;
    L14:
      if (Type != 1 && Type != 2 && Type != 5) goto L10;
      if (Arr != 0 || Diags1 != 1 || Rout != 0) goto L10;
      if (Dptr > 297) goto L10;
      Q = Word[Jj];
      Lnum = Lett[Q];
      if (Lnum > 8) Lnum = 8;
      Ptype = Nam << 6 | Prec << 3 | Type;
      Dd[Dptr] = Ptype << 24 | I << 20 | K << 8 | Lnum;
      for (W1 = 1; W1 <= Lnum; W1++) *Byteinteger(Addr(Dd[Dptr]) + W1 + 3) = Lett[W1 + Q];
      Dptr = Dptr + 1 + ((unsigned)(Lnum + 3) >> 2);
      goto L10;
    L20:
      if (!Diags1) goto L21;
      Dd[Dptr] = -1;
      Lput(4, (Dptr << 2) + 4, Sstl, Addr(Dd[0]));
      Sstl = Sstl + (Dptr << 2) + 4;  //  CHECK CYCLE-REPEATS
    L21:
      if (!Cycle[Level]) goto L22;
      From2(Cycle[Level], J);
      if (!J) goto L22;
      Pop(Cycle[Level], I, I);
      Fault(13);
      goto L21;
    L22:  //  GARBAGE COLECT DICTIONARY
      Next = Rnext[Level];
      for (W1 = 0; W1 <= Nnames; W1++)
        if (Word[W1] > Next) Word[W1] = 0;  //  PLANT ANY NECESSARY Code
      Nmax = (Nmax + 7) & (-8);
      if (Nmax > 4092) Fault(99);
      if (Kkk >= 10000 || Kkk == 1) Plug(Set[Rlevel], Nmax);
      if (Kkk == 10000) goto L23;
      if (!Kkk) goto L24;
      if (Kkk > 10000 && Compiler == 0) {
        Pconst(0x4100000B);
        Ppj(21);
      }
      if (Kkk == 1) Ppj(6);
      goto L30;
    L23:
      P++;
      A[P] = 5;
      Cui(0);
      goto L30;
    L24:
      Jj = 0xFFF & Ral[Level - 1];
      Prx(0x98, 10, 11, Rbase, Jj);
      if (Diags1 == 1) Pss(0xD2, 4, Gla, 20, Rbase, Jj + 8);
    L30:
      if (Kkk == 2) goto L99;
      Newline();
      if (Printmap == 1 && List == 1 && Kkk != 0) {
        Printstring(_imp_str_literal(" LOCALS EXTEND TO "));
        Write(Nmax, 2);
        Newline();
      }
      if (List) goto L31;
      Write(Line, 5);
      Spaces(3 * Level - 3);
      Printstring(_imp_str_literal("END"));
    L31:
      if (Level > 2 || Perm == 1 || Cprmode == 2) goto L33;
      if (Kkk == 1) goto L32;
      Fault(14);
      A[1] = 13;
      goto L99;
    L32:
      Kkk = 2;
    L33:
      Level--;
      if (Kkk >= 10000) Rlevel--;
      Rbase = 10 - Rlevel;
      Register[9 - Rlevel] = 0;
      N = Ral[Level];
      Sbflag = (unsigned)N >> 15 & 1;
      if (Kkk >= 10000) Nmax = (unsigned)N >> 16;
      N = N & 4095;
      if (Kkk == 2) goto L2;
      if (Rlevel == 1 && Cprmode == 2) goto L99;
      if (Kkk == 0 || Compiler == 1) goto L99;
      From2(Jump[Level], J);
      Plab(J);
    L99:;
    }
    void Crspec(unsigned char M) {
      int Pp;
      int Kk;
      int Jj;
      int Jjj;
      int Q;
      int Typep;
      if (M == 3) goto L12;
      Pp = P;
      if (M != 2) goto L2;
      Kk = A[P];
      P++;
      Copytag(Kk);
      if (Oldi == Level && 10006 != Ptype && Ptype >= 10000) goto L1;
      Fault(3);
      goto L99;
    L1:
      Fromlist(K, Jj, Q);
      Ophead = K;
      if (Q == 1000) goto L12;
      goto L10;
    L2:
      if (A[Pp + 1] == 2) goto L3;
      Typep = 10000;
      P = Pp + 3;
      goto L4;
    L3:
      Rout = 1;
      Arr = 0;
      P = Pp + 2;
      Clt();
      Nam = (A[P] - 1) * 2;
      Pack(Typep);
      P += 2;
    L4:
      Kk = A[P];
      Copytag(Kk);
      if (Oldi != Level) goto L11;
      if (Ptype == Typep || abs(Ptype - Typep) == 1000) goto L1;
    L10:
      Fname = Kk;
      if (Ptype != 7) Fault(7);
      if (M == 2) goto L99;
    L11:
      Jj = Nr;
      Nr++;
      Ra[Jj] = 4 * N0;
      N0++;
      if (Nr > Nrouts) Fault(109);
      Ophead = Newcell();
      J = 15;
      Ptype = Typep;
      Storetag(Kk, Ophead);
    L12:
      Jjj = Ophead;
      Q = 0;
      if (A[P + 1] == 2) goto L24;
    L13:
      P += 2;
      Compileformalparameter();
      for (Pp = 1; Pp <= A[P]; Pp++) {
        Kk = 0;
        if (Ptype == 5) Kk = Acc;
        Insertafter(Ophead, Ptype, Kk);
        Q++;
      }
      P = P + Pp + 1;
      if (A[P] == 1) goto L13;
    L24:
      Replace2(Jjj, Q);
      if (M == 3) goto L99;
      Replace1(Jjj, Jj);
    L99:;
    }
    void Compileformalparameter(void) {
      static int Fpd_sw;
      static void *Fpd[5 /*1:5*/] = {
          &&Fpd_1, &&Fpd_2, &&Fpd_3, &&Fpd_4, &&Fpd_default,
      };
      goto *Fpd[Fpd_sw = (A[P]) - 1];
    Fpd_1:;
      Acc = 16;
      Rout = 1;
      Nam = 1;
      Arr = 0;
      if (A[P + 1] != 1) goto L1;
      Prec = 0;
      Type = 0;
      P += 3;
      goto L98;
    L1:
      P += 2;
      Clt();
      Nam = 2 * (A[P] - 1) + 1;
      P += 2;
      Acc = 16;
      goto L98;
    Fpd_2:;
      P++;
      Clt();
      Cqn(P);
      Rout = 0;
      if (Type == 5 && Acc == 0) Fault(70);
      P++;
      goto L98;
    Fpd_3:;
      Type = 0;
    L31:
      Nam = 1;
      Arr = 2 - A[P + 1];
      Rout = 0;
      Acc = 4 + 12 * Arr;
      Prec = 0;
      P += 2;
      goto L98;
    Fpd_4:
      Type = 3;
      goto L31;
    L98:
      Pack(Ptype);
      goto Fpd_skip;
    Fpd_default:
      fprintf(stderr, "\nSwitch label 'Fpd(%d):' not set in %s\n", Fpd_sw + 1, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    Fpd_skip:;
    }
    void Assign(int P1, int P2) {
      int Q;
      int Assop;
      int Kk;
      int Reg;
      int Precp;
      int Z;
      int Zp;
      int Typep;
      int Jjj;
      static int Sw_sw;
      static void *Sw[4 /*1:4*/] = {
          &&Sw_1,
          &&Sw_2,
          &&Sw_3,
          &&Sw_4,
      };
      static int S_sw;
      static void *S[16 /*0:15*/] = {
          &&S_0, &&S_1,       &&S_2,  &&S_3,  &&S_4,  &&S_5,       &&S_6,  &&S_7,
          &&S_8, &&S_default, &&S_10, &&S_11, &&S_12, &&S_default, &&S_14, &&S_default,
      };
      Assop = A[P2];
      goto *Sw[Sw_sw = (Assop)-1];
    Sw_2:
    Sw_3:
      Copytag(A[P1 + 1]);
      P = P2 + 1;
      if (Type == 8) goto Regvar;
      if (Rout == 1) goto Maps;
      if (Type == 2) goto L34;
      if (Type == 5) goto L50;
      if (Type == 3) goto L35;
      if (Nam == 0 && Type == 1 && Arr == 0) goto L32;
    L33:
      P = P2 + 1;
      Kk = 0;
      if (Arr != 0 || Rout != 0 || 1 < Type) Kk = 4;
    L36:
      if (Kk == 4 && Register[4] != 0) Kk = 14;
      Csexp(Kk, 1);
      Reg = Nest;
      Kk = P;
      if (!Register[Reg]) Register[Reg] = 1;
      P = P1 + 1;
      Cname((Assop - 1) * (Assop - 1), Reg);
      if (Register[Reg] > 0) Register[Reg] = 0;
    L30:;
      P = Kk;
      if (A[P] == 1 && 1 == Qu) Cquery(Reg);
      P++;
      goto L1;
    L31:
      Printstring(_imp_str_literal(" CRUNCH "));
      _imp_monitor();
      exit(0);
    L32:
      if (Rout == 1 || A[P1 + 2] == 1 || A[P1 + 3] == 1) goto L33;
      if (Unass == 1) goto L33;
      Precp = Prec;
      Typep = Ptype;
      Kk = K;
      Reg = I;
      Q = Tsexp(Jjj);
      Ptype = Typep;
      Unpack();
      if (Q == 0 || A[P] == 1 && 1 == Qu) goto L33;
      if (10 <= Q && Q <= 12 && Q - 10 == Precp) goto L37;
      if (Q != 1 || Precp != 1) goto L33;
      Psi(0x92, Jjj, Reg, Kk);
      P++;
      goto L1;
    L37:
      Pss(0xD2, Bytes[Precp], Reg, Kk, I, K);
      P++;
      goto L1;
    L34:
      Q = 2;
      if (Prec == 3) Q = 3;
      if (A[P1 + 2] == 1) {
        P = P1 + 2;
        Fflag = 0;
        Skipapp();
        if (Fflag) goto L55;
        P = P2 + 1;
      }
      Csexp(0, Q);
      Kk = P;
      Freg[Nest] = 1;
      Reg = Nest;
      P = P1 + 1;
      Cname(1, Nest);
      Freg[Reg] = 0;
      goto L30;
    L35:
      P = P1 + 1;
      Q = Copyrecordtag();
      P = P2 + 1;
      if (Type != 2 && Type != 5) Type = 1;
      if (Type == 5) goto L50;
      Kk = 4;
      if (Type == 1) goto L36;
      goto L34;
    L50:
      Cstrexp(4);
      Kk = P;
      Register[4] = 1;
      P = P1 + 1;
      Cname(IEXP((Assop - 1), 2), 4);
      Register[4] = 0;
      Reg = 4;
      goto L30;
    Maps:
      if (Ptype == 10006) {
        Type = Tsname[K];
        Prec = (unsigned)Type >> 3;
        Type = Type & 7;
      }
      if (Type == 1) goto L33;
      if (Type == 5) goto L50;
    L55:
      P = P2 + 1;
      Precp = Prec;
      Csexp(0, 2 + (Prec & 1));
      Q = Parkf(Nest, 3);
      Kk = P;
      P = P1 + 1;
      Cname(3, 1);
      Dump(16, 0, Q, 0, Rbase);
      Dump(9 + 2 * Prec, 0, 0, 0, 1);
      Push(Lwsp[Level], 0, Q);
      goto L30;
    Regvar:
      if (A[P1 + 2] != 2 || 2 != A[P1 + 3]) Fault(59);
      Kk = K;
      Csexp(Kk, 1);
      Register[Kk] = -1;
      if (A[P] == 1 && 1 == Qu) Cquery(Reg);
      P++;
      goto L1;
    Sw_4:;
      P = P1 + 1;
      Cname(2, 1);
      P = P2 + 1;
      Cres(0, 0);
      P++;
      goto L1;
    Sw_1:;
      P = P1 + 1;
      Copytag(A[P]);
      if (I == -1) goto L9;
      Q = 1;
      if (Type == 3) Q = Copyrecordtag();
      if (!Q) goto L201;
      if (A[P2 + 1] != 4 || A[P2 + 2] != 1) Fault(81);
      if (Rout == 1) goto L101;
      Nest = 4;
      goto *S[S_sw = ((Nam & 2) + Arr) << 2 | (Nam & 1) * 2 | (2 - A[P + 1])];
    L9:
      Fname = A[P];
      Fault(16);
    S_0:
    S_1:
    S_3:
    S_4:
    S_5:;
    S_7:
    S_8:
    S_10:
    S_11:
    S_12:;
    L10:
      Fault(82);
      P = P2 + 1;
      Skipexp();
      P++;
      goto L1;
    S_2:;
      Z = 3;
      Zp = 6;
    L12:
      P = P2 + 3;
      Cname(Z, 4);
      if (A[P] != 2) goto L10;
      Precp = Prec;
      Typep = Type;
      Kk = P + 2;
      P = P1 + 1;
      Cname(Zp, 4);
    L14:;
      P = Kk;
      if (Prec == Precp && Type == Typep) goto L1;
      Fault(83);
      goto L1;
    S_6:;
    S_14:;
      Z = 12;
      Zp = 11;
      goto L12;
    L201:;
      if (Arr == 1 && Nam == 1 && A[P + 1] == 2) goto *S[S_sw = 6];
      Z = 15;
      Zp = 14;
      goto L12;
    L101:
      P = P1 + 1;
      Cname(13, 1);
      Precp = Prec;
      Typep = Type;
      Jjj = K;
      if (J != 0 || Nam != 1) goto L10;
      Reg = Findpp();
      if (!Reg) goto L31;
      Dump(0, Reg, Disp, Index, Base);
      P = P2 + 3;
      Cname(13, 1);
      if (Base == Gla && J == 0) goto L102;
      Pss(0xD2, 16, Reg, 0, Base, Disp);
      if (J == 14) goto L103;
    L110:
      Register[Reg] = 0;
      Kk = P + 2;
      From2(Jjj, Z);
      From2(K, Zp);
      if (Z != Zp) Fault(83);
      goto L14;
    L102:
      Dump(2, 2, Disp, Index, Base);
      Prx(0x5A, 2, 0, Gla, 28);
      Pconst(0x180C181D);
      Prr(0x18, 3, Reg);
      Prx(0x90, 0, 9, Reg, 0);
      goto L110;
    L103:
      Prx(0x50, 9, 0, Reg, 12);
      goto L110;
    L1:;
      goto S_skip;
    S_default:
      fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    S_skip:;
    }
    void Cui(unsigned char Code) {
      int Kk;
      int Jj;
      int Qq;
      static int Sw_sw;
      static void *Sw[11 /*1:11*/] = {
          &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6, &&Sw_7, &&Sw_8, &&Sw_9, &&Sw_10, &&Sw_11,
      };
      goto *Sw[Sw_sw = (A[P]) - 1];
    Sw_1:
      P++;
      Marker1 = P + A[P];
      if (A[Marker1] == 1) goto L3;
      P++;
      Cname(0, 0);
      P++;
      goto L1;
    L3:
      Assign(P, Marker1 + 1);
      goto L1;
    Sw_2:;
      Nmdecs[Level] = 1;
      Copytag(A[P + 1]);
      Ptypep = Ptype;
      Kk = K;
      P += 2;
      if (Oldi == Level && Type == 6) goto L200;
      Fault(4);
      Skipexp();
      goto L1;
    L200:
      Csexp(1, 1);
      Ptype = Ptypep;
      Unpack();
      Fromlist(Kk, Qq, Jj);
      Qq -= Codebase[Level];
      if (!Checksp) goto L205;
    L201:
      Loadad(2, 10, 0, Qq);
      Ppj(7);
      goto L1;
    L205:
      Jj = 8 + Qq - Jj * Bytes[Prec];
      if (0 > Jj || Jj > 4095) goto L201;
      if (!Prec) goto L210;
      Plant(0x1A11);
      Kk = 0x48;
    L207:
      Prx(Kk, 1, 1, 10, Jj);
      Pconst(0x47F1A000);
      goto L1;
    L210:
      Pconst(0x89100002);
      Kk = 0x58;
      goto L207;
    Sw_3:;
      Nmdecs[Level] = 1;
      K = A[P + 2] + ((A[P + 1] - 1) << 14);
      Pj(Mask, K);
      P += 3;
      goto L1;
    Sw_4:;
      K = (A[P + 1] + 2) / 2;
      P++;
      Ppj(30);
      for (Kk = 1; Kk <= K; Kk++) {
        Plant(A[P] << 8 | A[P + 1]);
        P += 2;
      }
      goto L1;
    Sw_5:;
      if (Flag[Level] != 10000 && Perm != 1) Fault(30);
      P++;
    L6:
      if (Diags1 == 1) Pss(0xD2, 4, Gla, 20, Rbase, 0);  //  CHECK FOR REGISTER VARS & UPDATE CORE COPY
      for (Kk = 5; Kk <= 8; Kk++)
        if (0 != Uvarreg[Kk] && Uvarreg[Kk] < Level) Prx(0x50, Kk, 0, Rbase, Kk << 2);
      Prx(0x98, 4, 15, Rbase, 16);
      R13 = 0;
      Prr(7, 15, Link);
      goto L1;
    Sw_6:;
      P++;
      Kk = Flag[Level];
      if (Kk <= 10000) Fault(31);
      if (Kk == 10002) goto L61;
      if (Kk == 10032) goto L62;
      if (Kk == 10005) goto L63;
      Csexp(1, 1);
      goto L6;
    L61:
      Csexp(2, 2);
      goto L6;
    L62:
      Csexp(2, 3);
      goto L6;
    L63:
      Cstrexp(1);
      goto L6;
    Sw_7:
    Sw_8:;
      Ppj(6 * (A[P] - 6));
      P++;
      goto L1;
    Sw_9:
      Sflabel--;
      Push(Sbr[Level], Code, Sflabel);
      Push(Cycle[Level], 0, 0);
      goto L1;
    Sw_11:;
      Kk = 2 - A[P + 1];
      P += 2;
      Psi(0x92, Kk, Gla, 1);
      goto L1;
    Sw_10:
      Ppj(31);
      P++;
    L1:;
    }
    void Crformat(void) {
      int Lengthp;
      int Qqq;
      int Rep;
      int Code;
      K = A[P + 1];
      Testnst();
      J = 0;
      Ptype = 4;
      Ophead = Newcell();
      Jjj = Ophead;
      Storetag(K, Jjj);
      P = 3;
      Q = 0;
      Inc = 4;
      Incp = 0;
      if (A[P] == 2) goto L101;
    L1:
      P++;
      Compileformalparameter();
      Lengthp = Acc - 1;
      if (Acc > 8) Lengthp = 3;
    L2:
      if (!(Incp & Lengthp)) goto L3;
      Incp++;
      goto L2;
    L3:
      for (Rep = 1; Rep <= A[P]; Rep++) {
        P++;
        Code = 255;
        Lengthp = Acc;
        if (Rout == 1) goto L11;
        if (Type == 3) goto L12;
        Qqq = Incp;
        if (Type != 5) goto L4;
        Code = 250;
        Lengthp = Acc - 1;
        Qqq = Inc;
      L4:
        Insertafter(Ophead, Ptype << 4 | A[P] << 20, Qqq);
        Psi(0x92, Code, Rbase, N + Inc);
        Psi(0x92, Lengthp, Rbase, N + Inc + 1);
        Q++;
        Inc += 4;
        Incp += Acc;
        goto L15;
      L11:
        Qqq = Newcell();
        Replaceboth(Qqq, Incp, 100);
        if (Ptype != 11000) Fault(41);
        Acc = 40;
        Lengthp = Acc;
        goto L4;
      L12:
        Qqq = Newcell();
        Replaceboth(Qqq, 0, Incp);
        goto L4;
      L15:;
      }
      P++;
      if (A[P] == 2) goto L101;
      P++;
      goto L1;
    L101:
      P++;
    L102:
      if (A[P] == 2) goto L201;
      P += 2;
      Clt();
      Nam = 2 * (2 - A[P]);
      if (Nam) Acc = 4;
      P++;
      Rout = 0;
      Arr = 1;
      Pack(Ptype);
    L103:;
      Psi(0x92, 0, Rbase, N + Inc);
      Dump(1, Wspr, N + Inc + 8, 0, Rbase);
      Qq = P;
      Cadcln(1);
      Jj = P;
      P = Qq + 2;
      Rep = P + A[P - 1];
    L105:
      Insertafter(Ophead, J | Ptype << 4 | A[P] << 20, Inc);
      Inc += 16;
      Q++;
      P++;
      if (P == Rep) goto L106;
      Pss(0xD2, 16, Rbase, N + Inc, Rbase, N + Inc - 16);
      goto L105;
    L106:
      P = Jj + 2;
      if (A[P - 1] == 1) goto L103;
      goto L102;
    L201:
      Replaceboth(Jjj, N, Q);
      Prx(0x41, 1, 0, 0, Q);
      Dump(5, 1, N, 0, Rbase);
      Dump(0, 1, N, 0, Rbase);
      Ppj(25);
      N += Inc;
    }
    void Cadcln(unsigned char Mode) {
      int Q;
      int Qq;
      int Kk;
      int S;
      int Jj;
      int Jjj;
      Q = P;
      Ptypep = Ptype;
    L1:
      P = A[Q + 1] + Q + 1;
      Kk = 0;
      if (Mode == 1) goto L4;
      Prx(0x50, Wspr, 0, Gla, 36);
      if (Unass == 1) Psi(0x92, 1, Gla, 36);
    L4:
      P += 2;
      Jj = P;
      Kk++;
      Skipexp();
      Qq = Tsexp(Jjj);
      P = Jj;
      if (!Qq)
        Csexp(4, 1);
      else
        Csexp(1, 1);
      Register[4] = 1;
      Csexp(2, 1);
      Register[4] = 0;
      if (!Qq) Prr(0x18, 1, 4);
      if (Kk != 1) goto L41;
      S = 1;
      if (Mode != 2) {
        S = 0;
        Prx(0x41, 0, 0, 0, Acc);
      }
      Prx(0x90, S, 2, Wspr, 4 * S);
      Psi(0x92, 3 - A[P], Wspr, 1);
      Mover(Wspr, 16);
      goto L42;
    L41:
      S = (Kk & 1) << 2;
      if (!S)
        Jjj = 8 * A[P];
      else
        Jjj = 16;
      Prx(0x90, 1, 2, Wspr, S);
      Mover(Wspr, Jjj);
    L42:
      if (A[P] == 1) goto L4;
      if (Kk <= 2) goto L5;
      if (Kk > 6) Fault(37);
      Paclod(27, 3, Kk);
    L5:
      Qq = Q + 1;
      J = Kk;
      Ptype = Ptypep;
      if (Mode >= 1) goto L9;
      for (Jjj = 1; Jjj <= A[Qq]; Jjj++) {
        K = A[Qq + Jjj];
        Testnst();
        J = Kk;
        Storetag(K, N);
        Ppj(13);
        Prx(0x90, 0, 3, Rbase, N);
        N += 16;
      }
      Q = P + 2;
      if (A[Q - 1] == 1) goto L1;
    L9:;
    }
    void Cvdecln(void) {
      int Lb;
      int Ub;
      int Adv;
      int Q;
      int Qq;
      int Range;
      int Jjj;
      int Kk;
      int Disp0;
      int Disp1;
      Q = P;
      P = A[Q + 1] + Q + 2;
      Cbpair(Lb, Ub);
      Adv = N0;
      St[N0] = 1 << 16 | Acc;
      St[N0 + 1] = Lb;
      St[N0 + 2] = Ub;
      Range = Ub - Lb + 1;
      St[N0 + 3] = Range;
      N0 += 4;
      if (Lb > Ub) Fault(44);
      Prx(0x41, 2, 0, Gla, Adv << 2);
      Prx(0x41, 3, 0, 0, Range);
      Qq = Q + 1;
      J = 1;
      for (Jjj = 1; Jjj <= A[Qq]; Jjj++) {
        N = (N + 7) & (-8);
        Disp1 = N + 16;
        Disp0 = Disp1 - Lb * Acc;
        if (0 >= Disp0 || Disp0 >= 4095) Fault(44);
        Kk = Newcell();
        Replaceboth(Kk, Disp0, N);
        Prx(0x41, 0, 0, Rbase, Disp0);
        Prx(0x41, 1, 0, Rbase, Disp1);
        K = A[Qq + Jjj];
        Testnst();
        Storetag(K, Kk);
        Prx(0x90, 0, 3, Rbase, N);
        if (Unass == 1) Set80(Disp1, Acc * Range);
        N = Disp1 + Acc * Range;
      }
      P++;
      if (A[P - 1] == 1) Cvdecln();
      N = (N + 3) & (-4);
    }
    void Csexp(int Reg, unsigned char Mode) {  //  MODE=1 FOR %INTEGER, =2REAL, =3LONG,=0INTEGER %IF PNS
      int C;
      int D;
      int Qp;
      int Nop;
      int X;
      int Jj;
      int Opcode;
      int Evaluate;
      int Opnd;
      short Ophead;
      unsigned char Real;
      unsigned char Longreal;
      unsigned char Realop;
      int Operator;
      int Nops;
      int Lastop;
      int Bs[2 /*1:2*/];
      int Pt[2 /*1:2*/];
      int Dp[2 /*1:2*/];
      int Op[6 /*0:5*/];
      int Opprec[6 /*0:5*/];
      auto void Test(int N);
      auto void Plant(int A, int B, int C);
      auto int Findr(void);
      auto void Load(int *N, int Reg, int Mode);
      auto void Printorders(void);
      static int N0 = 1024;
      Qp = 0;
      Ophead = 0;
      Opcode = 0;
      Real = 0;
      Longreal = 0;
      Realop = 0;
      Nops = 0;
      Lastop = 0;
      {
        static int S_sw;
        static void *S[4 /*1:4*/] = {
            &&S_1,
            &&S_2,
            &&S_3,
            &&S_4,
        };
        static int Sw_sw;
        static void *Sw[4 /*1:4*/] = {
            &&Sw_1,
            &&Sw_2,
            &&Sw_3,
            &&Sw_4,
        };
        Aflag = 0;
        Nop = N0;
        Op[0] = 0;
        Opprec[0] = 0;
        goto *S[S_sw = (A[P]) - 1];
      S_2:;
        Op[1] = 11;
      L101:
        Opprec[1] = 2 + Op[1] / 6;
        Qp = 1;
        goto L1;
      S_3:
        Op[1] = 23;
        goto L101;
      S_1:
      S_4:
      L1:;
        Opnd = A[P + 1];
        P += 2;
        Qp++;
        goto *Sw[Sw_sw = (Opnd)-1];
      Sw_1:;
        Copytag(A[P]);
        if (Type == 8) goto Regvar;
        if (Type == 3 && Arr == 0 && Inreg != 0) goto L19;
        if (Arr == 2 && A[P + 1] == 1) goto L171;
        if (1 <= Type && Type <= 2 && Arr == 0 && Rout == 0 && A[P + 1] == 2 && 2 == A[P + 2]) goto L17;
      L10:;
        if (Type != 1 && (Rout != 1 || Type != 6 || (Tsname[K] & 7) != 1)) goto L14;
        C = P;
        if (Qp > 1) goto L11;
        P++;
        Skipapp();
        if (A[P] != A[P + 1] || A[P + 1] != 2) goto L11;
        P = C;
        C = Reg;
        if (Reg <= 0) {
          C = Findr();
          Register[C] = 0;
        }
        Cname(2, C);
        Nest = C;
        goto L80;
      L11:
        P = C;
        C = Findpp();
        if (!C) goto L14;
        Cname(2, C);
        Nest = C;
        if (Qp == 1 && A[P] == 2) goto L80;
        P++;
      L12:
        St[N0] = 9;
        St[N0 + 1] = C;
        N0 += 3;
        Register[C] = 1;
        goto L50;
      L14:  //  OPERAND MUST BE FETCHED AND STORED
        Cname(2, 2);
        Nest = 2;
        if (Type == 5) {
          Fault(42);
          Type = 1;
        }
        if (Type == 2)
          Freg[2] = 1;
        else
          Register[2] = 1;
        Nam = 0;
        Arr = 0;
        Rout = 0;
        if (Prec == 3) Longreal = 1;
        if (Qp == 1 && A[P] == 2) goto L80;
      L16:
        if (Type == 1) goto L15;
        Real = 1;
        if (Prec == 3) Longreal = 1;
        if (A[P] == 2) goto L161;
        C = Parkf(Nest, Prec);
        Freg[Nest] = 0;
      L13:
        St[N0] = 10;
        P++;
        St[N0 + 1] = Rbase | (Type | Prec << 3 | Nam << 6) << 8;
        St[N0 + 2] = C;
        N0 += 3;
        goto L50;
      L161:
        St[N0] = 8;
        St[N0 + 1] = Nest + 512 + (Prec << 11);
        Freg[Nest] = 1;
        N0 += 3;
        P++;
        goto L50;
      L15:
        C = Nest;
        C = Park(Nest);
        if (Nest != C) Register[Nest] = 0;
        if (C > 0) goto L18;
        C = abs(C);
        Prec = 0;
        goto L13;
      L18:
        P++;
        goto L12;
      L17:  //  OPND HAS BASE REGISTER COVER
        St[N0] = 2;
        St[N0 + 1] = I | (Type | Prec << 3 | Nam << 6) << 8;
        St[N0 + 2] = K;
        P += 4;
        N0 += 3;
        if (Type == 2) Real = 1;
        if (Prec == 3) Longreal = 1;
        if (Unass != 1 || (Prec != 0 && Prec != 3)) goto L50;
        if (Nam == 1) goto L50;
        Pss(0xD5, Bytes[Prec], I, K, Gla, 128);
        Prx(0x47, 8, 0, Coder, 40);
        goto L50;
      L171:
        if (A[P + 2] != 4 || A[P + 3] != 2 || A[P + 4] != 9) goto L10;
        if (A[P + 5] >= 256 || A[P + 6] != 2 || A[P + 7] != 2 || 2 != A[P + 8]) goto L10;
        From1(K, C);
        C += Bytes[Prec] * A[P + 5];
        if (0 >= C || C >= 4096) goto L10;
        K = C;
        P += 6;
        goto L17;
      L19:
        if (A[P + 1] != 2 || A[P + 2] != 1) goto L14;
        P += 3;
        From1(K, Fname);
        I = Inreg;
        K = Displacement(Fname);
        if (I == -1) goto L191;
        Unpack();
        if (Arr == 0 && Rout == 0 && 1 <= Type && Type <= 2 && A[P + 1] == 2 && 2 == A[P + 2]) goto L17;
      L191:
        P -= 3;
        goto L14;
      Regvar:
        if (A[P + 1] != 2 || 2 != A[P + 2]) goto L14;
        P += 4;
        St[N0] = 9;
        St[N0 + 1] = K;
        N0 += 3;
        goto L50;
      Sw_2:;
        C = A[P];
        St[N0 + 1] = P;
        St[N0 + 2] = A[P + 1];
        if ((C & 7) == 2) goto L24;
        if (C == 5) {
          Fault(42);
          P = P + (A[P + 1] & 0xFE) + 1;
          C = 9;
        }
        if (C <= 8) goto L22;
        St[N0] = 0;
      L21:
        N0 += 3;
        P += 3;
        goto L50;
      L22:
        St[N0] = 1;
        P++;
        goto L21;
      L24:
        Real = 1;
        P += 2;
        goto L22;
      Sw_3:
      Sw_4:;
        D = 0;
        if (Mode == 1 || Lastop == 12) D = 1;
        Csexp(0, D);
        if (Opnd != 4) goto L32;
        D = 16 * Type;
        if (Type == 2 && Prec == 0) D = 48;
        Prr(D, Nest, Nest);
      L32:
        if (Prec == 3) Longreal = 1;
        if (Qp == 1 && A[P] == 2) goto L80;
        goto L16;
      L50:  //  DEAL WITH Operator
        if (A[P - 1] == 2) goto L60;
        Operator = A[P];
        if (Operator == 12) {
          Fault(42);
          Operator = 2;
        }
        if (Operator == 13) Operator = 6;
        if (Operator == 1 || Operator == 8) Realop = 1;
        if (Operator == 1) Operator = 12;
        Nops++;
        Lastop = Operator;
        C = Precedence[Operator];
      L51:
        if (C > Opprec[Qp - 1]) goto L52;
        Qp--;
        St[N0] = Op[Qp];
        N0 += 3;
        goto L51;
      L52:
        Op[Qp] = 10 + Operator;
        Opprec[Qp] = C;
        goto L1;
      L60:  //  - END OF EXPRESSION
        for (Jj = Qp - 1; Jj >= 0; Jj--) {
          St[N0] = Op[Jj];
          N0 += 3;
        }
        if (Mode != 1 && Realop == 1) Real = 1;
        if (Real == 1) goto L70;
        //  - CAN EVALUATE AS Integer
        Printorders();
      L61:
        if (Mode >= 2) goto L71;
      L72:
        D = 1;
        if (0 >= Reg) Reg--;
        if (Real != 0 || 0 <= Reg || Dp[1] >= 0 || Register[Bs[1]] >= 0) Load(D, Reg, Real);
        Nest = Bs[1];
        if (Real == 1)
          Freg[Nest] = 0;
        else if (Register[Nest] > 0)
          Register[Nest] = 0;
        Ptype = 1 + 30 * Longreal + Real;
        N0 = Nop;
        Unpack();
        goto L99;
      L70:  //  EVALUATE AS Real
        if (Mode == 1) Fault(24);
        if (Mode == 3) Longreal = 1;
        Evaluate = 16 * Longreal;
        Printorders();
        goto L72;
      L71:
        if (Mode == 3) Longreal = 1;
        Real = 1;
        Evaluate = 16 * Longreal;
        goto L72;
      L80:  //  SINGLE OPERAND EXPRESSION
        Bs[1] = Nest;
        Dp[1] = -1;
        Pt[1] = Prec << 3 | Type;
        Aflag = 0;
        P++;
        if (Type == 2 && Mode == 1) Fault(24);
        if (Type == 1) goto L61;
        goto L71;
      L99:;
      }
      goto L99;
      int Findr(void) {
        int I;
        if (0 >= Reg) goto L2;
        I = Reg;
        if (!Register[I]) goto L1;
      L2:
        for (I = 1; I <= Rbase - 1; I++)
          if (!Register[I]) goto L1;
        Fault(241);
      L1:
        Register[I] = 1;
        return (I);
      }
      int Findpr(void) {
        int I;
        for (I = 0; I <= 6; I += 2)
          if (Register[I] == 0 && Register[I + 1] == 0) goto Found;
        Fault(242);
      Found:
        Register[I] = 1;
        Register[I + 1] = 1;
        return (I);
      }
      int Findfr(void) {
        int I;
        for (I = 6; I >= 0; I -= 2)
          if (!Freg[I]) goto L1;
        Fault(242);
      L1:
        Freg[I] = 1;
        return (I);
      }
      void Load(int *N, int Reg, int Mode) {
        int I;
        int X;
        int *Bsi;
        int *Dpi;
        int *Pti;
        I = *N;
        if (I) goto Nochoice;
        I = 1;
        if (Dp[1] < 0 && Register[Bs[1]] >= 0) goto Chosen;
        I = 2;
        if (Dp[2] < 0 && Register[Bs[2]] >= 0) goto Chosen;
        if (Mode == 0 && (Pt[2] == 255 || (Pt[2] & 24) == 8)) goto Chosen;
        if (Mode == 1 && ((Pt[2] & 7) == 1 || (Evaluate > 0 && (Pt[2] & 24) == 0))) goto Chosen;
        I = 1;
      Chosen:
        *N = I;
      Nochoice:
        Bsi = &Bs[I];
        Dpi = &Dp[I];
        Pti = &Pt[I];
        if (Mode == 0 && *Pti == 255) goto Shortconst;
        if (Mode == 1 || (*Pti & 64) != 0) Test(I);
        if (*Dpi < 0) goto Inreg;
        if (Reg >= 0) goto Nofind;
        if (!Mode)
          Reg = Findr();
        else
          Reg = Findfr();
      Nofind:
        X = (Mode << 3 | ((unsigned)*Pti >> 2 & 6)) + 2;
        Dump(X, Reg, *Dpi, 0, *Bsi);
        goto L98;
      Inreg:
        if (Mode == 1) goto L90;
        if (*Bsi == Reg) goto L99;
        if (Register[*Bsi] < 0) goto Locked;
        if (0 > Reg) goto L99;
        Register[*Bsi] = 0;
      Swop:
        Prr(0x18, Reg, *Bsi);
        goto L98;
      Locked:
        if (0 > Reg) Reg = Findr();
        goto Swop;
      L90:
        if (!*Bsi) goto L91;
        if (*Bsi == Reg || 0 > Reg) goto L99;
      L91:;
        if (0 > Reg) Reg = Findfr();
        Prr(0x38 - Evaluate, Reg, *Bsi);
        Freg[*Bsi] = 0;
        goto L98;
      Shortconst:
        if (0 > Reg) Reg = Findr();
        Dump(0, Reg, *Dpi, 0, 0);
      L98:
        *Bsi = Reg;
        *Dpi = -2;
      L99:;
      }
      void Plant(int Opcode, int R1, int R2) {
        int Bsr2;
        Bsr2 = Bs[R2];
        R1 = Bs[R1];
        if (Dp[R2] < 0) goto Rrop;
        if ((Pt[R2] & 24) == 16 && 0x5A <= Opcode && Opcode <= 0x5B) Opcode -= 16;
        Prx(Opcode, R1, 0, Bsr2, Dp[R2]);
        goto L99;
      Rrop:
        Prr(Opcode - 64, R1, Bsr2);
        if (Real == 1) Freg[Bsr2] = 0;
        if (Real == 0 && Register[Bsr2] > 0) Register[Bsr2] = 0;
      L99:;
      }
      void Test(int N) {  //  INSPECTS OPERAND - MAKES TYPE CONVERSIONS ETC.
        int X;
        int *Lbase;
        int *Ldisp;
        int *Lptype;
        unsigned char Lprec;
        Lptype = &Pt[N];
        Ldisp = &Dp[N];
        Lbase = &Bs[N];
        Lprec = (unsigned)*Lptype >> 3 & 3;
        if (*Lptype == 255) goto Shortconst;
        if (!(*Lptype & 64)) goto Start;
        Rp13 = R13;
        R13 = *Lbase << 12 | *Ldisp;
        if (R13 != Rp13) Prx(0x58, Link, 0, *Lbase, *Ldisp);
        *Lptype = *Lptype & 31;
        *Lbase = Link;
        *Ldisp = 0;
      Start:
        if (Real) goto Floating;
        if (Lprec == 0 || (Lprec == 2 && 12 <= Opcode && Opcode <= 13)) goto Finish;
      Pickup:
        Load(N, -1, 0);
        Lprec = 0;
        goto Finish;
      Shortconst:
        Lprec = 0;
        if (!Real) goto Pickup;
        if (0 <= *Ldisp && *Ldisp <= 2) goto Ingla;
        A[-2] = 9;
        A[-1] = *Ldisp;
        *Ldisp = Sortconst(-2, Longreal, 2);
      L1:
        *Lbase = Gla;
        goto Finish;
      Ingla:
        *Ldisp = 8 * *Ldisp + 40;
        goto L1;
      Floating:
        if ((*Lptype & 7) == 1) goto Floatit;
        if (Lprec == 3 || Evaluate == 0) goto Finish;
        //  MUST STRETCH A 32 BIT Real
        if (*Ldisp < 0) Freg[*Lbase] = 1;
        X = Findfr();
        Prr(0x2B, X, X);
        if (*Ldisp < 0) {
          Prr(0x38, X, *Lbase);
          Freg[*Lbase] = 0;
        } else
          Prx(0x78, X, 0, *Lbase, *Ldisp);
        *Lbase = X;
        *Ldisp = -2;
        goto Finish;
      Floatit:
        Load(N, 1, 0);
        Ppj(43);
        Register[1] = 0;
        *Lbase = 0;
        *Ldisp = -2;
      Finish:
        *Lptype = (1 + Real) | Lprec << 3;
        if (Longreal == 1 && Real == 1) *Lptype = *Lptype | 24;
      }
      void Mult(int *Result) {
        int I;
        int K;
        for (I = 1; I <= 2; I++) {
          if (Pt[I] == 255 && Dp[I] == 2) goto L30;
          if (Dp[I] < 0 && Register[Bs[I]] >= 0) goto L1;
        L5:;
        }
        I = 1;
        K = Findpr();
        Load(I, K + 1, 0);
        goto L11;
      L1:
        if ((Bs[I] & 1) == 1 && I > 0 && Register[Bs[I] - 1] == 0) goto L14;
        if ((Bs[I] & 1) == 0 && Register[Bs[I] + 1] == 0) goto L12;
        goto L5;
      L12:
        K = Bs[I];
        Register[K + 1] = 1;
        Prr(0x18, K + 1, K);
        goto L13;
      L14:
        Register[Bs[I] - 1] = 1;
      L11:
        Bs[I] = Bs[I] - 1;
      L13:
        Test(3 - I);
        Plant(0x5C, I, 3 - I);
        if (!Checksp) goto L15;
        Prx(0x8F, Bs[I], 0, 0, 32);
      L15:
        *Result = 257 + Bs[I] - Checksp;
        Register[Bs[I] + Checksp] = 0;
        Aflag = Checks;
        goto L99;
      L30:
        K = 3 - I;
        Load(K, -1, 0);
        Prr(0x1A, Bs[K], Bs[K]);
        Aflag = 1;
        *Result = 256 + Bs[K];
      L99:;
      }
      void Div(int *Result) {
        int I;
        int K;
        if (Dp[1] < 0) goto L3;
      L1:
        K = Findpr();
      L2:
        I = 1;
        Load(I, K, 0);
        goto L10;
      L3:
        if ((Bs[1] & 1) == 0 && Register[Bs[1] + 1] == 0) goto L4;
        K = Findpr();
        goto L2;
      L4:
        if (Register[Bs[1]] < 0) goto L1;
        Register[Bs[1] + 1] = 1;
        K = Bs[1];
      L10:
        Prx(0x8E, K, 0, 0, 32);
        Test(2);
        Plant(0x5D, 1, 2);
        if (!Checksp) goto L20;
        if (Opcode == 17) goto L20;
        Prr(0x12, K, K);
        Prx(0x47, 7, 0, Coder, 64);
      L20:
        Register[K] = 0;
        Aflag = 0;
        *Result = K + 257;
      }
      void Printorders(void) {
        static int S_sw;
        static void *S[50 /*0:49*/] = {
            &&S_0,       &&S_1,  &&S_2,  &&S_default, &&S_default, &&S_default, &&S_default, &&S_default,
            &&S_default, &&S_9,  &&S_10, &&S_11,      &&S_12,      &&S_13,      &&S_14,      &&S_15,
            &&S_16,      &&S_17, &&S_18, &&S_19,      &&S_20,      &&S_21,      &&S_22,      &&S_23,
            &&S_24,      &&S_25, &&S_26, &&S_27,      &&S_default, &&S_default, &&S_default, &&S_default,
            &&S_default, &&S_33, &&S_34, &&S_35,      &&S_36,      &&S_37,      &&S_38,      &&S_39,
            &&S_40,      &&S_41, &&S_42, &&S_43,      &&S_44,      &&S_45,      &&S_46,      &&S_47,
            &&S_48,      &&S_49,
        };
        int C;
        int D;
        int Last;
        int Kk;
        Last = N0 - 6;
        for (Jj = Nop; Jj <= Last; Jj += 3) {
          Opcode = St[Jj];
          if (10 >= Opcode || Opcode == 24) goto Skip;
          if (Opcode == 11 || Opcode == 23)
            Kk = 1;
          else
            Kk = 2;
          for (Kk = Kk; Kk >= 1; Kk--) {
            Pop(Ophead, C, Dp[Kk]);
            Pt[Kk] = (unsigned)C >> 8;
            Bs[Kk] = C & 15;
          }
        Skip:
          goto *S[S_sw = Opcode + 25 * Real];
        S_0:;
        S_25:;
          D = 0xFF00;
          C = St[Jj + 2];
          goto L99;
        S_1:;
          C = Sortconst(St[Jj + 1], 0, 1);
          D = 256 + Gla;
          goto L99;
        S_26:;
          D = 512 + Gla;
          if (Longreal == 1) D += 3 << 11;
          C = Sortconst(St[Jj + 1], Longreal, 2);
          goto L99;
        S_2:
        S_27:;
          D = St[Jj + 1];
          C = St[Jj + 2];
          goto L99;
        S_33:;
          D = St[Jj + 1];
          C = -2;
          goto L99;
        S_9:
        S_34:;
          D = 256 + St[Jj + 1];
          C = -2;
          goto L99;
        S_10:
        S_35:;
          C = St[Jj + 2];
          D = St[Jj + 1];
          if (Real == 1 && ((unsigned)D >> 8 & 24) == 24)
            Push(Lwsp[Level], 0, C);
          else
            Push(Wsp[Level], 0, C);
          goto L99;
        S_11:;
          if (Pt[1] != 255 || Dp[1] != 1) goto L109;
          Aflag = 0;
          D = 256 + Gla;
          C = 16;
          goto L99;
        S_36:;
        L109:
          C = 1;
          D = 0x13 + Real * (32 - Evaluate);
          Load(C, -1, Real);
          Aflag = 1;
          Prr(D, Bs[1], Bs[1]);
        L111:
          D = (Real + 1 + 24 * Longreal) << 8 | Bs[C];
          C = -2;
          goto L99;
        S_23:;
          C = 1;
          Aflag = 2;
          Load(C, -1, 0);
          Prx(0x57, Bs[1], 0, Gla, 16);
          goto L111;
        S_12:
        S_37:;
          Aflag = 1;
          D = 0x5A;
        L125:
          C = 0;
        L126:
          Load(C, -1, Real);
          Test(3 - C);
          D += Real * (0x20 - Evaluate);
          Plant(D, C, 3 - C);
          goto L111;
        S_13:
        S_38:;
          Aflag = 1;
          D = 0x5B;
          C = 1;
          if (Real != 0 || Pt[2] != 255 || 1 > Dp[2] || Dp[2] > 2) goto L126;
          Aflag = 0;
          Load(C, -1, 0);
          if (Dp[2] == 2) Prr(6, Bs[1], 0);
          Prr(6, Bs[1], 0);
          goto L111;
        S_14:
          D = 0x57;
        L141:
          Aflag = 2;
          goto L125;
        S_15:
          D = 0x56;
          goto L141;
        S_16:
          Mult(D);
          C = -2;
          goto L99;
        S_17:
        S_18:
          Div(D);
          C = -2;
          goto L99;
        S_19:
          D = 0x54;
          goto L141;
        S_20:
        S_21:;
          D = 0;
          C = 1;
          Load(C, -1, 0);
          if (Pt[2] == 255) D = 1;
          C = 2;
          if (!D) Load(C, -1, 0);
          Prx(0x89 + Opcode - 21, Bs[1], 0, Bs[2], D * Dp[2]);
          if (!D) Register[Bs[2]] = 0;
          C = 1;
          Aflag = 0;
          goto L111;
        S_22:
          for (C = 1; C <= 2; C++) {
            Load(C, -1, 0);
            Dump(1, Bs[C], 28 + 4 * C, 0, Gla);
            Register[Bs[C]] = 0;
          }
          if (Register[0]) goto L221;
          C = 2;
          Aflag = 0;
          Register[0] = 1;
          Ppj(15);
          Bs[2] = 0;
          goto L111;
        L221:
          C = Findr();
          D = Findr();
          Prr(0x18, C, 0);
          Ppj(15);
          Prr(0x18, D, 0);
          Prr(0x18, 0, C);
          Register[C] = 0;
          C = 2;
          Aflag = 0;
          Bs[2] = D;
          goto L111;
        S_39:
        S_40:
        S_42:
        S_44:
        S_45:
        S_46:
        S_48:;
          Fault(24);
          if (Opcode == 23)
            Opcode = 36;
          else
            Opcode = 37;
          goto *S[S_sw = Opcode];
        S_41:;
          D = 0x5C;
          C = 0;
        L410:
          Aflag = 0;
          goto L126;
        S_43:;
          D = 0x5D;
          C = 1;
          goto L410;
        S_47:;
          C = 1;
          Load(C, -1, 1);
          if (Pt[2] == 255 && Dp[2] == 2) goto L222;
          Prr(0x38 - Evaluate, 0, Bs[1]);
          C = 2;
          if (Pt[2] != 255 && (Pt[2] & 7) > 1) Fault(39);
          Load(C, 1, 0);
          Ppj(36);
          Register[1] = 0;
          Prr(0x38 - Evaluate, Bs[1], 0);
          C = 1;
          goto L111;
        L222:
          Prr(0x3C - Evaluate, Bs[1], Bs[1]);
          C = 1;
          goto L111;
        L99:
          if (Jj != Last) Push(Ophead, D, C);
        S_24:
        S_49:;
        }
        Dp[1] = C;
        Pt[1] = (unsigned)D >> 8;
        Bs[1] = D & 15;
        goto S_skip;
      S_default:
        fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw, __PRETTY_FUNCTION__);
        fflush(stderr);
        abort();
      S_skip:;
      }
    L99:;
    }
    int Sortconst(int P, int Long, int Type) {
      double Cvalue;
      int I;
      int K;
      if (Type == 2) goto L50;
      if (A[P] == 9)
        I = A[P + 1];
      else
        Fromar4(P + 1, I);
    L40:
      K = N0;
      St[K] = I;
      N0++;
      return (K << 2);
    L50:
      Cvalue = 0;
      if ((A[P] & 7) != 1) goto L60;
      if (A[P] == 9)
        I = A[P + 1];
      else
        Fromar4(P + 1, I);
      Cvalue = I;
      goto L70;
    L60:
      Fromar8(P + 1, Cvalue);
    L70:
      if (Long) goto L75;
      I = *Integer(Addr(Cvalue));
      goto L40;
    L75:
      K = (N0 + 1) & (-2);
      St[K] = *Integer(Addr(Cvalue));
      St[K + 1] = *Integer(Addr(Cvalue) + 4);
      N0 = K + 2;
      return (K << 2);
    }
    void Cstrexp(int Reg) {  //  EVALUATES STRING EXPR USING CURRENT
                             //  WORKAREA AND 1 SUBROUTINES LEAVES ADDR IN
                             //  REG -VE IF STRING MUST BE MOVED TO WK.ARREA
      int Jj;
      int Qq;
      int Kk;
      int Wkarea;
      int Pp;
      if (!Strinst) Setex();
      Pp = P;
      Jj = Tsexp(Qq);
      if (Jj == 20 && Reg >= 0) goto L71;
      P = Pp;
      Reg = abs(Reg);
      Wkarea = Getstrwsp();
      Psi(0x92, 0, Rbase, Wkarea);
      if (A[P] == 4) goto L2;
    L1:
      Fault(71);
    L4:
      P = Pp;
      Skipexp();
      goto L99;
    L5:
      Fault(72);
      goto L4;
    L2:
      if (A[P + 1] == 2) goto L10;
      if (A[P + 1] != 1) goto L1;
      P += 2;
      Cname(2, 1);
      if (Type != 5) goto L1;
      goto L20;
    L10:
      P += 2;
      if (A[P] == 5) goto L14;
      if (A[P] != 9 || A[P + 1] >= 127) goto L1;
      if (!A[P + 1]) goto L11;
      Prx(0x41, 1, 0, 0, A[P + 1]);
      P += 2;
      goto L20;
    L11:
      P += 2;
      goto L21;
    L14:  //  STRING CONSTANT PUT IN CODE CF (TEXTTEXT)
      Kk = (Ca + 6 + A[P + 1] - Codebase[Level]) & (-2);
      Qq = 0;
      if (Kk < 4095) goto L15;
      Kk += 4;
      Qq = 1;
      Prx(0x58, 1, Gla, 0, Pageno(Kk) << 2);
    L15:
      Prx(0x45, 1, 10, Qq, Kk & 4095);
      P++;
      for (Kk = 1; Kk <= (A[P] + 2) / 2; Kk++) {
        Plant(A[P] << 8 | A[P + 1]);
        P += 2;
      }
    L20:
      Prx(0x41, 2, Rbase, 0, Wkarea);
      Ppj(26);
    L21:
      if (A[P] == 2) goto L90;
      if (A[P + 1] != 12) goto L5;
      P++;
      goto L2;
    L71:
      Dump(2, Reg, K, I, 0);
      goto L99;
    L90:
      P++;
      Push(Strwsp[Level], 0, Wkarea);
      Prx(0x41, Reg, 0, Rbase, Wkarea);
    L99:
      Ptype = 5;
      Unpack();
    }
    void Cres(int Mode, int Lab) {
      auto void Skipname(void);
      auto void Fail(int Mask);
      int P1;
      int P2;
      int P3;
      int W;
      int Sexprn;  //  MODE=0 UNCONDITIONAL # 0 CONDITIONAL
                   //  ENTER WITH ADDR OF LHS IN R1 AND P ON PLUS''
      Sexprn = 0;
      W = Getdblewrd();
      P1 = P;
      if (A[P] == 4) goto L1;
    L1000:
      P = P1;
      Skipexp();
      Fault(74);
      goto L99;
    L1:
      if (Type != 5) goto L1000;
      Prr(0x1B, 2, 2);
      Prx(0x90, 1, 2, Rbase, W);
      P2 = -1;
      P += 2;
      if (A[P - 1] == 3) goto L10;
      if (A[P - 1] != 1) goto L1000;
    L3:
      P2 = P;
      Skipname();
      if (A[P] == 2) goto L50;
      if (A[P + 1] != 12) goto L1000;
      if (A[P + 2] != 3) goto L1000;
      P += 3;
    L10:
      Cstrexp(-4);
      Sexprn++;
      Prx(0x98, 1, 2, Rbase, W);
      Ppj(27);
      Fail(7);
      Prx(0x90, 1, 2, Rbase, W);
      if (P2 < 0) goto L15;
      P3 = P;
      P = P2;
      Cname(1, 4);
      if (Type != 5) Fault(71);
      P = P3;
    L12:
      if (A[P] != 1 || A[P + 1] != 12 || A[P + 2] != 1) goto L1000;
      P += 3;
      goto L3;
    L15:
      Psi(0x95, 0, 4, 0);
      Fail(7);
      goto L12;
    L50:
      if (!Sexprn) goto L1000;
      Prx(0x98, 1, 2, Rbase, W);
      Ppj(37);
      P3 = P;
      P = P2;
      Cname(1, 4);
      if (Type != 5) Fault(71);
      P = P3 + 1;
    L99:
      Push(Lwsp[Level], 0, W);
      return;
      void Skipname(void) {
      L1:
        P++;
        Skipapp();
        P++;
        if (A[P - 1] == 2) return;
        P++;
        goto L1;
      }
      void Fail(int Mask) {
        if (!Mode)
          Prx(0x47, Mask, 0, Coder, 152);
        else
          Plocaljump(Mask, Lab);
      }
    }
    void Ccond(int Iu, int Nearlab, int Farlab) {  //  IU=0 FOR IF =1 FOR UNLESS
      auto void Ccc(void);
      auto void Csc(int *Flab);  //   P ON ALT OF (SC)
      int T;
      int C;
      int Failpt;
      int Base;
      int Disp;
      int Jnporfp;
      int Tp;
      int Clauses;
      Clauses = 0;
      T = A[P + 1 + A[P + 1]];
      if (T == 3) T = 0;
      Tp = T;
      if (!T) Tp++;
      if (!(Iu ^ (Tp - 1)))
        Jnporfp = Farlab;
      else
        Jnporfp = Nearlab;
      Failpt = 0;
      Ccc();
      goto L99;
      void Ccomp(int C) {
        int M;
        int L;
        int Q;
        int R;
        int T;
        static unsigned char Fcomp[7 /*1:7*/] = {8, 10, 2, 7, 12, 4, 7};
        static unsigned char Bcomp[7 /*1:7*/] = {8, 12, 4, 7, 10, 2, 7};
        static int Sw_sw;
        static void *Sw[13 /*-10:2*/] = {
            &&Sw_M10, &&Sw_M9, &&Sw_default, &&Sw_default, &&Sw_default, &&Sw_M5, &&Sw_M4,
            &&Sw_M3,  &&Sw_M2, &&Sw_M1,      &&Sw_0,       &&Sw_1,       &&Sw_2,
        };
        M = A[P];
        P++;
        if (M != 8) goto *Sw[Sw_sw = (C) - -10];
        Fault(73);
        Skipexp();
        goto L1;
      Sw_M10:;
        Cstrexp(1);
        Nest = 1;
        Dump(2, 2, Disp, 0, Base);
        goto L161;
      Sw_M9:
        T = P;
        R = Tsexp(Q);
        if (R == 10 && A[P] == 2) goto Reg1;
        if (R == 11 && A[P] == 2) goto Reg2;
        P = T;
        Csexp(0, 0);
        if (Type == 2) goto Reg3;
        Prr(0x19, Disp, Nest);
        goto L20;
      Reg1:
        Q = 0x59;
        goto Rcom;
      Reg2:
        Q = 0x49;
      Rcom:
        Prx(Q, Disp, 0, I, K);
        goto L20;
      Reg3:
        Prr(0x18, 1, Disp);
        goto L37;
      Sw_M5:;
        Csexp(0, 3);
        Q = 0x69;
      L51:
        Prx(Q, Nest, 0, Base, Disp);
        goto L21;
      Sw_M4:;
        Q = 0x79;
        Csexp(0, 2);
      L40:
        if (!Prec) goto L51;
        Prr(0x2B, 0, 0);
        Prx(0x78, 0, 0, Base, Disp);
        Prr(0x29, 0, Nest);
        goto L20;
      Sw_M3:;
        Csexp(0, 0);
        if (!Value) goto L30;
        if (Type == 2) goto L36;
        R = 2;
        if (Nest == 2) R = 1;
        Dump(0, R, Value, 0, 0);
      L29:
        Prr(0x19, R, Nest);
        goto L20;
      L30:;
        if (Type == 5) goto L35;
        if (Aflag == 1) goto L32;
        if (Type == 2) goto L31;
        if (Aflag == 2 && 7 <= Fcomp[M] && Fcomp[M] <= 8) goto L32;
      L31:
        Prr((Type - 1) * (2 - (Prec & 1)) * 16 + 0x12, Nest, Nest);
      L32:
        if (C == -3) goto L21;
        goto L20;
      L35:
        Psi(0x95, 0, Nest, 0);
        goto L20;
      L36:
        Dump(0, 1, Value, 0, 0);
      L37:
        Ppj(43);
        Prr((1 - (Prec & 1)) * 16 + 0x29, 0, Nest);
        goto L20;
      Sw_M2:
        Q = 0x49;
      L24:
        Csexp(0, 0);
        if (Type == 2) goto L25;
        Prx(Q, Nest, 0, Base, Disp);
        goto L21;
      L25:
        R = 2;
        if (Q == 0x49) R = 6;
      L26:
        Dump(R, 1, Disp, 0, Base);
        goto L37;
      Sw_M1:;
        T = P;
        R = Tsexp(Q);
        L = 1;
        if (R == 11 && A[P] == 2) goto L18;
        if (R == 1 && A[P] == 2) goto L19;
        P = T;
        Csexp(0, 0);
        if (Type == 2) goto L14;
        R = 2;
        if (Nest == 2) R = 1;
        Dump(4, R, Disp, 0, Base);
        goto L29;
      L14:
        R = 4;
        goto L26;
      L18:
        Pss(0xD5, L, Base, Disp, I, K);
        goto L20;
      L19:
        Psi(0x95, Q, Base, Disp);
        goto L20;
      Sw_0:;
        T = P;
        R = Tsexp(Q);
        L = 4;
        if (R != 10 || A[P] != 2) goto Rstore;
        if (7 <= Fcomp[M] && Fcomp[M] <= 8) goto L18;
      Rstore:
        P = T;
        Q = 0x59;
        goto L24;
      Sw_1:;
      Sw_2:;
        T = P;
        Ptypep = Ptype;
        R = Tsexp(Value);
        Ptype = Ptypep;
        Unpack();
        if (R == 1 && Value == 0 && (A[P] == 2 || C == 2)) goto L30;
        if (Type == 5) goto L160;
        if (Type == 2) goto L150;
        if (R == 0 || 14 <= R && R <= 15 || (A[P] == 1 && C == 1)) goto L120;
        if (Unass == 1 || R == 100 || R == 11 || R <= 2) goto L130;
        if (R == 50) goto L131;
        Q = 0x59;
        if (R == 12) Q = 0x49;
        Prx(Q, Nest, 0, I, K);
        goto L20;
      L130:;
        R = Nest;
        if (!Register[R]) Register[R] = 1;
        P = T;
        Csexp(0, 1);
        if (Register[R] > 0) Register[R] = 0;
        goto L29;
      L131:
        Prr(0x19, Nest, K);
        goto L20;
      L120:;
        Q = Park(Nest);
        P = T;
        Csexp(0, 0);
        if (Type == 2) goto L122;
        Unpark(0x59, Nest, Q);
        goto L21;
      L122:
        Unpark(0x58, 1, Q);
        goto L37;
      L150:
        P = T;
        Q = Parkf(Nest, Prec);
        if (!Prec) goto L155;
        Csexp(0, 3);
        Push(Lwsp[Level], 0, Q);
        Base = Rbase;
        Disp = Q;
        Q = 0x69;
        goto L51;
      L155:
        Csexp(0, 2);
        Push(Wsp[Level], 0, Q);
        Base = Rbase;
        Disp = Q;
        Q = 0x79;
        goto L40;
      L160:  //  1ST OPERAND A STRING EXPRESSION PTR IN Nest
        P = T;
        Pop(Strwsp[Level], R, T);
        R = Park(Nest);
        Cstrexp(1);
        Nest = 1;
        Unpark(0x58, 2, R);
        Push(Strwsp[Level], 0, T);
      L161:
        if (7 > Fcomp[M] || Fcomp[M] > 8) goto L162;
        Prx(0x43, 3, 0, 1, 0);
        Prx(0x44, 3, 0, Gla, Strinst + 6);
        goto L20;
      L162:
        Ppj(35);
      L20:
        Mask = Fcomp[M];
        goto L1;
      L21:
        Mask = Bcomp[M];
      L1:;
        goto Sw_skip;
      Sw_default:
        fprintf(stderr, "\nSwitch label 'Sw(%d):' not set in %s\n", Sw_sw + -10, __PRETTY_FUNCTION__);
        fflush(stderr);
        abort();
      Sw_skip:;
      }
      void Ccc(void) {
        int Line;
        int Flab;
        Csc(Flab);
        C = A[P];
        P++;
        Clauses++;
        if (T == 0 || (Clauses > 1 && C == 2)) goto L10;
        if (Failpt) goto L2;
        Failpt = 1;
        Line = 1;
        goto L3;
      L2:
        Line = 0;
      L3:;
        Plocaljump(Mask, Jnporfp);
        if (Flab) {
          Push(Locallabel, Ca, Flab);
          if (R13 != Save13 || Chnge13 != 0) R13 = 0;
        }
        Ccc();
        if (!Line) goto L10;
        if (Jnporfp == Nearlab) Mask = Mask ^ 15;
      L10:;
      }
      void Csc(int *Flab) {
        int Line;
        int Q;
        int R;
        int S;
        int Tp;
        int Near;
        *Flab = 0;
        S = A[P + 1 + A[P + 1]];
        Line = S;
        Near = Nearlab;
        if (T == 0 || (S == 2 && Clauses > 0)) goto Start;
        Plabel--;
        Near = Plabel;
      Start:
        if (A[P] == 1) goto L1;
        P += 2;
        if (!T) goto Redund;
        if (T == A[P + 1 + A[P + 1]]) goto Redund2;
        if (Near != Nearlab) *Flab = Near;
        Tp = T - 1;
        if (Near == Nearlab) goto Last;
        Ccond(Tp, Near, Farlab);
        goto L9;
      Redund:
        Ccond(Iu, Nearlab, Farlab);
        goto L9;
      Redund2:
        Ccond(Iu, Nearlab, Farlab);
        if (Jnporfp == Nearlab) Mask = Mask ^ 15;
        goto L9;
      Last:
        Ccond(Iu, Near, Farlab);
        Nearlab = 0;
        goto L9;
      L1:  //  CLASSIFY SIMPLE CONDITION AND ACT ACCORDINGLY
        P += 2;
        S = P;
        Skipexp();
        if (A[P] == 8) goto L21;
        P++;
        Q = Tsexp(R);
        if (Type == 3) {
          P += 2;
          R = Copyrecordtag();
        }
        if (Type == 5) goto Str;
        if (Q == 1 && R == 0 && A[P] == 2) goto Zero;
        P = S;
        Q = Tsexp(R);
        if (1 <= Q && Q <= 2) goto Const;
        if (Q == 20) goto Simple;
        if (Q == 50) goto Regvar;
        if (Type == 5) goto Str;
        if (Unass != 0 || 10 > Q || Q > 15) goto Normal;
      Simple:
        Base = I;
        Disp = K;
        Ccomp(10 - Q);
        goto L8;
      Regvar:
        Disp = K;
        Ccomp(-9);
        goto L8;
      Str:
        P = S;
        Cstrexp(1);
        Nest = 1;
        Ccomp(1);
        goto L8;
      Const:
        Value = R;
        Ccomp(-3);
        goto L8;
      L21:
        P = S + 2;
        if (A[S] != 4 || A[S + 1] != 1) goto L22;
        Cname(2, 1);
        if (A[P] == 2 && Type == 5) goto L23;
      L22:
        P = S;
        Skipexp();
      L28:
        P++;
        Skipexp();
        Fault(73);
        goto L8;
      L23:
        P += 2;
        if (Near != Nearlab) *Flab = Near;
        if (T != 2)
          R = Jnporfp;
        else if (Jnporfp != Farlab && Line == 2 && Clauses > 0)
          R = Farlab;
        else
          R = Near;
        Cres(1, R);
        if (A[P] != 2) goto L28;
        P++;
        Mask = 15;
        goto L10;
      Zero:
        P = S;
        Q = Tsexp(R);
        if (Q == 11) goto Simple;
        if (Type == 5) goto Str;
      Normal:
        P = S;
        Csexp(0, 0);
        Ccomp(1);
      L8:
        P++;
        if (A[P - 1] == 2) goto L10;
        if (Near != Nearlab) *Flab = Near;
        if (T == 2) goto Orcond;
        R = Jnporfp;
        goto L7;
      Orcond:
        if (Jnporfp != Farlab && Line == 2 && Clauses > 0)
          R = Farlab;
        else
          R = Near;  //  LAST DOUBLESIDED IN OR CONDITION IS SPECIAL
      L7:;
        Plocaljump(Mask ^ 15, R);
        Ccomp(2);
      L10:
        if (T == 1 || (T == 0 && Iu == 0)) Mask = Mask ^ 15;
      L9:;
      }
    L99:;
    }
    void Filllocaljumps(void) {
      int T;
      int C;
      int J;
    L1:
      Pop(Localjump, T, C);
      if (T == -1) goto L98;
      J = Find(C, Locallabel);
      if (J == -1) Fault(233);
      J -= Localaddr;
      Plug(T + 2, J);
      goto L1;
    L98:
      Clearlist(Locallabel);
    }
    void Plocaljump(int Mask, int Label) {
      if (!Mask) return;
      if (Save13 != R13) Chnge13 = 1;
      if (Label > 21000) goto L1;
      Pj(Mask, Label);
      goto L99;
    L1:
      if (Localbase) goto L2;
      Localbase = 10;
      Localaddr = Codebase[Level];
      if (Sbflag == 1 || 3000 + 800 * Compiler > Ca - Codebase[Level]) goto L2;
      Localbase = Findpp();
      if (Localbase <= 0) Fault(231);
      Prr(5, Localbase, 0);
      Localaddr = Ca;
    L2:
      Push(Localjump, Ca, Label);
      Prx(0x47, Mask, Localbase, 0, 0);
    L99:;
    }
    void Csname(int Z, int Reg) {
      int B[6 /*0:5*/];
      static unsigned char Plabel[46 /*0:45*/] = {9,
                                                  9,
                                                  3,
                                                  3,
                                                  1,
                                                  [5 ... 7] = 14,
                                                  2,
                                                  3,
                                                  1,
                                                  18,
                                                  4,
                                                  3,
                                                  [14 ... 15] = 12,
                                                  33,
                                                  42,
                                                  34,
                                                  35,
                                                  32,
                                                  [21 ... 36] = 12,
                                                  5,
                                                  [38 ... 45] = 12};
      static unsigned char Mode[46 /*0:45*/] = {[0 ... 1] = 16,
                                                [2 ... 4] = 0,
                                                [5 ... 7] = 16,
                                                2,
                                                [9 ... 10] = 16,
                                                31,
                                                32,
                                                0,
                                                18,
                                                31,
                                                [16 ... 18] = 18,
                                                63,
                                                47,
                                                [21 ... 22] = 23,
                                                18,
                                                [24 ... 30] = 31,
                                                31,
                                                [32 ... 33] = 23,
                                                [34 ... 35] = 47,
                                                18,
                                                16,
                                                2,
                                                23,
                                                [40 ... 41] = 16,
                                                23,
                                                [43 ... 45] = 0};
      static int Sw_sw;
      static void *Sw[46 /*0:45*/] = {
          &&Sw_0,  &&Sw_1,  &&Sw_2,  &&Sw_3,       &&Sw_4,       &&Sw_5,       &&Sw_6,  &&Sw_7,  &&Sw_8,  &&Sw_9,
          &&Sw_10, &&Sw_11, &&Sw_12, &&Sw_13,      &&Sw_14,      &&Sw_default, &&Sw_16, &&Sw_17, &&Sw_18, &&Sw_19,
          &&Sw_20, &&Sw_21, &&Sw_22, &&Sw_23,      &&Sw_default, &&Sw_25,      &&Sw_26, &&Sw_27, &&Sw_28, &&Sw_29,
          &&Sw_30, &&Sw_31, &&Sw_32, &&Sw_33,      &&Sw_34,      &&Sw_35,      &&Sw_36, &&Sw_37, &&Sw_38, &&Sw_39,
          &&Sw_40, &&Sw_41, &&Sw_42, &&Sw_default, &&Sw_default, &&Sw_default,
      };
      int Pl;
      int Kk;
      int Pp;
      int V;
      int Jj;
      Kk = K;
      Jj = Countaps();
      Pl = Plabel[Kk];
      Pp = P + 1;
      V = Mode[K];
      P++;
      if ((unsigned)V >> 4) P++;
      if ((V & 15) == 15) goto L1010;
      if ((unsigned)V >> 4 != Jj) goto L1001;
      V = V & 15;
      if (V == 0 && Z != 0) goto L1002;
      if (V == 2 && Z != 2) goto L1003;
      if (Z == 0 && V != 0) goto L1005;
    L1010:
      goto *Sw[Sw_sw = Kk];
    L1001:
      Fault(19);
      Printname(Fname);
    L1000:
      P = Pp;
      Skipapp();
      P--;
      goto L99;
    L1002:
      Fault(23);
      goto L1000;
    L1003:
      Fault(29);
      goto L1000;
    L1004:
      Fault(22);
      goto L1000;
    L1005:
      Fault(17);
      goto L1000;
    L1:
      Ppj(Pl);
      goto L99;
    Sw_4:
      Ciocp(1);
      goto L99;
    Sw_2:
      V = 10;
      Prx(0x41, 1, 0, 0, V);
    L23:
      Ciocp(3);
      goto L99;
    L21:
      Prx(0x41, 1, 0, 0, V);
      goto L1;
    Sw_3:
      V = 32;
      goto L21;
    Sw_5:
      V = 0;
    L51:
      Csexp(2, 1);
      goto L21;
    Sw_6:
      V = 10;
      goto L51;
    Sw_7:
      V = 32;
      goto L51;
    Sw_0:
    Sw_1:;
      Csexp(1, 1);
      Ciocp(Kk + 8);
      goto L99;
    Sw_9:;
      Csexp(1, 1);
      goto L23;
    Sw_8:
      Ciocp(2);
    L81:
      if (Reg != 1) Prr(0x18, Reg, 1);
    L82:
      Ptype = 10001;
      Unpack();
      goto L99;
    Sw_10:
      Ciocp(1);
    L106:
      if (A[P] != 4 || A[P + 1] != 1) goto L1004;
      P += 2;
      Copytag(A[P]);
      Unpack();
      if (Type != 1 || Arr != 0 || Rout != 0) goto L104;
      Cname(1, 1);
    L102:
      if (A[P] != 2) goto L1004;
      P++;
      goto L99;
    L104:
      Plant(0x1841);
      Register[4] = 1;
      Cname(1, 4);
      Register[4] = 0;
      if (Type != 1) goto L1004;
      goto L102;
    Sw_11:;
      B[0] = 1;
      B[1] = 1000;
    L110:
      Jj = 10000;
      if (0 != Z && Z != 13) goto L1004;
      goto L302;
    Sw_12:;
      Csexp(1, 1);
      P++;
      Jj = P;
      V = Tsexp(Kk);
      if (V) goto L121;
      V = Park(1);
      Csexp(2, 1);
      Unpark(0x58, 1, V);
    L120:
      Ppj(Pl);
      goto L99;
    L121:
      P = Jj;
      Register[1] = 1;
      Csexp(2, 1);
      Register[1] = 0;
      goto L120;
    Sw_13:;
      Prx(0x41, 1, 0, 0, 12);
      Ciocp(5);
      goto L99;
    Sw_14:
      if (A[P] != 4 || A[P + 1] != 1) goto L1004;
      P += 2;
      Cname(3, Reg);
      if (A[P] != 2) goto L1004;
      P++;
      goto L82;
    Sw_16:;
    Sw_17:;
      Csexp(0, 3);
      if (Nest) Prr(0x28, 0, Nest);
      Ppj(Pl);
      goto L81;
    Sw_18:
      Csexp(6, 3);
      Pclod(32);
      if (Reg != 2) Prr(0x28, Reg, 2);
      Ptype = 10032;
      Unpack();
      goto L99;
    Sw_19:;
      B[0] = 3;
      B[3] = 1;
    L191:
      B[1] = 32;
      B[2] = 1;
      goto L110;
    Sw_20:;
      Qpreal = (N0 << 2) + 4;
      B[0] = 2;
      goto L191;
    Sw_39:
      Jj = 11032;
      goto L210;
    Sw_21:
      Jj = 11002;
    L210:
      Csexp(0, 1);
      P++;
      if (Nest) goto L212;
      Plant(0x1810);
      Nest = 1;
    L212:
      Ptype = Jj;
      Unpack();
      goto L99;
    Sw_22:
      Jj = 11001;
      goto L210;
    Sw_23:
      Csexp(Reg, 3);
      Prr(0x20, Reg, Reg);
      goto L99;
    Sw_25:
    Sw_26:
    Sw_27:;
    Sw_28:
    Sw_29:
    Sw_30:;
      B[0] = 1;
    L301:
      B[1] = 32;
      Jj = 10032;
      if (2 != Z && Z != 13) goto L1004;
    L302:
      Redefineep(Jj, B);
      Cname(Z, Reg);
      P -= 2;
      goto L99;
    Sw_31:;
      Csexp(Reg, 1);
      if (Z != 15) Fault(84);
      Ptype = 3;
      Unpack();
      goto L99;
    Sw_32:
      Jj = 11011;
      goto L210;
    Sw_33:
      Jj = 11021;
      goto L210;
    Sw_34:
    Sw_35:;
      B[0] = 2;
      B[2] = 32;
      goto L301;
    Sw_36:;
      Csexp(Reg, 1);
      Prx(0x89, Reg, 0, 0, 31);
      Prx(0x8A, Reg, 0, 0, 30);
      Prx(0x5B, Reg, 0, Gla, 16);
      goto L99;
    Sw_37:
      Cstrexp(1);
      Ciocp(7);
      goto L99;
    Sw_38:
      Prx(0x41, Reg, 0, 0, 10);
      goto L82;
    Sw_40:;
      Csexp(1, 1);
      Ciocp(5);
      goto L99;
    Sw_41:;
      Ciocp(4);
      goto L106;
    Sw_42:
      Jj = 11005;
      goto L210;
    L99:;
      goto Sw_skip;
    Sw_default:
      fprintf(stderr, "\nSwitch label 'Sw(%d):' not set in %s\n", Sw_sw, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    Sw_skip:;
    }
    void Ciocp(int N) {
      Prx(0x41, 0, 0, 0, N);
      Prx(0x90, 4, 1, 11, 16);
      Prx(0x98, 12, 14, Gla, 140);
      Prr(0x05, 15, 14);
      R13 = 0;
    }
    void Caname(int Z, int Bs, int Dp, int Clink, int Bsrf, int Dprf) {
      static int S_sw;
      static void *S[4 /*0:3*/] = {
          &&S_0,
          &&S_1,
          &&S_2,
          &&S_3,
      };
      int Ptypep;
      int Kk;
      int Rr;
      int Pp;
      int Jj;
      int Jjj;
      int Kkk;
      int Dis;
      int Q;
      int Precp;
      int Checksp;
      int Basereg;
      int Arrp;
      int Basicdisp;
      Checksp = Checks;
      if (!Type) Checksp = 1;
      Pp = P;
      Basereg = Link;
      if (Inreg) {
        if (Type) Checksp = 0;
        Basereg = Inreg;
      }
      Jj = J;
      Ptypep = Ptype;
      Arrp = Arr;
      Q = Countaps();
      if (Jj) goto L1;
      From1(Clink, Jj);
      Replace1(Clink, Jj | Q);
      Jj = Q;
    L1:
      if (Jj == Q && Q != 0) goto L4;
      Fault(19);
      Printname(Fname);
      P++;
      Skipapp();
      goto L99;
    L4:;
      if (Arrp == 2) Fromlist(K, Basicdisp, Dp);
      if (Checksp != 0 || Jj != 1 || Z == 3) goto L12;
      if (2 < Type) goto L12;
      Precp = Prec;
      Kkk = 0;
      P = Pp + 2;
      Jjj = Tsexp(Kkk);
      if (3 <= Jjj && Jjj <= 99)
        Dis = 0;
      else
        Dis = Kkk * Bytes[Precp];
      if (Dis > 4095 || (Arrp == 2 && Dis + Basicdisp > 4095)) goto L12;
      if (Jjj == 50 && Precp == 1) goto Regvar;
      if (Jjj == 101) goto Rdisp;
      if (1 <= Jjj && Jjj <= 2) goto Const;
      if (Jjj != 100) goto L12;
      Dump(2 + 2 * Prec, 1, K, 0, I);
      P++;
      goto L9;
    Regvar:
      Jjj = K;
      P++;
      goto L8;
    Rdisp:
      if (Precp == 1) goto Regvar;
      Prr(0x18, 1, K);
      P++;
      goto L9;
    L12:
      P = Pp + 2;
      Dis = 0;
      if (Jj != 1) goto L21;
      Csexp(1, 1);
      P++;
      if (Checksp == 1) goto L10;
    L9:
      Jjj = 1;
    L8:
      if (Basereg != Link) goto L5;
      if (Arrp == 2) goto Vector;
      Rp13 = R13;
      R13 = Bs << 12 | Dp;
      if (R13 != Rp13) Prx(0x58, Link, 0, Bs, Dp);
      goto L5;
    Vector:
      Dis += Basicdisp;
      Basereg = Bs;
    L5:
      Ptype = Ptypep;
      Unpack();
      if (!Jjj) goto L6;
      if (Type == 5) goto Str;
      if (Type != 3) goto *S[S_sw = Prec];
    L3:
      Prx(0x4C, 1, 0, Bsrf, Dprf);
      goto L6;
    Str:
      Prx(0x58, 2, 0, Bs, Dp + 8);
      Bsrf = 2;
      Dprf = 2;
      goto L3;
    S_3:;
    S_0:;
      Pconst(0x89100002 | Prec);
      goto L6;
    S_2:;
      Plant(0x1A11);
    S_1:
    L6:
      Disp = Dis;
      Index = Jjj;
      Base = Basereg;
      goto L99;
    Const:
      Jjj = 0;
      P++;
      goto L8;
    L10:;
      Dump(0, 3, Dp, 0, Bs);
      Ppj(22 + Jj);
      Jjj = 1;
    L11:
      Ptype = Ptypep;
      Unpack();
      goto L6;
    L21:;
      if (Jj != 2 || Checksp != 0) goto L31;
      Csexp(2, 1);
      Jjj = 2;
      P++;
      Kk = P;
      Q = Tsexp(Pp);
      P = Kk;
      if (Q) goto L22;
      Jjj = Park(2);
    L22:
      Csexp(1, 1);
      P++;
      Prx(0x4C, 1, 0, Bs, Dp + 14);
      Unpark(0x5A, 1, Jjj);
      goto L9;
    L31:;
      Rr = Getarrwsp();
      for (Pp = 0; Pp <= Jj - 1; Pp++) {
        Csexp(0, 1);
        P++;
        Dump(1, Nest, Rr + (Pp << 2), 0, Rbase);
      }
      Dump(0, 1, Rr + (Pp << 2), 0, Rbase);
      Dump(0, 2, Dp, 0, Bs);
      Ppj(24);
      Jjj = 1;
      Push(Mdarr[Level], 0, Rr);
      goto L11;
    L99:
      J = Jj;
    }
    void Cename(int Z, int Mode, int Bs, int Dp) {  //  MODE=0 POINTER TO RECORD IN CORE AT BS & Dp
                                                    //  MODE=1 POINTER TO RECORD IN REGISTER BS DP RUBBISH
                                                    //  MODE=2 RECORD REG CLAIMED
      int Q;
      int Qqq;
      int Bsrf;
      int Dprf;
      if (A[P] == 1) goto L2;
      if (Z >= 14) goto L1;
      Fault(64);
      P -= 2;
      Ptype = 1;
      Unpack();
      goto L99;
    L1:
      Base = Bs;
      Disp = Dp;
      if (Mode) Disp = -1;
      Index = 0;
      goto L99;
    L2:
      P++;
      Q = Displacement(Fname);
      Unpack();
      if (Q == -1) goto L98;
      if (Type == 3) goto L50;
      if (Arr == 1) goto L20;
      if (Type == 5) goto L30;
      if (Mode) goto L11;
      Rp13 = R13;
      R13 = Bs << 12 | Dp;
      if (R13 != Rp13) Prx(0x58, Link, 0, Bs, Dp);
      Base = Link;
    L7:
      Index = 0;
      Disp = Q;
      if (Rout == 1) From1(Q, Disp);
      goto L99;
    L11:
      Base = Bs;
      goto L7;
    L20:;
      Fromlist(Fname, Bsrf, Qqq);
      Bsrf = (unsigned)Bsrf >> 4 & 15;
      From1(Qqq, Dprf);
      if (Z < 10 || A[P + 1] == 1) goto L21;
      K = Dprf + Q;
      I = Bsrf;
      if (!Mode) Dump(2, 1, Dp, 0, Bs);
      goto L99;
    L21:
      if (Mode != 0 || Bs >= 4) goto L22;
      Dump(2, 1, Dp, 0, Bs);
      Mode = 1;
      Bs = 1;
    L22:
      if (Mode == 1) Qqq = Park(1);
      Caname(3, Bsrf, Dprf + Q, K, 0, 0);
      R13 = 0;
      if (!Mode) Prx(0x5A, Index, Bs, 0, Dp);
      if (Mode == 1) Unpark(0x5A, Index, Qqq);
      if (Mode == 2) Prr(0x1A, Index, Bs);
      I = Bsrf;
      K = Dprf + Q;
      goto L99;
    L30:
      Fromlist(Fname, Bsrf, Qqq);
      From1(Qqq, Dprf);
      Bsrf = (unsigned)Bsrf >> 4 & 15;
      if (Mode != 0 && Bs != 1) Prr(0x18, 1, Bs);
      if (!Mode) Prx(0x58, 1, Bs, 0, Dp);
      Prx(0x5A, 1, Bsrf, 0, Dprf + Q);
      Base = 1;
      Index = 0;
      Disp = 0;
      I = Bsrf;
      K = Dprf + Q;
      goto L99;
    L50:;
      if (!Mode) Dump(2, 1, Dp, 0, Bs);
      if (Mode) Prr(0x18, 1, Bs);
      From2(Q, Qqq);
      Crname(Z, 1, K, 1, Qqq);
      goto L99;
    L98:
      P++;
      Skipapp();
      P -= 2;
    L99:;
    }
    void Crname(int Z, int Mode, int Clink, int Bs,
                int Dp) {  //  DEALS WITH RECORD NAME CALLING CENAME TO COMPILE SUBFIELDS
                           //  MODE=0 POINTER TO RECORD IN CORE AT BS & Dp
                           //  MODE=1 POINTER TO RECORD IN REGISTER BS DP RUBBISH
                           //  CLINK POINTS TO CELL CONTAING NAME DETAILS
      int Kk;
      int Jj;
      int Q;
      int Qq;
      From2(Clink, Q);
      From1(Q, Fname);
      if (!Arr) goto L50;
      I = Bs;
      K = Dp;
      if (11 <= Z && Z <= 12 && A[P + 1] == 2) goto L99;
      Fromlist(Fname, Kk, Jj);
      Kk = (unsigned)Kk >> 4 & 15;
      From1(Jj, Jj);
      if (Mode == 2) Prr(0x1A, Index, Bs);
      if (Mode != 0 || Bs >= 4) goto L3;
      Dump(2, 1, Dp, 0, Bs);
      Mode = 1;
      Bs = 1;
    L3:;
      Qq = Bs;
      if (Mode == 1) Qq = Park(Bs);
      Caname(Z, Qq, Dp, Clink, Kk, Jj + 2);
      From1(Q, Fname);
      if (Mode == 1) Register[Qq] = 0;
      Prr(0x1A, 1, Link);
      Cename(Z, 1, 1, 0);
      goto L99;
    L50:
      P++;
      if (A[P] == 2) goto L51;
      Fault(19);
      Skipapp();
    L51:
      P++;
      if (Inreg == 0 || Z == 14)
        Cename(Z, 0, Bs, Dp);
      else
        Cename(Z, 2, Inreg, 0);
    L99:;
    }
    void Cname(int Z, int Reg) {
      int Jj;
      int Jjj;
      int Kk;
      int Rr;
      int Ptypep;
      int Levelp;
      int Dispp;  //  Z=0-RTCALL, Z=1 STORE(=), Z=2 FETCH, Z=3 FETCH ADDR, Z=4 STORE(<-), Z=6 STORE PTR, Z=12 FETCH ARRAYHEAD, Z=11 STORE ARRAY Head
      static int S_sw;
      static void *S[6 /*10:15*/] = {
          &&S_default, &&S_11, &&S_12, &&S_13, &&S_14, &&S_15,
      };
      static int Funny_sw;
      static void *Funny[6 /*10:15*/] = {
          &&Funny_default, &&Funny_11, &&Funny_12, &&Funny_13, &&Funny_14, &&Funny_15,
      };
      static int Sw_sw;
      static void *Sw[9 /*0:8*/] = {
          &&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6, &&Sw_7, &&Sw_8,
      };
      static int Mod_sw;
      static void *Mod[32 /*0:31*/] = {
          &&Mod_0,  &&Mod_1,  &&Mod_2,  &&Mod_3,  &&Mod_4,  &&Mod_5,  &&Mod_6,  &&Mod_7,  &&Mod_8,  &&Mod_9,  &&Mod_10,
          &&Mod_11, &&Mod_12, &&Mod_13, &&Mod_14, &&Mod_15, &&Mod_16, &&Mod_17, &&Mod_18, &&Mod_19, &&Mod_20, &&Mod_21,
          &&Mod_22, &&Mod_23, &&Mod_24, &&Mod_25, &&Mod_26, &&Mod_27, &&Mod_28, &&Mod_29, &&Mod_30, &&Mod_31,
      };
      Fname = A[P];
      Copytag(Fname);
      if (I != -1) goto L3;
      I = Level;
      J = 0;
      K = Fname;
      Ptype = 7;
      Storetag(K, N);
      K = N;
      N += 4;
      Unpack();
    L3:
      Jj = J;
      if (Jj == 15) Jj = 0;
      Levelp = I;
      Dispp = K;
      if (Type == 7) goto L502;
      if (Z == 0 && (Rout != 1 || 0 != Type && Type != 6)) goto L500;
      if (Z >= 10) goto *Funny[Funny_sw = (Z)-10];
      if (Rout == 1) goto L501;
      goto *Sw[Sw_sw = Type];
    L500:
      if (Type == 3) goto *Sw[Sw_sw = 3];
      if (Type != 7) Fault(17);
      goto L502;
    Sw_6:
      if (Z != 3 || Arr != 1) goto L661;
      K = K << 2;
      Arr = 0;
      I = 10;
      goto L600;
    Sw_4:;
    L661:
      Fault(20);
    Sw_7:
    L502:
      P++;
      Ptype = 1;
      Unpack();
      if (A[P] == 2) goto L6;
      goto L102;
    Funny_11:
      if (Type == 3) goto L1011;
      if (Arr != 1 || Nam != 1 || (unsigned)K >> 12 != 0) Fault(17);
      Prx(0x90, 0, 3, I, K);
      goto L91;
    L1011:
      Pclod(44);
      goto *Sw[Sw_sw = 3];
    S_11:
      Mover(Wspr, -16);
      Pss(0xD2, 16, 1, 0, Wspr, 0);
      goto L91;
    Funny_12:
      if (Type == 3) goto *Sw[Sw_sw = 3];
      if (Arr == 2) goto L1202;
      if (Arr != 1) Fault(17);
    L1201:
      Prx(0x98, 0, 3, I, K & 4095);
      goto L91;
    L1202:
      From2(K, K);
      goto L1201;
    S_12:
      if (Type == 3 && Arr == 1) goto L1201;
      Prr(0x18, 0, 1);
      Prx(0x5A, 0, 0, I, K);
      Prx(0x5A, 1, 0, I, K + 4);
      Prx(0x98, 2, 3, I, K + 8);
      goto L91;
    Funny_13:;
      if (Type == 3) goto *Sw[Sw_sw = 3];
      if (Ptype == 10006) goto L1302;
      if (Rout == 1 && (Nam & 1) == 1) goto L1301;
      Base = Gla;
      From1(K, Disp);
      Index = 0;
      Disp = Ra[Disp];
      if (J == 14) Disp += 4;
    L1300:
      if (Rout != 1) goto L500;
      goto L91;
    L1301:
      Base = I;
      From1(K, Disp);
      Index = 0;
      goto L91;
    L1302:
      Csname(Z, Reg);
      goto L6;
    S_13:
      From2(K, K);
      goto L1300;
    Funny_15:;
      if (Ptype == 10006) goto L1501;
    Funny_14:;
      Rr = 0;
      if (Arr == 0 && Inreg != 0 && A[P + 1] == 2 && 2 == A[P + 2]) Rr = Inreg;
      if (Type == 3) goto *Sw[Sw_sw = 3];
      goto L661;
    S_14:
      if (Type != 3 || Nam != 1) Fault(20);
      if (Reg != Rr && Rr != 0) Prr(0x18, Rr, Reg);
      if (Disp < 0) Disp = 0;
      if (R13 == (Base << 12 | Disp)) R13 = 0;
    L1401:
      Dump(Z - 13, Reg, Disp, Index, Base);
      P++;
      goto L9005;
    S_15:
      if (Type != 3) goto L661;
      if (Disp >= 0) goto L1401;
      Dump(0, Reg, 0, Index, Base);
      P++;
      goto L9005;
    L1501:
      Csname(Z, Reg);
      if (A[P] != 2 || A[P + 1] != 2) Fault(22);
      P += 2;
      goto L9005;
    Sw_3:;
      From2(K, Jjj);
      Crname(Z, 0, Tags[A[P]], I, Jjj);
      if (Z >= 10) goto *S[S_sw = (Z)-10];
      if (Type == 5) goto L5020;
      if (Z) goto L601;
      if (Rout != 1 || Nam != 1) goto L500;
      Levelp = Park(Base);
      Rr = Disp;
      Ptypep = Ptype;
      From2(K, Jj);
      From2(Jj, K);
      goto L22;
    Sw_5:;
      Base = I;
      Index = 0;
      Disp = K;
      Jjj = 2;
      if (Arr != 1) goto L5000;
      Caname(Z, I, K, Tags[Fname], 0, 0);
    L4998:
      Nam = (unsigned)Nam >> 1;
      Jjj = 0;
      if (Z != 3) goto L5000;
      Dump(0, Reg, Disp, Index, Base);
      if (Checks) Prx(0x58, 2, 0, Levelp, Dispp + 8);
      Paclod(10, 6, Reg << 4);
      goto L9;
      //  L 2,LMAX. BCTR 2,0. SLL 2,24. OR REG,2
    L5000:
      if (2 <= Z && Z <= 3) goto L605;
      if (Reg != 4) Prr(0x18, 4, Reg);
      Dump(Jjj, 1, Disp, Index, Base);
      if (!Arr) goto L5001;
      if (Z == 4 || Checks != 0) Prx(0x58, 2, 0, Levelp, Dispp + 8);
      I = 2;
      K = 3;
    L5001:
      Storestring(Z, 4, 1, I, K);
      goto L9;
    L5020:;
      if (Arr == 1) goto L5025;
      if (2 <= Z && Z <= 3) goto L9;
      if (Reg != 4) Prr(0x18, 4, Reg);
      goto L5001;
    L5025:;
      Levelp = I;
      Dispp = K;
      goto L4998;
    Sw_8:;
      if ((1 > Z || Z > 2) && Z != 4) Fault(29);
      if (K == Reg) goto L9;
      if (Z == 2)
        Prr(0x18, Reg, K);
      else
        Prr(0x18, K, Reg);
      goto L9;
    Sw_0:
      if (Z != 3 && Z <= 10) {
        Fault(12);
        Type = 1;
        Ptype++;
      }
    Sw_2:;
    Sw_1:
      if (!Arr) goto L600;
      Caname(Z, I, K, Tags[Fname], 0, 0);
      if (!Type) Type = 1;
      Nam = (unsigned)Nam >> 1;
      goto L601;
    L501:
      if (Z == 0 || Ptype != 10000) goto L503;
      Fault(23);
      Printname(A[P]);
      goto L503;
    L503:
      Ptypep = Ptype;
      if (Ptype != 10006) goto L20;
      Csname(Z, Reg);
      if (Rout == 1 && Nam >= 1 && Z != 0) goto L202;
      goto L6;
    L20:
      Kk = K;
      Fromlist(Kk, Rr, K);
    L22:
      if (K != 1000) goto L21;
      Fault(21);
      goto L502;
    L21:
      Crcall(Kk);
      Ptype = Ptypep;
      Unpack();
      if ((Nam & 1) == 1) goto L37;
      if (Jj == 14) goto L36;
      Dump(2, 1, Ra[Rr], 0, Gla);
      Prx(0x45, Link, 0, Gla, 116);
    L371:
      Mone = 1;
      R13 = 0;
      P++;
      if (Ptype == 10000 || Ptype == 11000) goto L1;
      if (Nam > 1) goto L201;
      if (Z != 2) Fault(29);
      if (Type == 2) goto L43;
    L44:
      if (Reg != 1) Prr(0x18, Reg, 1);
      goto L1;
    L43:
      if (Reg != 2) Prr(0x28, Reg, 2);
      goto L1;
    L36:;
      Paclod(55, 4, Ra[Rr] + 4);
      goto L371;
    L37:;
      if (Levelp < Rbase) Register[Levelp] = 0;
      Paclod(61, 4, Levelp << 12 | Rr);  //  STM 4,14,?--LM 12,15 ? -- LM 5,9,20(15) -- BALR 15,14
      goto L371;
    L201:  //  - REAL MAPS AND INTEGER MAPS
      Nest = 1;
    L202:;
      if (Type == 5) goto L205;
      if (Z == 3) goto L203;
      Jjj = Z;
      if (Z == 4) Jjj = 1;
      Jjj += (Type << 3) + (Prec << 1) - 8;
      Dump(Jjj, Reg, 0, 0, Nest);
      if (Z == 1 && Checks == 1) Checkcapacity(Reg, 0, 0, Nest);
      if (Z == 2 && Unass == 1) Testass(Reg);
      goto L1;
    L203:
      if (Reg != Nest) Prr(0x18, Reg, Nest);
      goto L1;
    L205:  //  STRING MAPS
      if (Nest != 1) Prr(0x18, 1, Nest);
      if (2 <= Z && Z <= 3) goto L206;
      Storestring(Z, Reg, 1, 0, 255);
      goto L1;
    L206:
      Pclod(69);
      goto L44;
    L600:
      Base = I;
      Index = 0;
      Disp = K;
    L601:
      if (Z == 6) goto L602;
      goto *Mod[Mod_sw = Nam << 4 | Prec << 2 | Z & 3];
    L602:
      if (!Nam) Fault(17);
      if (R13 == (Base << 12 | Disp)) R13 = 0;
      Jjj = 1;
      goto L605;
    Mod_1:;
    Mod_0:;
    Mod_5:;
    Mod_4:;
    Mod_9:;
    Mod_8:;
    Mod_12:;
    Mod_13:;
    Mod_2:;
    Mod_14:;
      Jjj = Z;
      if (Z == 4) Jjj = 1;
      Jjj += (Type << 3) + (Prec << 1) - 8;
    L605:
      Dump(Jjj, Reg, Disp, Index, Base);
      if (Z == 1 && Checks == 1) Checkcapacity(Reg, Disp, Index, Base);
      if (Z == 2 && Unass == 1) Testass(Reg);
      goto L9;
    Mod_31:;
    Mod_19:;
    Mod_23:;
    Mod_27:;
      Jjj = 2;
      goto L605;
    Mod_15:;
    Mod_3:;
    Mod_7:;
    Mod_11:;
      Jjj = 0;
      goto L605;
    Mod_6:;
    Mod_10:;
      Jjj = (Prec << 1) + 2;
      goto L605;
    Mod_16:;
    Mod_20:;
    Mod_24:;
    Mod_17:;
    Mod_21:;
    Mod_25:;
    Mod_28:;
    Mod_29:;
    Mod_18:;
    Mod_22:;
    Mod_26:;
    Mod_30:;
      Rp13 = R13;
      R13 = Base << 12 | Disp;
      if (R13 != Rp13 || Index != 0) Prx(0x58, Link, Index, Base, Disp);
      Jjj = Z;
      if (Z == 4) Jjj = 1;
      Jjj += (Type << 3) + (Prec << 1) - 8;
      Dump(Jjj, Reg, 0, 0, Link);
      if (Z == 1 && Checks == 1) Checkcapacity(Reg, 0, 0, Link);
      if (Z == 2 && Unass == 1) Testass(Reg);
    L9:
      if (Arr) goto L1;
    L91:
      P++;
      if (A[P] == 2) goto L6;
      Fault(19);
    L102:
      Skipapp();
      goto L1;
    L6:
      P++;
    L1:
      P++;
      if (A[P - 1] == 2) goto L9005;
      Fault(69);
      goto L91;
    L9005:;
      goto Funny_skip;
    Funny_default:
      fprintf(stderr, "\nSwitch label 'Funny(%d):' not set in %s\n", Funny_sw + 10, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    Funny_skip:;
      goto S_skip;
    S_default:
      fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw + 10, __PRETTY_FUNCTION__);
      fflush(stderr);
      abort();
    S_skip:;
    }
    void Crcall(int Clink) {
      static int Fpd_sw;
      static void *Fpd[4 /*0:3*/] = {
          &&Fpd_0,
          &&Fpd_1,
          &&Fpd_2,
          &&Fpd_3,
      };
      int Kk;
      int Ii;
      int Iii;
      int Q;
      int Qq;
      int Qqq;
      int Pp;
      int Rf;
      auto void Moveback(void);
      int Moved;
      int Tomove;
      int Typep;
      short List;
      List = 0;
      Fflag = 0;
      Kk = Countaps();
      P++;
      if (K == Kk) goto L2;
      Fault(19);
      Printname(Fname);
      Skipapp();
      P--;
      goto L99;
    L2:
      if (!K) goto L99;
      Q = 0;
      Qq = 64;
      Rf = 1 - Fflag;
      Moved = 0;
      if (Kk == 1) Rf = 1;
    L7:
      Mlink(Clink);
      From1(Clink, Ptype);
      P++;
      Unpack();
      Ii = Type;
      Iii = Prec;
      Qqq = P;
      Pp = (Nam << 1 | Arr) & 3;
      if ((Pp != 0 || Rout != 0) && (A[P] != 4 || A[P + 1] != 1)) goto L10;
      if (Rout == 1) goto L12;
      goto *Fpd[Fpd_sw = Pp];
    L10:
      P = Qqq;
      Skipexp();
    L11:
      Fault(22);
      goto L53;
      //  ROUTINE TYPE PARAMETERS
    L12:
      Ii = Ptype;
      P += 2;
      Cname(13, 0);
      if (1000 != abs(Ptype - Ii) && abs(Ptype - Ii) != 0) goto L10;
      if (A[P] == 1) goto L10;
      P++;
      if (J == 14) goto L13;
      if (Nam & 1) goto L15;
      Dump(2, 2, Disp, Index, Base);
      Prx(0x5A, 2, 0, Gla, 28);
      Pconst(0x180C181D);
      Push(List, Qq + 12, 0);
      goto L69;
    L13:
      Prx(0x98, 0, 2, Base, Disp);
      Prr(0x18, 3, 9);
      goto L69;
    L15:
      Prx(0x98, 0, 3, Base, Disp);
      goto L69;
    Fpd_0:
      if (Prec == 3) goto L41;
      if (Type == 5) goto L45;
      if (Unass != 0 || Type != 1) goto L39;
      Pp = P;
      Typep = Prec;
      Ii = Tsexp(Iii);
      if (Ii == 10 && Typep == 0) goto L42;
      if (Ii == 1 && Typep == 1) goto L43;
      P = Pp;
      Type = 1;
    L39:
      Csexp(0, Type);
      Moveback();
      Dump(8 * Type - 7, Nest, Qq - Moved, 0, Wspr);
      if (Checks == 1) Checkcapacity(Nest, Qq - Moved, 0, Wspr);
      Tomove = 4;
      goto L50;
    L42:
      Moveback();
      Pss(0xD2, 4, Wspr, Qq - Moved, I, K);
      Tomove = 4;
      goto L50;
    L43:
      Moveback();
      Psi(0x92, Iii, Wspr, Qq - Moved + 3);
      Tomove = 4;
      goto L50;
    L41:
      Ii = 0;
      if (Qq & 7) Ii = 4;
      Csexp(0, 3);
      Dump(15, Nest, Qq - Moved + Ii, 0, Wspr);
      Tomove = 8 + Ii;
      goto L50;
    L45:
      Cstrexp(4);
      From2(Clink, Iii);
      Prx(0x41, 1, 0, Wspr, Qq - Moved + 4);
      Storestring(1, 4, 1, 0, Iii - 1);
      Tomove = (Iii + 7) & (-4);
      goto L50;
    Fpd_2:;
      P += 2;
      if (Type == 3)
        Cname(15, 1);
      else
        Cname(3, 1);
      if (A[P] == 1) goto L10;
      P++;
      if ((Ii != Type || Iii != Prec) && Ii != 0) goto L11;
      Moveback();
      Dump(1, 1, Qq - Moved, 0, Wspr);
      Tomove = 4;
      if (Ii) goto L50;
      if (2 < Type) Fault(12);
      Psi(0x92, Prec << 3 | Type, Wspr, Qq - Moved);
      goto L50;
    Fpd_1:
    Fpd_3:;
      P += 2;
      Cname(12, 0);
      if (A[P] == 1) goto L10;
      P++;
      From2(Clink, Pp);
      if (!Pp) Replace2(Clink, J);
      if (Arr <= 0 || (J != 0 && Pp != 0 && J != Pp)) Fault(22);
      if (Ii != 0 && (Type != Ii || Iii != Prec)) Fault(22);
    L69:
      Moveback();
      Prx(0x90, 0, 3, Wspr, Qq - Moved);
      Tomove = 16;
    L50:
      Qq += Tomove;
      if (Rf == 1 || Q == Kk - 1) goto L53;
      Ii = ((Qq + 7) & (-8)) - Moved;
      Mover(Wspr, Ii);
      Moved += Ii;
    L53:
      Q++;
      if (Q != Kk) goto L7;
      if (Rf != 1) Mover(Wspr, -Moved);
    L55:
      Pop(List, Q, Qq);
      if (Q == -1) goto L99;
      Prx(0x50, Wspr, 0, Wspr, Q);
      goto L55;
      void Moveback(void) {
        if (Qq >= Moved) goto L1;
        Mover(Wspr, Qq - Moved);
        Moved = Qq;
      L1:;
      }
    L99:;
    }
    //  Z=1 FOR= ,4 FOR <- AND MAX LENGTH IN BYTE DEFINED BY BML&Dml
    void Storestring(int Z, int From, int To, int Bml, int Dml) {  //  REGISTER 2 IS ASSUMED TO BE USABLE.
      if (To != 1 || From != 4) Fault(239);
      if (Z == 4) goto L10;
      if (!Checks) goto L2;
      if (Bml > 0) goto L1;
      Psi(0x95, Dml, From, 0);
      goto L3;
    L1:;
      Pss(0xD5, 1, From, 0, Bml, Dml);
    L3:;
      Prx(0x47, 2, 0, Coder, 88);
    L2:
      Prx(0x43, 2, 0, From, 0);
      Prx(0x44, 2, 0, Gla, Strinst);
      goto L99;
    L10:
      Prx(0x43, 2, 0, Bml, Dml);
      Ppj(39);
    L99:;
    }
    void Testnst(void) {
      Fname = K;
      if (Find(Fname, Name[Level]) != -1) Fault(7);
    }
    void Cuci(void) {
      auto void Dxb(void);
      auto void Dlb(void);
      auto void Db(void);
      auto void Cucs(void);
      int Z;
      int Kk;
      int X;
      int Opcode;
      int Reg;
      static int Sw_sw;
      static void *Sw[4 /*1:4*/] = {
          &&Sw_1,
          &&Sw_2,
          &&Sw_3,
          &&Sw_4,
      };
      static int S_sw;
      static void *S[8 /*1:8*/] = {
          &&S_1, &&S_2, &&S_3, &&S_4, &&S_5, &&S_6, &&S_7, &&S_8,
      };
      P = 2;
      goto *Sw[Sw_sw = (A[P]) - 1];
    Sw_1:;
      Nest = A[3];
      P = 5;
      Z = A[4] - 1;
      if (!Z) Z = 3;
      Cname(Z, Nest);
      goto L99;
    Sw_2:
      Ppj(A[P + 1]);
      goto L99;
    Sw_4:;
      if (A[P + 1] != 9) goto L401;
      Plant(A[P + 2]);
      P += 3;
      goto L99;
    L401:
      if (A[P + 1] != 1) Fault(32);
      Plant(A[P + 3]);
      P += 4;
      goto L99;
    Sw_3:
      Opcode = A[P + 2];
      P += 3;
      goto *S[S_sw = (A[P - 2]) - 1];
    S_1:
      if (!Opcode) goto L87;
      Prr(Opcode, A[P], A[P + 1]);
      P += 2;
      goto L99;
    S_2:
      Reg = A[P];
      P++;
      Dxb();
    L11:
      Prx(Opcode, Reg, X, I, K);
      goto L99;
    S_3:
      Reg = A[P];
      X = A[P + 1];
      P += 2;
      Db();
      goto L11;
    S_4:
      Db();
      Z = 0;
      if (A[P] == 2) goto L41;
      Z = A[P + 2];
      if (A[P + 1] != 9 || Z >= 256) Fault(32);
      P += 2;
    L41:
      Psi(Opcode, Z, I, K);
      P++;
      goto L99;
    S_5:
      Reg = A[P];
      P++;
      Db();
      X = 0;
      goto L11;
    S_6:
      Dlb();
      Kk = K;
      Z = X;
      Reg = I;
      Db();
      if (!Z) Z = 1;
    L61:
      Pss(Opcode, Z, Reg, Kk, I, K);
      goto L99;
    S_7:
      Dlb();
      Kk = K;
      Z = X;
      Reg = I;
      Dlb();
      if (!Z) Z = 1;
      if (!X) X = 1;
      Z = (Z - 1) << 4 | X;
      goto L61;
    S_8:
      Reg = A[P];
      P++;
      if (Opcode == 0x80) goto L85;
      if (Opcode == 10) goto L83;
      Prr(Opcode, Reg, 0);
      goto L99;
    L83:
      Plant(0xA00 | Reg);
      goto L99;
    L85:
      Psi(Opcode, Reg, 0, 0);
      goto L99;
    L87:
      Cnop(A[P], A[P + 1]);
      goto L99;
      void Db(void) {
        if (A[P] == 1) goto L2;
        K = A[P + 1];
        I = 0;
        P += 3;
        if (A[P - 1] == 2) goto L99;
        I = A[P];
        P++;
        goto L99;
      L2:
        Cucs();
      L99:;
      }
      void Dxb(void) {
        static int Sw_sw;
        static void *Sw[3 /*1:3*/] = {
            &&Sw_1,
            &&Sw_2,
            &&Sw_3,
        };
        if (A[P] == 2) goto L2;
        Cucs();
        X = 0;
        P++;
        if (A[P - 1] == 2) goto L99;
        X = A[P];
        P++;
        goto L99;
      L2:
        K = A[P + 1];
        P += 2;
        I = 0;
        X = 0;
        goto *Sw[Sw_sw = (A[P]) - 1];
      Sw_1:
        X = A[P + 1];
        P++;
      Sw_2:
        I = A[P + 1];
        P++;
      Sw_3:
        P++;
      L99:;
      }
      void Dlb(void) {
        if (A[P] == 2) goto L2;
        K = A[P + 1];
        X = A[P + 2];
        I = A[P + 3];
        P += 4;
        goto L99;
      L2:
        Cucs();
        X = A[P];
        P++;
      L99:;
      }
      void Cucs(void) {
        static int Utype_sw;
        static void *Utype[9 /*0:8*/] = {
            &&Utype_0, &&Utype_1, &&Utype_2, &&Utype_3, &&Utype_4, &&Utype_5, &&Utype_6, &&Utype_7, &&Utype_8,
        };
        P++;
        if (A[P] == 2) goto L10;
        Fname = A[P + 1];
        Copytag(Fname);
        P += 3;
        if (I != -1) goto L1;
        Fault(16);
        J = 0;
        I = Level;
        Ptype = 7;
        Unpack();
        Storetag(Fname, N);
        K = N;
        N += 4;
      L1:
        if (Rout == 1) Fault(33);
        goto *Utype[Utype_sw = Type];
      Utype_3:
        From2(K, K);
        goto L9;
      Utype_4:
        From1(K, K);
        goto L9;
      Utype_8:
        Fault(33);
        goto L9;
      Utype_6:
        From1(K, K);
        K -= Codebase[Oldi];
        if (K > 4095) Fault(99);
        I = 10;
      Utype_0:
      Utype_1:
      Utype_2:
      Utype_5:
      Utype_7:;
        if (Arr != 2) goto L9;
        From2(K, K);
      L9:
        if (A[P - 1] == 2) goto L99;
        K += A[P];
        P++;
        goto L99;
      L10:
        K = A[P + 2] + ((A[P + 1] - 1) << 14);
        J = Find(K, Label[Level]);
        if (J == -1) goto L25;
        K = J - Codebase[Level];
        I = 10;
        if (K > 4095) Fault(99);
        P += 3;
        goto L99;
      L25:
        Push(Jump[Level], Ca | Labset, K);
        K = 0;
        I = 0;
        P += 3;
      L99:;
      }
    L99:;
    }
    void Testass(int Reg) {
      int J;
      if (1 > Type || Type > 2) return;
      if (Type == 1) goto L5;
      J = 0x79;
      if (Prec == 3) J = 0x69;
    L3:
      Prx(J, Reg, 0, Gla, 128);
      Prx(0x47, 8, 0, Coder, 40);
      goto L99;
    L5:
      if (Prec) goto L99;
      J = 0x59;
      goto L3;
    L99:;
    }
    void Gxref(int Name, int Hash) {
      int I;
      int J;
      int K;
      int N;
      int Np;
      I = N0;
      N0 += 7;
      J = Word[Name];
      St[I + 1] = 0;
      St[I + 2] = 0;
      St[I + 3] = 0;
      N = Lett[J];
      Np = N;
      if (Np > 8) Np = 8;
      K = Addr(St[I + 5]);
      if (!Hash) goto L1;
      St[I + 5] = Hash << 16 | '#' << 8;
      K += 2;
      N += 2;
      if (Np > 6) Np = 6;
    L1:
      for (Np = 1; Np <= Np; Np++) *Byteinteger(K + Np) = Lett[J + Np];
      if (N > 8) N = 8;
      St[I + 4] = 0x80000000;
      St[I] = Xreflink;
      Xreflink = I << 2;
      *Byteinteger(Addr(St[I + 5])) = N;
      if (N == 8) N0++;
    }
    void Undcrf(short *Ophead) {
      int I;
      int J;
      short Op;  //  UNSCRAMBLES RECORD FORMAT TAGS LIST & SIDECHAIN
      Pop(*Ophead, I, J);
    L1:
      Pop(*Ophead, I, J);
      if (I == -1) goto L9;
      Op = J;
      Ptype = (unsigned)I >> 4 & 0xFFFF;
      Unpack();
      if (Rout == 1 || Type == 3) Clearlist(Op);
      goto L1;
    L9:;
    }
    void Clt(void) {  //  P ON PHRASE TYPE AT ENTRY - TO NEXT PHRASE AT EXIT
      Type = Typeflag[A[P]];
      Prec = (unsigned)Type >> 3;
      Type = Type & 7;
      if (Type == 2 && Alllong != 0) Prec = 3;
      Acc = Bytes[Prec];
      P++;
      if (Type != 5) goto L99;
      if (A[P] != 2) goto L2;
      Acc = 0;
      P++;
      goto L99;
    L1:
      P++;
      Fault(70);
      goto L99;
    L2:
      P++;
      Acc = A[P] + 1;
      if (2 > Acc || Acc > 256) goto L1;
      P++;
    L99:;
    }
    void Cqn(int P) {
      unsigned char I;
      I = A[P];
      Nam = 0;
      Arr = 0;
      if (I == 1) Nam = 2;
      if (I <= 2) Arr = 1;
      if (I <= 3) Nam = Nam | 1;
      if (Arr == 1) Acc = 16;
      if (I == 3) Acc = 4;
    }
    void Skipexp(void) {
      static int Sw_sw;
      static void *Sw[4 /*1:4*/] = {
          &&Sw_1,
          &&Sw_2,
          &&Sw_3,
          &&Sw_4,
      };
      int J;
      static int Rt = 10000;
    L3:
      P++;
      goto *Sw[Sw_sw = (A[P]) - 1];
    Sw_1:
      P += 2;
      J = Addr(Aslist[Tags[A[P - 1]]]);
      if (Shortinteger < Rt) goto L5;
      Fflag = 1;
    L5:
      Skipapp();
      P++;
      if (A[P - 1] == 2) goto L1;
      P++;
      goto L5;
    Sw_2:;
      P++;
      J = A[P];
      if (J == 9) {
        P += 2;
        goto L1;
      }
      if (J == 1) {
        P += 3;
        goto L1;
      }
      if (J == 2) {
        P += 5;
        goto L1;
      }
      P = P + (A[P + 1] & 0xFE) + 3;
      goto L1;
    Sw_3:
    Sw_4:
      P++;
      Skipexp();
    L1:
      P++;
      if (A[P - 1] == 1) goto L3;
    }
    void Skipapp(void) {
    L5:
      P++;
      if (A[P - 1] == 2) goto L1;
      Skipexp();
      goto L5;
    L1:;
    }
    void Cquery(int Reg) {
      Psi(0x95, 0, Gla, 1);
      Pj(8, Plabel - 1);
      if (Type == 2) goto L1;
      if (Type == 5) goto L5;
      if (Reg != 1) Prr(0x18, 1, Reg);
      Pconst(0x4120000B);
      Ppj(4);
      goto L9;
    L1:
      Pconst(0x41100020);
      Ppj(3);
      if (!Qpreal) {
        Qpreal = (N0 << 2) + 4;
        St[N0] = Xreflink;
        Xreflink = Qpreal - 4;
        St[N0 + 4] = 8;
        St[N0 + 5] = 'I#PR';
        St[N0 + 6] = 'INTF';
        N0 += 7;
      }
      Paclod(82, 1, Reg << 4);  //  STD REG,64(11).LA 0,12.ST 0,68(11) %ABD SS ENTRYPRINTF
      Paclod(55, 4, Qpreal);
      goto L9;
    L5:
      Pconst(0x4110000A);
      Ppj(3);
      Prr(0x18, 1, Reg);
      Ppj(5);
    L9:
      Plab(-1);
    }
    void Loadad(int Reg, int Base, int X, int Disp) {
      int I;
      Prx(0x41, Reg, X, Base, Disp & 4095);
      I = Pageno(Disp);
      if (4095 < Disp) Prx(0x5A, Reg, 0, Gla, 4 * I);
    }
    int Tsexp(int *Code) {
      static int Sw_sw;
      static void *Sw[4 /*1:4*/] = {
          &&Sw_1,
          &&Sw_2,
          &&Sw_3,
          &&Sw_4,
      };
      Type = 1;
      if (1 != A[P] && A[P] != 4) goto L9;
      goto *Sw[Sw_sw = (A[P + 1]) - 1];
    Sw_1:
      *Code = A[P + 2];
      Copytag(*Code);
      if (Ptype == 10006) {
        Type = Tsname[K];
        Prec = (unsigned)Type >> 3;
        Type = Type & 7;
      }
      if (Type == 8) goto L40;
      if (Type == 3 && Arr == 0 && Inreg != 0) goto L30;
      if (Arr == 2 && Type == 1) goto L50;
      if (A[P + 3] != 2 || 2 != A[P + 4]) goto L9;
      if (Rout != 0 || Arr != 0) goto L9;
      if (Type == 5) goto L20;
      if (Nam) goto L9;
      if (Type == 2) goto L14;
      if (Type != 1) goto L9;
      if (A[P + 5] == 2) goto L11;
      if (A[P + 6] != 2 || 2 != A[P + 7]) goto L9;
      if (A[P + 8] != 9 || A[P + 10] != 2) goto L9;
      *Code = A[P + 9];
      P += 11;
      return (100);
    L11:
      P += 6;
      return (10 + Prec);
    L14:
      if (A[P + 5] != 2) goto L9;
      P += 6;
      return (14 + (Prec & 1));
    L20:
      if (A[P + 5] != 2) goto L9;
      P += 6;
      return (20);
    L30:
      if (A[P + 3] != 2 || A[P + 4] != 1) goto L9;
      P += 5;
      From1(K, Fname);
      I = Inreg;
      K = Displacement(Fname);
      Unpack();
      if (I == -1 || Arr != 0 || Rout != 0) goto L9;
      if (1 > Type || Type > 2 || A[P + 1] != 2 || 2 != A[P + 2]) goto L9;
      if (A[P + 3] != 2) goto L9;
      P -= 2;
      if (Type == 1) goto L11;
      goto L14;
    L40:
      if (A[P + 5] == 2) goto L41;
      if (A[P + 6] != 2 || 2 != A[P + 7]) goto L9;
      if (A[P + 8] != 9 || A[P + 10] != 2) goto L9;
      *Code = A[P + 9];
      P += 11;
      return (101);
    L41:
      P += 6;
      return (50);
    L50:
      if (A[P + 3] != 1 || A[P + 4] != 4 || A[P + 5] != 2) goto L9;
      if (A[P + 6] != 9 || A[P + 7] >= 256 || A[P + 8] != 2) goto L9;
      if (A[P + 9] != 2 || A[P + 10] != 2 || A[P + 11] != 2) goto L9;
      From1(K, K);
      K += A[P + 7] * Bytes[Prec];
      if (0 > K || K >= 4096) goto L9;
      P += 12;
      return (10 + Prec);
    Sw_2:
      Type = A[P + 2] & 7;
      if (A[P + 2] != 9) goto L9;
      if (A[P + 4] == 1) goto L21;
      *Code = A[P + 3];
      P += 5;
      if (256 > *Code) return (1);
      return (2);
    L21:
      if (A[P + 5] == 12) Type = 5;
    Sw_3:
    Sw_4:
    L9:
      return (0);
    }
    void Mover(int R, int N) {
      if (!N) goto L99;
      if (0 > N) goto L2;
      Dump(0, R, N, 0, R);
      goto L99;
    L2:
      N = -N;
      if (N != 4 && N != 8) goto L3;
      Prx(0x5A, R, 0, Gla, 76 + N);
      goto L99;
    L3:
      Pconst(0x41000000 | N);
      Prr(0x1B, R, 0);
    L99:;
    }
    int Findpp(void) {
      int I;
      for (I = 9 - Rlevel; I >= 4; I--)
        if (!Register[I]) goto L1;
      return (0);
    L1:
      Register[I] = 1;
      return (I);
    }
    void Unpark(int Opcode, int Reg, int Q) {
      if (0 > Q) goto L1;
      Prr(Opcode - 0x40, Reg, Q);
      Register[Q] = 0;
      goto L9;
    L1:
      Q = abs(Q);
      Prx(Opcode, Reg, 0, Rbase, Q);
      Push(Wsp[Level], 0, Q);
    L9:;
    }
    int Park(int Reg) {
      int I;
      int J;
      int P;
      P = Claimablereg();
      if (!P) goto L1;
      Register[P] = 1;
      if (P == Reg) goto L2;
      Prr(0x18, P, Reg);
    L2:
      return (P);
    L1:
      Pop(Wsp[Level], I, J);
      if (J != -1) goto L3;
      J = N;
      N += 4;
    L3:
      Dump(1, Reg, J, 0, Rbase);
      return (-J);
    }
    int Claimablereg(void) {
      int I;
      if (Rbase <= 4) goto L1;
      for (I = 5; I <= Rbase; I++)
        if (!Register[I]) return (I);
    L1:
      return (0);
    }
    int Parkf(int Reg, int Prec) {
      int I;
      int J;
      if (Prec) goto L10;
      Pop(Wsp[Level], I, J);
      if (J != -1) goto L3;
      J = N;
      N += 4;
    L3:
      Dump(9 + 2 * Prec, Reg, J, 0, Rbase);
      return (J);
    L10:
      J = Getdblewrd();
      goto L3;
    }
    int Getarrwsp(void) {  //  PRODUCES 6 CONTIGUOUS WORDS UNDER BASE
                           //  REGISTER COVER FOR ARRAY ACCESS
      int I;
      int J;
      Pop(Mdarr[Level], I, J);
      if (J > 0) goto L1;
      J = N;
      N += 24;
    L1:
      return (J);
    }
    void Rhead(int Kk) {
      int Flag;
      int W1;
      int W2;
      Flag = Kk;
      if (!Rlevel) Flag = 10000;
      if (!Rlevel) goto L5;
      if (List) goto L5;
      Newline();
      Write(Line, 5);
      Spaces(3 * Level);
      if (Kk < 0)
        Printstring(_imp_str_literal("BEGIN"));
      else {
        Printstring(_imp_str_literal("RT/FN/MAP "));
        Printname(Kk);
      }
      Write(Ca, 6);
    L5:
      Level++;
      if (Flag < 0) goto L6;
      Rlevel++;
      Rbase = 10 - Rlevel;
      R13 = 0;
      if (Rbase == 4 || Register[Rbase] != 0) Fault(35);
      Register[Rbase] = 1;
    L6:
      if (Level == 10) Fault(34);
      if (Level > Maxlevels) Fault(105);
      Nmdecs[Level] = 0;
      if (Flag >= 0) goto L10;
      Prx(0x90, 10, 11, Rbase, N);
      N += 12;
      W1 = Rbase;
      W2 = N - 4;
      goto L20;
    L10:
      if (Kk < 0) goto L25;
      Fromlist(Jj, J, K);
      St[(unsigned)Ra[J] >> 2] = Ca;
      Prx(0x50, Link, 0, Wspr, 60);
      W1 = Wspr;
      W2 = 0;
    L20:
      if (!Diags1) goto L21;
      Pss(0xD2, 4, W1, W2, Gla, 20);
      Loadad(0, 0, 0, Line);
      Pconst(0x4000D014);
    L21:
      Mone = 1;
      Setline();
    L25:
      if (Flag >= 0) Prr(0x18, Rbase, Wspr);
      if (Kk < 0)
        W1 = 0;
      else
        W1 = Word[Kk];
      L[Level] = Line;
      M[Level] = W1;
      Rnext[Level] = Next;
      if (Flag < 0) return;
      Set[Rlevel] = Ca + 2;
      Prx(0x41, Wspr, Wspr, 0, 0);
      if (Checks) Pclod(75);
      N = 64;
      Nmax = N;
    }
    void Set80(int Where, int N) {
      if (N <= 2) return;
      int K;
      Psi(0x92, 0x80, Rbase, Where);
      N--;
      K = Where;
    L1:
      if (N <= 256) goto L2;
      Pss(0xD2, 256, Rbase, K + 1, Rbase, K);
      K += 256;
      N -= 256;
      goto L1;
    L2:
      Pss(0xD2, N, Rbase, K + 1, Rbase, K);
    }
    void Cbpair(int *Lb, int *Ub) {
      int Kk;
      int Kkk;
      int Jj;
      int Bp;
      P++;
      Kk = 0;
      for (Jj = 1; Jj <= 2; Jj++) {
        Kkk = Kk;
        if (A[P] == 2)
          Kk = -1;
        else
          Kk = 1;
        if ((A[P + 1] & 7) == 2) goto Real;
        if ((A[P + 1] & 7) == 5) goto String;
        if (A[P + 1] == 9)
          Bp = A[P + 2];
        else {
          Fromar4(P + 2, Bp);
          P++;
        }
        Kk = Kk * Bp;
        P += 3;
        goto Again;
      Real:
        Fault(24);
        P += 6;
        Kk = 0;
        goto Again;
      String:
        Fault(42);
        P = (P * A[P + 2] & 0xFE) + 2;
        Kk = 0;
      Again:;
      }
      *Lb = Kkk;
      *Ub = Kk;
    }
    void Loaddata(void) {
      int Ldlink;
      int Jj;
      int Kk;
      int Ptr;
      int Jjj;
      short Head;
      Ldptr = 8 + 8 * Neps;
      int Buffer[Ldptr + 1];
      Buffer[0] = 7;
      Buffer[2] = 88;
      Buffer[3] = 0;
      Buffer[4] = 0;
      Buffer[5] = 0;
      Buffer[6] = 64;
      Ptr = 8;
      Ldlink = 0;
    L1:
      Pop(Eplink, Jj, Kk);
      if (Jj < 0) goto L10;
      Head = Kk;
      Buffer[Ptr] = Ldlink;
      Ldlink = Ptr << 2;
      Buffer[Ptr + 1] = 0;
      Buffer[Ptr + 2] = 0;
      Buffer[Ptr + 3] = Jj;
      Buffer[Ptr + 4] = 0x80000000;
      Pop(Head, Buffer[Ptr + 5], Kk);
      if (Kk > 3) Pop(Head, Buffer[Ptr + 6], Jjj);
      Ptr += 7;
      if (Kk > 7) {
        Pop(Head, Buffer[Ptr], Jjj);
        Ptr++;
      }
      goto L1;
    L10:
      Buffer[1] = Ldlink;
      Lput(3, Ptr << 2, 0, Addr(Buffer[0]));
      Ldptr = Ptr;
    }
    void Defineep(int Mode, int Name, int Adr) {
      short Head;
      int Jj;
      int Kk;
      int Length;
      int Id1;
      int Id2;
      int Id3;
      static int Sw_sw;
      static void *Sw[3 /*0:2*/] = {
          &&Sw_0,
          &&Sw_1,
          &&Sw_2,
      };
      Kk = Word[Name];
      Head = 0;
      goto *Sw[Sw_sw = Mode];
    Sw_0:
      //  DEFINE S#GO
      Length = 4;
      Id1 = 'S#G';
      Id2 = 'O   ';
      goto L10;
    Sw_1:
      //  SYSTEM EP
      Length = Lett[Kk] + 2;
      Id1 = 'S#A';
      for (Jj = 1; Jj <= 6; Jj++) *Byteinteger(Addr(Id1) + Jj + 2) = Lett[Kk + Jj];
      goto L10;
    Sw_2:
      //  ENTRY TO EXTERNAL ROUTINE
      Length = Lett[Kk];
      for (Jj = 1; Jj <= 8; Jj++) *Byteinteger(Addr(Id1) + Jj) = Lett[Kk + Jj];
    L10:
      if (Length > 8) Length = 8;
      *Byteinteger(Addr(Id1)) = Length;
      if (Length > 7) Push(Head, Id3, 0);
      if (Length > 3) Push(Head, Id2, 0);
      Push(Head, Id1, Length);
      Push(Eplink, Adr, Head);
      Neps++;
    }
    void Redefineep(int Typep, int Params) {
      int Jj;
      int Kk;
      short Ophead;
      Jj = N0;
      P -= 2;
      Gxref(A[P], 'I');
      K = Newcell();
      Ophead = K;
      if (!Params) goto L1;
      for (Kk = 1; Kk <= Params; Kk++) Insertafter(Ophead, Params, 0);
    L1:
      I = 9;
      J = 14;
      Oldi = 0;
      Ptype = Typep;
      Replacetag(A[P]);
      Replaceboth(K, Nr, Params);
      Ra[Nr] = Jj << 2;
      Nr++;
    }
    int Getdblewrd(void) {  //  PRODUCES A DOUBLE WORD OF TEMPORARY SPACE
                            //  COVERED BY CURRENT BASE REGISTER (RBASE)
      int I;
      int J;
      Pop(Lwsp[Level], I, J);
      if (I != -1) goto L3;
      if (!(N & 7)) goto L2;
      Push(Wsp[Level], 0, N);
      N += 4;
    L2:
      J = N;
      N += 8;
    L3:
      return (J);
    }
    int Getstrwsp(void) {
      int I;
      int J;
      Pop(Strwsp[Level], I, J);
      if (J != -1) goto L2;
      J = N;
      N += 256;
    L2:
      return (J);
    }
    void Setex(void) {
      if (Strinst) return;
      St[N0] = 0xD2001000;
      St[N0 + 1] = 0x4000D500;
      St[N0 + 2] = 0x20001000;
      Strinst = N0 << 2;
      N0 += 3;
    }
    void Setline(void) {
      int K;
      static int Value;
      if (Linenos != 1) return;
      K = Line & 255;
      if (!K) Mone = 1;
      if (K != Value || Mone != 0) Psi(0x92, K, Gla, 23);
      Value = K;
      if (!Mone) goto L9;
      Psi(0x92, (unsigned)Line >> 8, Gla, 22);
    L9:
      Mone = 0;
    }
    void Checkcapacity(int Reg, int Dis, int X, int Level) {
      int Mask;
      if (Type != 1 || 1 > Prec || Prec > 2) return;
      if (Prec == 1) goto L3;
      Mask = 7;
      Prx(0x49, Reg, Level, X, Dis);
    L1:
      Prx(0x47, Mask, 12, 0, 88);
      goto L99;
    L3:
      Prx(0x55, Reg, 0, Gla, 24);
      Mask = 2;
      goto L1;
    L99:;
    }
    //  MACROISING  THE FROMS,REPLACES & MLINK SAVES TIME & SPACE;
    //  MACROISING  THE OTHERS SAVES TIME BUT INCREASES SIZE
    void Fromlist(int Cell, int *S1, int *S2) {
      int J;
      J = Addr(Aslist[Cell]);
      *S1 = *Integer(J);
      *S2 = Shortinteger;
    }
    int Newcell(void) {
      int P;
      P = Asl;
      if (!P) Fault(107);
      Asl = Shortinteger;
      Setshortinteger(Addr(Aslist[P + 6]), 0);
      return (P);
    }
    void Push(short *Cell, int S1, int S2) {
      int P;
      int Q;
      P = Newcell();
      Q = Addr(Aslist[P]);
      *Integer(Q) = S1;
      Setshortinteger(Q + 4, S2);
      Setshortinteger(Q + 6, *Cell);
      *Cell = P;
    }
    void Pop(short *Cell, int *S1, int *S2) {
      int P;
      int Q;
      Q = Addr(Aslist[*Cell]);
      *S1 = *Integer(Q);
      *S2 = Shortinteger;
      if (!*Cell) goto L1;
      P = *Cell;
      *Cell = Shortinteger;
      Shortinteger = Asl;
      Asl = P;
    L1:;
    }
    void Replace1(int Cell, int S1) { *Integer(Addr(Aslist[Cell])) = S1; }
    void Replace2(int Cell, int S2) { Shortinteger = S2; }
    void Mlink(int *Cell) { *Cell = Shortinteger; }
    void Insertafter(short *Cell, int S1, int S2) {
      if (!*Cell) goto L1;
      Push(Shortinteger, S1, S2);
      *Cell = Shortinteger;
      return;
    L1:
      Push(*Cell, S1, S2);
    }
    int Find(int Lab, int List) {
    L3:
      if (!List) goto L1;
      if (Shortinteger == Lab) goto L4;
      Mlink(List);
      goto L3;
    L4:
      return (*Integer(Addr(Aslist[List])));
    L1:
      return (-1);
    }
    void From1(int Cell, int *S1) { *S1 = *Integer(Addr(Aslist[Cell])); }
    void From2(int Cell, int *S2) { *S2 = Shortinteger; }
    void Replaceboth(int Cell, int S1, int S2) {
      int I;
      I = Addr(Aslist[Cell]);
      *Integer(I) = S1;
      Shortinteger = S2;
    }
    void Clearlist(short *Ophead) {
      int I;
      int J;
    L1:
      Pop(*Ophead, I, J);
      if (I != -1) goto L1;
    }
    void Storetag(int Kk, int Slink) {
      Push(Tags[Kk], Ptype << 16 | Level << 8 | Rbase << 4 | J, Slink);
      if (Level > 1) Push(Name[Level], 0, Kk);
    }
    int Countaps(void) {
      int Pp;
      int Q;
      Q = 0;
      Pp = P;
      P++;
    L1:
      if (A[P] == 2) goto L2;
      P++;
      Q++;
      Skipexp();
      goto L1;
    L2:
      P = Pp;
      return (Q);
    }
    int Displacement(int Link) {
      int Rr;
      int Ii;
      if (!Link) goto L2;
      From2(Link, Link);
    L1:
      Mlink(Link);
      Fromlist(Link, Rr, Ii);
      if (Ii == -1) goto L2;
      J = Rr & 15;
      Ptype = (unsigned)Rr >> 4 & 0xFFFF;
      Rr = (unsigned)Rr >> 20;
      K = Link;
      Inreg = 0;
      if (Rr == A[P]) goto L99;
      goto L1;
    L2:
      Fault(65);
      Printname(A[P]);
      Ptype = 1;
    L99:
      return (Ii);
    }
    int Copyrecordtag(void) {
      int Q;
      int Fname;
    L1:
      From1(K, Fname);
      P++;
      Skipapp();
      if (A[P] == 2) return (0);
      P++;
      Q = Displacement(Fname);
      if (Q == -1) Ptype = 7;
      Unpack();
      if (Type == 3) {
        K = Q;
        goto L1;
      }
      if (Q == -1) return (-1);
      return (1);
    }
    void Copytag(int Kk) {
      int Q;
      Fromlist(Tags[Kk], Q, K);
      if (Q == -1) goto Notset;
      Ptype = (unsigned)Q >> 16;
      Inreg = (unsigned)Q >> 12 & 15;
      Oldi = (unsigned)Q >> 8 & 15;
      I = (unsigned)Q >> 4 & 15;
      J = Q & 15;
    L1:
      Unpack();
      return;
    Notset:
      Ptype = 7;
      I = -1;
      J = I;
      Oldi = J;
      goto L1;
    }
    void Replacetag(int Kk) {
      int P;
      int Q;
      P = Tags[Kk];
      Q = Ptype << 16 | Inreg << 12 | Oldi << 8 | I << 4 | J;
      Replaceboth(P, Q, K);
    }
    void Unpack(void) {
      int Q;
      Rout = Ptype / 10000;
      Q = Ptype - 10000 * Rout;
      Nam = Q / 1000;
      Q -= 1000 * Nam;
      Arr = Q / 100;
      Q -= 100 * Arr;
      Prec = Q / 10;
      Type = Q - 10 * Prec;
    }
    void Pack(int *Ptype) {
      int Q;
      Q = 10000 * Rout + 1000 * Nam + 100 * Arr;
      *Ptype = Q + 10 * Prec + Type;
    }
    void Ppj(unsigned char N) {
      R13 = 0;
      Pconst(0x45F0C000 | N << 2);
    }
    int Pageno(int N) {
      int I;
      int J;
      J = (unsigned)N >> 12;
      I = Pagenos[J];
      if (I) return (I);
      St[N0] = J << 12;
      Pagenos[J] = N0;
      N0++;
      return (N0 - 1);
    }
    void Filljumps(int Level) {
      int J;
      int K;
      int Q;
      int Kk;
      Ophead = 0;
    L1:
      Pop(Jump[Level], J, K);
      if (J == -1) goto L3;
      Q = Find(K, Label[Level]);
      if (Q != -1) goto L2;
      Push(Ophead, J, K);
      goto L1;
    L2:
      Kk = 0;
      Q -= Codebase[Level];
      K = (unsigned)Q >> 12;
      if (J & Labset) goto L22;
      if (Sbflag == 1) goto L23;
      Plug(J, 0x58E0);
      Plug(J + 2, Gla << 12 | 4 * Pageno(Q));
      J += 4;
      if (K) Kk = 14;
    L21:
      Plug(J + 2, Kk << 12 | Q & 0xFFF);
      goto L1;
    L22:
      J = J & 0xFFFFFF;
      Kk = 10;
    L23:
      if (Q > 4095) Fault(99);
      goto L21;
    L3:
      Jump[Level] = Ophead;
    }
    void Pj(int Mask, int Lab) {
      int I;
      int J;
      int Q;
      J = Find(Lab, Label[Level]);
      if (J == -1) goto L200;
      I = J - Codebase[Level];
      if (I >= 4096) goto L50;
      Prx(0x47, Mask, 0, 10, I);
      goto L999;
    L50:
      Q = 4 * Pageno(I);
      Pconst(0x58E0D000 | Q);
      Prx(0x47, Mask, 14, 10, I & 4095);
      goto L999;
    L200:
      Push(Jump[Level], Ca, Lab);
      if (Sbflag != 1) Pconst(0);
      Prx(0x47, Mask, 10, 0, 0);
    L999:;
    }
    void Plab(int M) {
      Mone = 1;
      if (M >= 0) goto L1;
      Plabel--;
      K = Plabel;
      M = K;
    L1:
      Push(Label[Level], Ca, M);
      R13 = 0;
    }
    void Checkrf(void) {
      Copytag(A[Marker1]);
      if (Type != 4) goto L1;
      Jj = K;
      Fromlist(Jj, Q, Fname);
      Dump(0, 4, Q, 0, I);
      goto L9;
    L1:
      K = -1;
      Fault(62);
    L9:;
    }
    void Dump(int Code, int Reg, int Dis, int X, int Level) {  //  CODE=8*(TYPE-1)+2*PREC+Z
      int J;
      static unsigned char Opcode[17 /*0:16*/] = {
          0x41, 0x50, 0x58, 0x42, 0x43, 0x40, 0x48, 0x59, 0x49, 0x70, 0x78, [11 ... 14] = 0, 0x60, 0x68};
      J = Opcode[Code];
      if (!J) Fault(248);
      if (Code == 4) goto L4;
      if (Code != 0 || 0 != Dis) goto L1;
      if (Level != 0 || 0 != X) goto L3;
      Prr(0x1F, Reg, Reg);
      goto L99;
    L3:
      if (Level != 0 && X != 0) goto L1;
      if (Reg != X + Level) Prr(0x18, Reg, X + Level);
      goto L99;
    L4:
      if (X != Reg && Reg != Level) Prr(0x1F, Reg, Reg);
    L1:
      Prx(J, Reg, X, Level, Dis);  //  AND WITH 255 FOR BYTE IF SLR NOT POSSIBLE AS ADDR IN R
      if (Code == 4 && (X == Reg || Reg == Level)) Prx(0x54, Reg, 0, Gla, 24);
    L99:;
    }
    goto Sw_skip;
  Sw_default:
    fprintf(stderr, "\nSwitch label 'Sw(%d):' not set in %s\n", Sw_sw + 1, __PRETTY_FUNCTION__);
    fflush(stderr);
    abort();
  Sw_skip:;
  }
  exit(0);
  return (1);
}
