#include <perms.h>
int _imp_mainep(int _imp_argc, char **_imp_argv) {
  static const int Release = 10;
  static const int Yes = 1;
  static const int No = 0;
  static const int Useimp = Yes;
  static const int Vmeb = No;
  static const _imp_string Ladate = _imp_str_literal("28 Jan 81");
  int I;
  int J;
  int K;
  static const unsigned char Clett[501 /*0:500*/] = {
      1,   43,  1,   45,  1,   40,  1,   41,  1,   44,  2,   201, 198, 6,   213, 206, 204, 197, 211, 211, 5,   215, 200,
      201, 204, 197, 5,   213, 206, 212, 201, 204, 3,   198, 207, 210, 1,   61,  4,   210, 197, 193, 204, 7,   201, 206,
      212, 197, 199, 197, 210, 8,   204, 207, 206, 199, 210, 197, 193, 204, 4,   204, 207, 206, 199, 11,  194, 217, 212,
      197, 201, 206, 212, 197, 199, 197, 210, 6,   211, 212, 210, 201, 206, 199, 11,  200, 193, 204, 198, 201, 206, 212,
      197, 199, 197, 210, 7,   210, 207, 213, 212, 201, 206, 197, 2,   198, 206, 3,   205, 193, 208, 8,   198, 213, 206,
      195, 212, 201, 207, 206, 6,   210, 197, 195, 207, 210, 196, 4,   206, 193, 205, 197, 5,   193, 210, 210, 193, 217,
      9,   193, 210, 210, 193, 217, 206, 193, 205, 197, 9,   207, 198, 208, 210, 207, 199, 210, 193, 205, 6,   207, 198,
      198, 201, 204, 197, 6,   207, 198, 204, 201, 211, 212, 6,   198, 207, 210, 205, 193, 212, 4,   211, 208, 197, 195,
      3,   206, 207, 212, 3,   193, 206, 196, 2,   207, 210, 1,   58,  6,   206, 207, 210, 205, 193, 204, 3,   207, 215,
      206, 8,   197, 216, 212, 197, 210, 206, 193, 204, 9,   197, 216, 212, 210, 201, 206, 211, 201, 195, 8,   195, 207,
      206, 211, 212, 193, 206, 212, 5,   195, 207, 206, 211, 212, 5,   197, 214, 197, 206, 212, 5,   211, 212, 193, 210,
      212, 9,   212, 200, 197, 206, 211, 212, 193, 210, 212, 4,   212, 200, 197, 206, 9,   197, 204, 211, 197, 211, 212,
      193, 210, 212, 4,   197, 204, 211, 197, 1,   95,  6,   211, 217, 211, 212, 197, 205, 7,   196, 217, 206, 193, 205,
      201, 195, 2,   42,  61,  1,   42,  4,   80,  85,  84,  95,  5,   67,  78,  79,  80,  95,  2,   204, 61,  1,   60,
      1,   62,  4,   40,  196, 210, 43,  2,   196, 210, 1,   194, 3,   212, 207, 211, 3,   204, 206, 194, 3,   216, 206,
      194, 2,   208, 195, 3,   195, 212, 194, 2,   45,  62,  6,   210, 197, 212, 213, 210, 206, 6,   210, 197, 211, 213,
      204, 212, 7,   205, 207, 206, 201, 212, 207, 210, 4,   211, 212, 207, 208, 6,   211, 201, 199, 206, 193, 204, 4,
      197, 216, 201, 212, 8,   195, 207, 206, 212, 201, 206, 213, 197, 6,   198, 201, 206, 201, 211, 200, 5,   195, 217,
      195, 204, 197, 6,   210, 197, 208, 197, 193, 212, 3,   197, 206, 196, 5,   210, 197, 193, 204, 211, 5,   194, 197,
      199, 201, 206, 2,   207, 206, 6,   211, 215, 201, 212, 195, 200, 4,   204, 201, 211, 212, 7,   211, 208, 197, 195,
      201, 193, 204, 14,  212, 210, 213, 211, 212, 197, 196, 208, 210, 207, 199, 210, 193, 205, 6,   205, 193, 201, 206,
      197, 208, 7,   195, 207, 206, 212, 210, 207, 204, 7,   201, 206, 195, 204, 213, 196, 197};
  static int Symbol[914 /*1300:2213*/] = {
      1307, 1303, 0,    1305, 2,    1307, 1000, 1319, 1312, 1001, 1357, 1824, 1315, 1003, 1020, 1319, 4,    1336, 6,
      1329, 1323, 1001, 1014, 1325, 1003, 1329, 4,    1329, 6,    1336, 1336, 1010, 1028, 1319, 1011, 1350, 1343, 1343,
      1010, 1028, 1307, 1011, 1343, 1350, 1348, 1026, 1307, 999,  1350, 1000, 1357, 1355, 1026, 1319, 999,  1357, 1000,
      1365, 1363, 4,    1336, 1365, 6,    1365, 1000, 1372, 1370, 8,    1336, 999,  1372, 1000, 1377, 1375, 10,   1377,
      13,   1401, 1384, 20,   1010, 1542, 1562, 1011, 1390, 26,   1010, 1542, 1562, 1011, 1401, 32,   1010, 1001, 36,
      1336, 8,    1336, 8,    1336, 1011, 1408, 1406, 8,    1001, 999,  1408, 1000, 1415, 1411, 38,   1413, 43,   1415,
      51,   1430, 1418, 43,   1420, 38,   1423, 60,   1408, 1425, 65,   1428, 77,   1925, 1430, 84,   1437, 1433, 96,
      1437, 1031, 1415, 1437, 1444, 1440, 104,  1442, 107,  1444, 111,  1466, 1450, 1415, 1476, 1001, 1401, 1456, 120,
      1466, 127,  1001, 1401, 1462, 1430, 1471, 1001, 1401, 1483, 1466, 127,  1001, 1401, 1471, 1469, 132,  1471, 1000,
      1476, 1474, 127,  1476, 1000, 1483, 1479, 138,  1481, 127,  1483, 1000, 1493, 1491, 4,    1010, 1444, 1011, 1493,
      6,    1493, 1000, 1502, 1500, 1030, 1010, 1444, 1011, 999,  1502, 1000, 1513, 1506, 148,  1016, 1508, 158,  1511,
      165,  1018, 1513, 1016, 1518, 1516, 172,  1518, 1000, 1542, 1526, 172,  1001, 4,    1876, 1869, 6,    1535, 179,
      1010, 1001, 1818, 1011, 4,    1001, 6,    1542, 1010, 1615, 1011, 4,    1001, 6,    1556, 1548, 1336, 1032, 1336,
      1556, 1553, 4,    1542, 1562, 6,    1556, 184,  1542, 1562, 1560, 1037, 1336, 1562, 1000, 1573, 1567, 188,  1542,
      1573, 1571, 192,  1542, 1580, 1573, 1000, 1580, 1578, 188,  1542, 999,  1580, 1000, 1587, 1585, 192,  1542, 999,
      1587, 1000, 1595, 1591, 1033, 1336, 1593, 195,  1595, 1000, 1601, 1599, 179,  1008, 1601, 1015, 1606, 1604, 60,
      1606, 197,  1615, 1613, 8,    1336, 195,  1336, 1606, 1615, 1000, 1624, 1620, 1476, 1001, 1401, 1624, 132,  1513,
      1624, 1630, 1630, 1001, 1401, 1832, 1630, 1636, 1634, 8,    1624, 1636, 1000, 1652, 1646, 1476, 1010, 1001, 1401,
      1840, 1011, 1652, 1006, 1652, 132,  1513, 1001, 1832, 1701, 1663, 1661, 8,    1010, 1001, 1401, 1840, 1011, 1652,
      1663, 1000, 1674, 1666, 204,  1668, 208,  1670, 217,  1672, 227,  1674, 236,  1701, 1678, 1415, 1636, 1689, 120,
      1476, 1010, 1001, 1401, 1011, 4,    1001, 6,    1006, 1701, 120,  132,  1513, 1010, 1001, 1832, 1011, 4,    1001,
      6,    1006, 1711, 1709, 36,   1028, 1319, 1350, 1722, 1711, 1711, 1000, 1722, 1720, 8,    1012, 1028, 1319, 1350,
      1722, 999,  1722, 1000, 1731, 1729, 4,    1028, 1319, 1350, 6,    1731, 1000, 1738, 1736, 8,    1009, 999,  1738,
      1000, 1743, 1741, 242,  1743, 1000, 1749, 1747, 8,    1336, 1749, 1000, 1762, 1760, 8,    1001, 1401, 4,    1336,
      195,  1336, 6,    999,  1762, 1000, 1769, 1767, 26,   1542, 1562, 1769, 1000, 1782, 1772, 1019, 1774, 1006, 1779,
      1372, 1542, 1562, 1006, 1782, 1377, 1006, 1795, 1786, 248,  1034, 1789, 254,  1034, 1795, 264,  1010, 2060, 1011,
      1801, 1801, 1799, 188,  2060, 1801, 1000, 1818, 1805, 269,  1034, 1813, 279,  1372, 1010, 1542, 1562, 1011, 1782,
      1816, 279,  2060, 1818, 1000, 1824, 1822, 284,  1001, 1824, 1000, 1832, 1830, 284,  1001, 1357, 1824, 1832, 1000,
      1840, 1840, 4,    1336, 195,  1336, 1606, 6,    1848, 1846, 36,   1028, 1319, 1350, 1848, 1000, 1858, 1852, 286,
      1013, 1854, 208,  1856, 293,  1858, 1000, 1869, 1867, 1001, 36,   1336, 8,    1336, 8,    1336, 1869, 1000, 1876,
      1874, 8,    1876, 999,  1876, 1000, 1916, 1882, 1415, 1476, 1001, 1401, 1889, 1415, 132,  1001, 1401, 1832, 1916,
      1895, 120,  1466, 127,  1001, 1401, 1904, 120,  1010, 1001, 1401, 1011, 4,    1001, 6,    1916, 120,  132,  1010,
      1001, 1401, 1832, 1916, 1011, 4,    1001, 6,    1925, 1923, 8,    1001, 1401, 1832, 999,  1925, 1000, 1932, 1930,
      4,    1009, 6,    1932, 1000, 1950, 1936, 301,  1001, 1939, 304,  1001, 1942, 306,  1002, 1945, 1022, 1950, 1950,
      311,  1009, 8,    1009, 1964, 1954, 1023, 1964, 1959, 1024, 317,  2003, 2008, 1964, 1025, 1005, 8,    1987, 1987,
      1969, 320,  1001, 322,  1971, 2036, 1976, 4,    2036, 2025, 6,    1980, 324,  2036, 6,    1985, 4,    329,  2025,
      6,    1987, 332,  2003, 1992, 320,  1001, 322,  1994, 2036, 1999, 4,    329,  2025, 6,    2003, 324,  1005, 6,
      2008, 2006, 329,  2008, 1005, 2016, 2014, 8,    1005, 8,    1005, 2016, 1000, 2025, 2020, 0,    1005, 2023, 2,
      1005, 2025, 1000, 2031, 2029, 0,    332,  2031, 1000, 2036, 2034, 36,   2036, 1000, 2051, 2041, 2031, 1300, 1003,
      2044, 1001, 2016, 2049, 4,    2051, 2016, 6,    2051, 334,  2060, 2054, 338,  2056, 342,  2058, 346,  2060, 349,
      2093, 2069, 1010, 1001, 1357, 1824, 1011, 1587, 1795, 2073, 353,  1001, 1357, 2075, 356,  2079, 363,  1033, 1336,
      2082, 370,  1795, 2084, 378,  2089, 383,  1738, 1009, 1743, 2091, 390,  2093, 395,  2214, 2100, 1027, 1010, 2060,
      1011, 1769, 2102, 1007, 2110, 1372, 1010, 1542, 1562, 1011, 1782, 1006, 2115, 404,  1035, 1801, 1006, 2120, 411,
      1029, 1858, 1006, 2125, 417,  1036, 1762, 1006, 2130, 1377, 411,  1029, 1006, 2136, 1031, 1008, 1415, 1615, 1006,
      2140, 424,  1502, 1006, 2144, 120,  1518, 1006, 2153, 1010, 1848, 1430, 1011, 1595, 1001, 1483, 1006, 2156, 1663,
      1674, 2160, 428,  1601, 1006, 2164, 434,  1015, 1006, 2173, 440,  1021, 1738, 1009, 1731, 248,  1034, 1006, 2184,
      443,  1001, 1401, 4,    1336, 195,  1336, 6,    1749, 1006, 2188, 450,  1006, 1017, 2193, 455,  127,  1001, 1006,
      2197, 304,  1932, 1006, 2200, 463,  1006, 2204, 478,  1001, 1006, 2208, 485,  1003, 1006, 2212, 493,  1003, 1038,
      2214, 1006};
  static const int Ss = 2093;
  static const unsigned char Itoetab[128 /*0:127*/] = {
      0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x15, 0x40, 0x0C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
      0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x4F, 0x7F, 0x7B, 0x5B, 0x6C,
      0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
      0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2,
      0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0x4A, 0x5F, 0x5A, 0x6A,
      0x6D, 0x7C, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
      0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x40, 0xD0, 0x40, 0x40};
  static const int Opc[127 /*0:126*/] = {
      0,      ' JCC', ' JAT', ' JAF', [4 ... 7] = 0, ' VAL', ' CYD', 'INCA', 'MODD', 'PRCL', '   J', ' JLK', 'CALL',
      ' ADB', ' SBB', 'DEBJ', ' CPB', ' SIG',        ' MYB', ' VMY', 'CPIB', ' LCT', 'MPSR', 'CPSR', 'STCT', 'EXIT',
      'ESEX', ' OUT', ' ACT', '  SL', 'SLSS',        'SLSD', 'SLSQ', '  ST', 'STUH', 'STXN', 'IDLE', ' SLD', ' SLB',
      'TDEC', 'INCT', ' STD', ' STB', 'STLN',        'STSF', '   L', ' LSS', ' LSD', ' LSQ', 'RRTC', ' LUH', 'RALN',
      ' ASF', 'LDRL', ' LDA', 'LDTB', ' LDB',        '  LD', '  LB', ' LLN', ' LXN', ' TCH', 'ANDS', ' ORS', 'NEQS',
      'EXPA', ' AND', '  OR', ' NEQ', '  PK',        ' INS', 'SUPK', ' EXP', 'COMA', ' DDV', 'DRDV', 'DMDV', 'SWEQ',
      'SWNE', ' CPS', ' TTR', ' FLT', ' IDV',        'IRDV', 'IMDV', ' MVL', '  MV', 'CHOV', ' COM', ' FIX', ' RDV',
      'RRDV', 'RDVD', ' UAD', ' USB', 'URSB',        ' UCP', ' USH', ' ROT', ' SHS', ' SHZ', ' DAD', ' DSB', 'DRSB',
      ' DCP', ' DSH', ' DMY', 'DMYD', 'CBIN',        ' IAD', ' ISB', 'IRSB', ' ICP', ' ISH', ' IMY', 'IMYD', 'CDEC',
      ' RAD', ' RSB', 'RRSB', ' RCP', ' RSC',        ' RMY', 'RMYD'};
  static const unsigned char Onecase[128 /*0:127*/] = {
      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,  20,  21,  22,  23, 24, 25,
      26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,  46,  47,  48,  49, 50, 51,
      52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,  72,  73,  74,  75, 76, 77,
      78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 65,  66,  67,  68,  69, 70, 71,
      72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127};
  static const int Tsname[63 /*0:62*/] = {[0 ... 7] = 0x1000,
                                          0x1001,
                                          [9 ... 13] = 0x1000,
                                          0x1001,
                                          0x1062,
                                          [16 ... 17] = 0x1001,
                                          0x1062,
                                          [19 ... 20] = 0x1000,
                                          0x52,
                                          0x51,
                                          0x62,
                                          [24 ... 30] = 0x1062,
                                          0x1000,
                                          0x31,
                                          0x51,
                                          [34 ... 35] = 0x1062,
                                          0x31,
                                          0x1000,
                                          0x51,
                                          0x62,
                                          [40 ... 41] = 0x1000,
                                          0x35,
                                          0x1000,
                                          0x1035,
                                          0x31,
                                          0x35,
                                          0x1035,
                                          0x33,
                                          0,
                                          0x1000,
                                          0x31,
                                          0x52,
                                          0x51,
                                          0x61,
                                          0x72,
                                          0x61,
                                          0x72,
                                          0x51,
                                          0x62,
                                          0x1051,
                                          0x41,
                                          0x1000};
  static int Fixedgla[12 /*0:11*/] = {0, 0x50000000, [2 ... 3] = 0, -1, 0, [6 ... 11] = 0};
  static const unsigned char Bytes[8 /*0:7*/] = {[0 ... 2] = 0, 1, 2, 4, 8, 16};
  static const unsigned char Trtab[256 /*0:255*/] = {[0 ... 47] = 0,    [48 ... 57] = 1,  [58 ... 64] = 0,
                                                     [65 ... 90] = 2,   [91 ... 96] = 0,  [97 ... 122] = 2,
                                                     [123 ... 127] = 0, [128 ... 255] = 0};
  static const int Maxlevels = 31;
  static const int Concop = 13;
  static const int Fixedglalen = 48;
  static const int Jobberbit = 0x40000000;
  static const int Cebit = 1;
  static const int Maxdict = 0x100;
  static const int Lb = 0x7A;
  static const int Slb = 0x52;
  static const int Stb = 0x5A;
  static const int Adb = 0x20;
  static const int Cpb = 0x26;
  static const int Myb = 0x2A;
  static const int Sbb = 0x22;
  static const int Cpib = 0x2E;
  static const int Out = 0x3C;
  static const int Cpsr = 0x34;
  static const int Ld = 0x78;
  static const int Lda = 0x72;
  static const int Inca = 0x14;
  static const int Std = 0x58;
  static const int Ldb = 0x76;
  static const int Ldtb = 0x74;
  static const int Ldrl = 0x70;
  static const int Cyd = 0x12;
  static const int Modd = 0x16;
  static const int Sld = 0x50;
  static const int Stln = 0x5C;
  static const int Asf = 0x6E;
  static const int St = 0x48;
  static const int Raln = 0x6C;
  static const int Lxn = 0x7E;
  static const int Lln = 0x7C;
  static const int Lss = 0x62;
  static const int Slss = 0x42;
  static const int Mpsr = 0x32;
  static const int Stsf = 0x5E;
  static const int Luh = 0x6A;
  static const int Stuh = 0x4A;
  static const int Lsd = 0x64;
  static const int Slsd = 0x44;
  static const int Prcl = 0x18;
  static const int Lsq = 0x66;
  static const int Slsq = 0x46;
  static const int Stxn = 0x4C;
  static const int Lct = 0x30;
  static const int Stct = 0x36;
  static const int Junc = 0x1A;
  static const int Jlk = 0x1C;
  static const int Call = 0x1E;
  static const int Exit = 0x38;
  static const int Jcc = 2;
  static const int Jat = 4;
  static const int Jaf = 6;
  static const int Debj = 0x24;
  static const int Iad = 0xE0;
  static const int Icp = 0xE6;
  static const int Ush = 0xC8;
  static const int Isb = 0xE2;
  static const int Irsb = 0xE4;
  static const int Or = 0x8C;
  static const int Ucp = 0xC6;
  static const int Imy = 0xEA;
  static const int Imdv = 0xAe;
  static const int And = 0x8A;
  static const int Ish = 0xE8;
  static const int Imyd = 0xEC;
  static const int Idv = 0xAA;
  static const int Rad = 0xF0;
  static const int Rsb = 0xF2;
  static const int Rrsb = 0xF4;
  static const int Flt = 0xA8;
  static const int Rrdv = 0xBC;
  static const int Rsc = 0xF8;
  static const int Fix = 0xB8;
  static const int Rdv = 0xBA;
  static const int Rddv = 0xBE;
  static const int Rmyd = 0xFC;
  static const int Rmy = 0xFA;
  static const int Mvl = 0xB0;
  static const int Mv = 0xB2;
  static const int Sweq = 0xA0;
  static const int Swne = 0xA2;
  static const int Cps = 0xA4;
  static const int Accr = 0;
  static const int Dr = 1;
  static const int Lnb = 2;
  static const int Xnb = 3;
  static const int Pc = 4;
  static const int Ctb = 5;
  static const int Tos = 6;
  static const int Breg = 7;
  static const unsigned char Ldcode[8 /*0:7*/] = {0, 0x78, 0x7C, 0x7E, 0, 48, 0, 0x7A};
  static const _imp_string Mdep = _imp_str_literal("S#NDIAG");
  static const _imp_string Iocpep = _imp_str_literal("S#IOCP");
  static const _imp_string Auxstep = _imp_str_literal("ICL9CEAUXST");
  static const int Snpt = 0x1006;
  static const int Commalt = 2;
  static const int Endalt = 9;
  static const int Unasspat = 0x81818181;
  static const int Decalt = 8;
  int Dictbase;
  int Constptr;
  int Constbtm;
  int Dfhead;
  int Consthole;
  int Wkfilead;
  int Wkfilek;
  int Dummyformat;
  int P1size;
  int Levelinf;
  int Iocpdisp;
  int Parmbits1;
  int Parmbits2;
  int Parmlet;
  int Asl;
  int Nnames;
  int Arsize;
  int Cabuf;
  int Ppcurr;
  int Constlimit;
  int Oldline;
  int Line;
  int Length;
  int Nextp;
  int Snum;
  int Rlevel;
  int Nmax;
  int Ustptr;
  int Plabel;
  int Level;
  int Ca;
  int Lastname;
  int Cdcount;
  int Aslcurbtm;
  int Parmdynamic;
  int Faulty;
  int Hit;
  int Inhcode;
  int Imps;
  int Ttoput;
  int List;
  int Parmdiag;
  int Warnflag;
  int Parmtrace;
  int Parmline;
  int Parmopt;
  int Ctype;
  int Dcomp;
  int Cprmode;
  int Parmchk;
  int Parmarr;
  int Alllong;
  int Parmdbug;
  int Compiler;
  int Lastinst;
  int Smap;
  int Stack;
  int Auxst;
  int Parmy;
  int Bfflag;
  int Rbase;
  int N;
  int Freeformat;
  int Parmprof;
  int Exitlab;
  int Contlab;
  int Q;
  int R;
  int S;
  int Nest;
  int Fname;
  int Ldptr;
  int Glaca;
  int Glacabuf;
  int Glacurr;
  int Crefhead;
  int Sstl;
  int Qmax;
  int Stmts;
  int Lastat;
  int Fileaddr;
  int Fileptr;
  int Fileend;
  int Filesize;
  int Lastend;
  int Bimstr;
  int Stlimit;
  int Strlink;
  int Rectb;
  int Aslwarn;
  int Ihead;
  int Maxulab;
  int Sflabel;
  double Cvalue;
  double Imax;
  double Ctime;
  _imp_string Mainep;
  typedef struct Listf {
    int S1;
    int S2;
    int S3;
    int Link;
  } Listf;
  int Logepdisp;
  int Expepdisp;
  extern int *Comreg(int N);
  {
    Fileaddr = *Comreg(46);
    Parmbits1 = *Comreg(27);
    Parmbits2 = *Comreg(28);
    Wkfilead = *Comreg(14);
    Wkfilek = 128;
    if (Fileaddr <= 0) {
      Filesize = 64000;
      Fileaddr = 0;
    } else {
      Fileptr = Fileaddr + *Integer(Fileaddr + 4);
      Fileend = Fileaddr + *Integer(Fileaddr);
      Filesize = *Integer(Fileaddr);
    }
    Nnames = 255;
    if (Filesize > 10000) Nnames = 511;
    if (!(Parmbits1 & Jobberbit)) {
      if (Filesize > 32000) Nnames = 1023;
      if (Filesize > 256 * 1024 || (Parmbits2 & Maxdict) != 0 || Wkfilek > 512) Nnames = 2047;
    }
    Asl = 3 * Nnames;
    if (Asl > 4095 && (Parmbits2 & Maxdict) == 0) Asl = 4095;
    Arsize = Wkfilek * 768 - 300;
    unsigned char A[(Wkfilek * 1024) + 1];
    Listf Aslist[Asl + 1];
    int Word[Nnames + 1];
    int Tags[Nnames + 1];
    int Dvheads[13 /*0:12*/];
    auto int Fromar4(int Ptr);
    auto int Fromar2(int Ptr);
    auto void Toar8(int Ptr, double Value);
    auto void Toar4(int Ptr, int Value);
    auto void Toar2(int Ptr, int Value);
    auto void Warn(int N, int V);
    auto void Fault2(int N, int Val, int Iden);
    auto void Fault(int N, int Value);
    auto _imp_string Printname(int N);
    auto int Morespace(void);
    auto void Insertatend(int *S, int A, int B, int C);
    auto void From12(int Cell, int *S1, int *S2);
    auto void From123(int Cell, int *S1, int *S2, int *S3);
    auto void Pop(int *C, int *P, int *Q, int *R);
    auto void Push(int *C, int S1, int S2, int S3);
    auto int Find(int Lab, int List);
    auto void Mlink(int *Cell);
    auto void Replace1(int Cell, int S1);
    auto void Replace2(int Cell, int S2);
    auto void Replace3(int Cell, int S3);
    auto void Replace123(int Cell, int A1, int A2, int S3);
    auto int From2(int Cell);
    auto int From1(int Cell);
    auto int From3(int Cell);
    auto void Binsert(int *T, int *B, int S1, int S2, int S3);
    auto void Clearlist(int *Head);
    auto _imp_string Message(int N);
    extern void Lput(int A, int B, int C, int D);
    extern double Cputime(void);
    extern void Ncode(int Start, int Finish, int Ca);
    auto void Printlist(int Head);
    auto void Prhex(int Value, int Places);
    auto void Checkasl(void);
#if 1 /*  !Vmeb */
    extern void Consource(_imp_string File, int *Ad);
#endif

    {
      auto void Readline(int Mode, int Char);
      auto int Compare(int P);
      auto void Pname(int Mode);
      auto void Const(int Mode);
      auto void Texttext(int Ebcdic);
      int Ccsize;
      int Dsize;
      int Next;
      int Atline1;
      int Starstart;
      Ccsize = 1000;
      Dsize = 7 * Nnames;
      int Display[32 /*0:31*/];
      int Sfs[32 /*0:31*/];
      unsigned char Tline[222 /*-60:161*/];
      unsigned char Cc[Ccsize + 1];
      unsigned char Lett[(Dsize + 20) + 1];
      long long int Atl0;
      long long int Asym0;
      static const unsigned char Ilett[501 /*0:500*/] = {
          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', 10,  'R', 'E', 'A', 'D', 'S', 'T', 'R', 'I', 'N', 'G', 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', 11,  'C', 'L', 'O', 'S', 'E', 'S', 'T', 'R', 'E', 'A', 'M', 11,  'B', 'Y', 'T', 'E', 'I', 'N', 'T',
          'E', 'G', 'E', 'R', 8,   'E', 'V', 'E', 'N', 'T', 'I', 'N', 'F', 6,   'R', 'A', 'D', 'I', 'U', 'S', 6,   'A',
          'R', 'C', 'T', 'A', 'N', 6,   'L', 'E', 'N', 'G', 'T', 'H', 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', 8,   'R', 'E', 'A', 'D', 'I', 'T', 'E',
          'M', 8,   'N', 'E', 'X', 'T', 'I', 'T', 'E', 'M', 6,   'C', 'H', 'A', 'R', 'N', 'O', 8,   'T', 'O', 'S', 'T',
          'R', 'I', 'N', 'G', 10,  'F', 'R', 'O', 'M', 'S', 'T', 'R', 'I', 'N', 'G', 6,   'R', 'E', 'C', 'O', 'R', 'D',
          5,   'A', 'R', 'R', 'A', 'Y', 10,  'S', 'E', 'T', 'M', 'A', 'R', 'G', 'I', 'N', 'S', 4,   'I', 'M', 'O', 'D',
          2,   'P', 'I', 9,   'E', 'V', 'E', 'N', 'T', 'L', 'I', 'N', 'E', 11,  'L', 'O', 'N', 'G', 'I', 'N', 'T', 'E',
          'G', 'E', 'R', 12,  'L', 'O', 'N', 'G', 'L', 'O', 'N', 'G', 'R', 'E', 'A', 'L', 9,   'L', 'E', 'N', 'G', 'T',
          'H', 'E', 'N', 'I', 9,   'L', 'E', 'N', 'G', 'T', 'H', 'E', 'N', 'R', 8,   'S', 'H', 'O', 'R', 'T', 'E', 'N',
          'I', 8,   'S', 'H', 'O', 'R', 'T', 'E', 'N', 'R', 6,   'N', 'E', 'X', 'T', 'C', 'H', 11,  'H', 'A', 'L', 'F',
          'I', 'N', 'T', 'E', 'G', 'E', 'R', 8,   'P', 'P', 'R', 'O', 'F', 'I', 'L', 'E', 255};
      Imax = (unsigned)(-1) >> 1;
      Plabel = 24999;
      Lett[0] = 0;
      Atline1 = Addr(Tline[1]);
      *Integer(Addr(Atl0) + 4) = Atline1 - 1;
      *Integer(Addr(Atl0)) = 0x18000100;
      *Integer(Addr(Asym0)) = 0x28000C00;
      *Integer(Addr(Asym0) + 4) = Addr(Symbol[1300]) - 4 * 1300;
      N = 12;
      Maxulab = Nnames + 16384;
      Glacurr = 0;
      Glaca = Fixedglalen;
      Glacabuf = Glaca;
      Parmopt = 1;
      Parmarr = 1;
      Lastinst = 0;
      Parmline = 1;
      Parmtrace = 1;
      Parmdiag = 1;
      List = 1;
      Sflabel = 20999;
      Parmchk = 1;
      Exitlab = 0;
      Contlab = 0;
      Cabuf = 0;
      Ppcurr = 0;
      Oldline = 0;
      Compiler = 0;
      Rlevel = 0;
      Nmax = 0;
      Ustptr = 0;
      Level = 0;
      Ca = 0;
      Lastat = 0;
      Faulty = 0;
      Warnflag = 0;
      Alllong = 0;
      Inhcode = 0;
      Dcomp = 0;
      Bfflag = 0;
      Cprmode = 0;
      Next = 1;
      Ldptr = 0;
      Iocpdisp = 0;
      Crefhead = 0;
      Auxst = 0;
      Rbase = 10;
      Logepdisp = 0;
      Expepdisp = 0;
      Strlink = 0;
      Rectb = 0;
      Ihead = 0;
      Sstl = 0;
      Stmts = 1;
      Snum = 0;
      Levelinf = 0;
      Cdcount = 0;
      Bimstr = 0;
      Logepdisp = 0;
      Expepdisp = 0;
      Mainep = _imp_str_literal("S#GO");
      Dictbase = Addr(Lett[0]);
      Lput(0, 0, 0, 0);
      Ctime = Cputime();
      I = *Comreg(27);
      Stlimit = 0x1F000;
      if ((unsigned)I >> 24 & 1) Stlimit = *Comreg(48) - 4096;
      if ((I & 2) == 2) List = 0;
      if ((I & 4) == 4) Parmdiag = 0;
      if (I & 0x800000) Parmline = 0;
      if ((I & 16) == 16) Parmchk = 0;
      if ((I & 32) == 32) Parmarr = 0;
      Parmprof = ((unsigned)I >> 15 & 1) | ((unsigned)I >> 7 & 1);
      Parmdynamic = (unsigned)I >> 20 & 1;
      Parmlet = (unsigned)I >> 13 & 1;
      Dcomp = (unsigned)I >> 14 & 1;
      Parmdbug = (unsigned)I >> 18 & 1;
      if ((I & 64) == 64) {
        Parmtrace = 0;
        Parmdiag = 0;
      }
      Freeformat = I & 0x80000;
      Stack = (unsigned)I >> 3 & 1;
      Smap = (unsigned)I >> 26 & 1;
      Ttoput = *Comreg(40);
      if (I & (1 << 16)) {
        Parmarr = 0;
        Parmopt = 0;
        Parmline = 0;
        Parmchk = 0;
        Parmdiag = 0;
      }
      Parmtrace = Parmtrace | Parmopt;
      Imps = (unsigned)I >> 23 & 1;
      Imps = 1;
      Newlines(3);
      Spaces(14);
      Printstring(_imp_str_literal("ERCC. Imp"));
      if (Imps) Printsymbol('s');
      Printstring(_imp_str_literal(" Compiler Release"));
      Write(Release, 1);
      Printstring(_imp_join(_imp_str_literal(" Version "), Ladate));
      Newlines(3);
      Write(Nnames, 5);
      Write(Asl, 5);
      Newline();
      Aslwarn = 0;
      Aslcurbtm = Asl - 240;
      Constlimit = 4 * Aslcurbtm - 8;
      for (I = Aslcurbtm; I <= Asl - 1; I++) Aslist[I + 1].Link = I;
      Aslist[Aslcurbtm].Link = 0;
      Aslist[0].S1 = -1;
      Aslist[0].S2 = -1;
      Aslist[0].S3 = -1;
      Aslist[0].Link = 0;
      for (I = 0; I <= Nnames; I++) {
        Word[I] = 0;
        Tags[I] = 0;
      }
      for (I = 0; I <= 12; I++) Dvheads[I] = 0;
      K = 0;
      Next = 1;
      I = Ilett[0];
      while (I < 255) {
        for (J = I; J >= 1; J--) Cc[J] = Ilett[K + J];
        Cc[I + 1] = ';';
        R = 2;
        Q = 1;
        Pname(1);
        Push(Tags[Lastname], Snpt << 16 | 0x8000, 0, Snum << 16);
        Snum++;
        K = K + I + 1;
        I = Ilett[K];
      }
      *Comreg(24) = 16;
      Dummyformat = 0;
      Dfhead = 0;
      Push(Dfhead, 0, 0, 0);
      Push(Dummyformat, 0, 0, Dfhead);
      Line = 0;
      Length = 0;
      Q = 1;
      R = 1;
      Level = 1;
      for (;;) {
        if (Q >= Length) {
          Qmax = 1;
          Readline(0, 0);
        }
        Warnflag = 0;
        Starstart = R;
        R += 3;
        Oldline = Line;
        A[R] = (unsigned)Line >> 8;
        A[R + 1] = Line & 255;
        R += 2;
        if (!Compare(Ss)) {
          Fault(100, Addr(Cc[0]));
          R = Starstart;
        } else {
          if (R > Arsize) Fault(102, 0);
          if (A[Starstart + 5] == Commalt)
            R = Starstart;
          else {
            I = R - Starstart;
            A[Starstart] = (unsigned)I >> 16;
            A[Starstart + 1] = (unsigned)I >> 8 & 255;
            A[Starstart + 2] = I & 255;
            if (A[Starstart + 5] == Decalt && Level > 1) {
              if (!Sfs[Level]) {
                Toar4(Display[Level], Starstart);
                Display[Level] = Starstart + 6;
              } else
                A[Starstart + 6] = 128;
            }
            if (Smap) {
              Newline();
              Write(Line, 5);
              Write(Starstart, 5);
              Newline();
              J = 0;
              for (I = Starstart; I <= R - 1; I++) {
                Write(A[I], 5);
                J++;
                if (J >= 20) {
                  Newline();
                  J = 0;
                }
              }
              Newline();
            }
            if (A[Starstart + 5] == Endalt && 1 <= A[Starstart + 6] && A[Starstart + 6] <= 2) break;
            if (!Level) {
              Fault(14, 0);
              break;
            }
          }
        }
      }
      Toar8(R, 0);
      R += 8;
      if (R + Next > Arsize) Fault(102, 0);
      P1size = R;
      for (I = 0; I <= Next; I++) A[R + I] = Lett[I];
      Dictbase = Addr(A[R]);
      R = R + Next + 1;
      goto Bend;
      void Readline(int Mode, int Char) {
        auto void Getline(void);
        int Del;
        int Ll;
        int Lp;
        Ll = 0;
        Lp = 0;
        Q = 1;
        Length = 0;
        Del = 0;
      Next:;
        Lp++;
        if (Lp > Ll) {
          Getline();
          Lp = 1;
        }
        I = Tline[Lp];
        if (!Mode) {
          if (I == '%') {
            Del = 128;
            goto Next;
          }
          I = Onecase[I];
          if ('A' <= I && I <= 'Z')
            I = I | Del;
          else {
            Del = 0;
            if (I == ' ') goto Next;
          }
          Length++;
          Cc[Length] = I;
          if (I == '\'' || I == 34) {
            Mode = 1;
            Char = I;
          }
        } else {
          Length++;
          Cc[Length] = I;
          if (I == Char) Mode = 0;
        }
        if (I != Nl) goto Next;
        if (Cc[Length - 1] == 'C' + 128) {
          Length -= 2;
          goto Next;
        }
        if (Length > Ccsize) Fault(101, 0);
        return;
        void Getline(void) {
          extern void Iocp(int A, int B);
          static const unsigned char Itoi[256 /*0:255*/] = {[0 ... 9] = 32,
                                                            10,
                                                            [11 ... 24] = 32,
                                                            25,
                                                            26,
                                                            [27 ... 31] = 32,
                                                            32,
                                                            33,
                                                            34,
                                                            35,
                                                            36,
                                                            37,
                                                            38,
                                                            39,
                                                            40,
                                                            41,
                                                            42,
                                                            43,
                                                            44,
                                                            45,
                                                            46,
                                                            47,
                                                            48,
                                                            49,
                                                            50,
                                                            51,
                                                            52,
                                                            53,
                                                            54,
                                                            55,
                                                            56,
                                                            57,
                                                            58,
                                                            59,
                                                            60,
                                                            61,
                                                            62,
                                                            63,
                                                            64,
                                                            65,
                                                            66,
                                                            67,
                                                            68,
                                                            69,
                                                            70,
                                                            71,
                                                            72,
                                                            73,
                                                            74,
                                                            75,
                                                            76,
                                                            77,
                                                            78,
                                                            79,
                                                            80,
                                                            81,
                                                            82,
                                                            83,
                                                            84,
                                                            85,
                                                            86,
                                                            87,
                                                            88,
                                                            89,
                                                            90,
                                                            91,
                                                            92,
                                                            93,
                                                            94,
                                                            95,
                                                            96,
                                                            97,
                                                            98,
                                                            99,
                                                            100,
                                                            101,
                                                            102,
                                                            103,
                                                            104,
                                                            105,
                                                            106,
                                                            107,
                                                            108,
                                                            109,
                                                            110,
                                                            111,
                                                            112,
                                                            113,
                                                            114,
                                                            115,
                                                            116,
                                                            117,
                                                            118,
                                                            119,
                                                            120,
                                                            121,
                                                            122,
                                                            123,
                                                            124,
                                                            125,
                                                            126,
                                                            32,
                                                            [128 ... 132] = 26,
                                                            10,
                                                            [134 ... 143] = 26,
                                                            [144 ... 159] = 26,
                                                            [160 ... 173] = 26,
                                                            92,
                                                            38,
                                                            [176 ... 186] = 26,
                                                            35,
                                                            [188 ... 191] = 26,
                                                            [192 ... 207] = 26,
                                                            [208 ... 216] = 26,
                                                            35,
                                                            [218 ... 222] = 26,
                                                            94,
                                                            [224 ... 255] = 26};
          int K;
          Ll = 0;
          if (!Fileaddr) do {
              Readsymbol(K);
              Tline[Ll + 1] = Itoi[K];
              Ll++;
            } while (K != Nl);
          else {
            if (Fileptr >= Fileend) {
              if (Ihead) {
                Pop(Ihead, Fileaddr, Fileptr, Fileend);
                Getline();
                return;
              }
              _imp_signal(9, 1, 0, _imp_str_literal(""));
            }
          Imp:;
            do {
              K = *Byteinteger(Fileptr);
              Fileptr++;
              Tline[Ll + 1] = Itoi[K];
              Ll++;
            } while (K != Nl && K != 0);
          Olist:;
          }
          Line++;
          if (List) {
            if (Mode == 0 && Length > 0)
              Printstring(_imp_str_literal("     C"));
            else
              Write(Line, 5);
            for (K = -7; K <= 0; K++) Tline[K] = ' ';
            if (Mode) Tline[-7] = '"';
            Tline[-8] = Ll + 8;
            Iocp(15, Addr(Tline[-8]));
          }
          if (Freeformat == 0 && Ll > 73) {
            Tline[73] = 10;
            Ll = 73;
          }
        }
      }
      int Compare(int P) {
        int I;
        int J;
        int Item;
        int Ra;
        int Rl;
        int Rp;
        int Rq;
        int Rr;
        int Rs;
        int Marker;
        int Ssl;
        int Alt;
        int Pp;
        static int Savecomp;
        static int Bip_sw;
        static void *Bip[40 /*999:1038*/] = {
            &&Bip_999,  &&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, &&Bip_1020, &&Bip_1021, &&Bip_1022,
            &&Bip_1023, &&Bip_1024, &&Bip_1025, &&Bip_1026, &&Bip_1027, &&Bip_1028, &&Bip_1029, &&Bip_1030,
            &&Bip_1031, &&Bip_1032, &&Bip_1033, &&Bip_1034, &&Bip_1035, &&Bip_1036, &&Bip_1037, &&Bip_1038,
        };
        Rp = Symbol[P];
        Rl = Level;
        P++;
        Pp = P;
      Comm:;
        Rq = Q;
        Rr = R;
        Ssl = Strlink;
        Alt = 1;
        Ra = Symbol[P];
        Rs = P;
      Upr:
        R++;
      Succ:;
        Rs++;
        if (Rs == Ra) goto Fini;
        Item = Symbol[Rs];
        if (Item < 999) goto Lit;
        if (Item < 1300) goto *Bip[Bip_sw = (Item)-999];
        if (!Compare(Item)) goto Fail;
        goto Succ;
      Lit:;
        I = Cc[Q];
        if (I != Clett[Item + 1]) goto Fail;
        Q++;
        K = Clett[Item] + Item;
        Item += 2;
        while (Item <= K) {
          if (Cc[Q] != Clett[Item]) goto Fail;
          Q++;
          Item++;
        }
        goto Succ;
      Fail:;
        if (Ra == Rp) goto Tfail;
        if (Q > Qmax) Qmax = Q;
        Q = Rq;
        R = Rr + 1;
        Strlink = Ssl;
        Alt++;
        Rs = Ra;
        Ra = Symbol[Ra];
        goto Succ;
      Tfail:;
        Level = Rl;
        return (0);
      Bip_999:;
        A[Rr] = Alt;
        P = Pp;
        goto Comm;
      Bip_1000:
      Fini:;
        A[Rr] = Alt;
        return (1);
      Bip_1001:;
      Bip_1004:;
        I = Cc[Q];
        if (Trtab[I] != 2) goto Fail;
        Pname(Item - 1004);
        if (Hit == 1) goto Succ;
        goto Fail;
      Bip_1002:;
      Bip_1003:;
        Const(Item - 1003);
        if (!Hit) goto Fail;
        goto Succ;
      Bip_1005:;
        I = Cc[Q];
        if ('0' > I || I > '9') goto Fail;
        S = 0;
        while ('0' <= I && I <= '9') {
          S = 10 * S + (I & 15);
          Q++;
          I = Cc[Q];
        }
        Toar2(R, S);
        R += 2;
        goto Succ;
      Bip_1006:;
        I = Cc[Q];
        if (I == Nl) goto Succ;
        if (I != ';') goto Fail;
        Q++;
        goto Succ;
      Bip_1007:;
        I = Cc[Q];
        J = I;
        if (I == ';' || I == Nl) goto Tx;
        if (I != '!' && I != '|' &&
            (I != 'C' + 128 || Cc[Q + 1] != 'O' + 128 || Cc[Q + 2] != Cc[Q + 3] || Cc[Q + 3] != 'M' + 128 ||
             Cc[Q + 4] != 'E' + 128 || Cc[Q + 5] != 'N' + 128 || Cc[Q + 6] != 'T' + 128))
          goto Fail;
        Q = Q + 1 + 6 * ((unsigned)I >> 7);
        J = Cc[Q];
        for (;;) {
          if (J == Nl || J == ';') break;
          Q++;
          J = Cc[Q];
        }
      Tx:
        if (J == ';') Q++;
        goto Succ;
      Bip_1008:;
        Toar4(R, 0);
        R += 4;
        goto Succ;
      Bip_1009:;
        I = Cc[Q];
        if ('0' > I || I > '9') goto Fail;
        S = 0;
        while ('0' <= I && I <= '9') {
          S = 10 * S + (I & 15);
          Q++;
          I = Cc[Q];
        }
        if (0 > S || S > 255) goto Fail;
        A[R] = S;
        goto Upr;
      Bip_1010:;
        Marker = R;
        R += 2;
        goto Succ;
      Bip_1011:;
        I = R - Marker;
        A[Marker + 1] = I;
        A[Marker] = (unsigned)I >> 8;
        goto Succ;
      Bip_1012:;
        I = Cc[Q];
        while (I == Nl) {
          Readline(0, 0);
          Rq = 1;
          I = Cc[Q];
        }
        if (R > Arsize) Fault(102, 0);
        goto Succ;
      Bip_1013:;
        if (Imps != 1) goto Fail;
        goto Succ;
      Bip_1014:;
        A[R] = 2;
        A[R + 1] = 2;
        R += 2;
        goto Succ;
      Bip_1015:;
        Level++;
        Toar4(R, 0);
        Display[Level] = R;
        Sfs[Level] = 0;
        R += 4;
        goto Succ;
      Bip_1016:;
        Display[Level] = 0;
        while (Sfs[Level]) {
          Pop(Sfs[Level], I, J, K);
          if (I == 1) Fault2(53, K, 0);
          if (I == 2) Fault2(13, K, 0);
        }
        Level--;
        goto Succ;
      Bip_1017:;
        List = 1;
        goto Succ;
      Bip_1018:;
        List = 0;
        goto Succ;
      Bip_1019:;
        if (Cc[Q - 1] != ':') goto Fail;
        goto Succ;
      Bip_1020:;
        if (Ctype == 5) {
          Toar4(S - 4, Strlink);
          Strlink = S - 4;
        }
        goto Succ;
      Bip_1021:;
        Parmtrace = 1;
        goto Succ;
      Bip_1022:;
        I = Cc[Q];
        S = '    ';
        while ('A' <= I && I <= 'Z') {
          S = S << 8 | I;
          Q++;
          I = Cc[Q];
        }
        if (I != '_' || S == '    ') goto Fail;
        Q++;
        goto Succ;
      Bip_1023:;
        for (I = 7; I <= 126; I++)
          if (Opc[I] == S) goto Pfnd;
        goto Fail;
      Pfnd:;
        if (8 <= (unsigned)I >> 3 && (unsigned)I >> 3 <= 11 && (I & 7) <= 3) goto Fail;
        A[R] = 2 * I;
        goto Upr;
      Bip_1024:;
        for (I = 64; I <= 88; I += 8)
          for (J = 0; J <= 3; J++)
            if (Opc[I + J] == S) goto Sfnd;
        goto Fail;
      Sfnd:
        A[R] = 2 * (I + J);
        goto Upr;
      Bip_1025:;
        for (I = 3; I >= 1; I--)
          if (Opc[I] == S) {
            A[R] = 2 * I;
            goto Upr;
          }
        goto Fail;
      Bip_1026:;
        I = Cc[Q];
        if (32 >= I || I >= 127 || ((unsigned)0x80000000 >> ((I - 32) & 31) & 0x4237000A) == 0) goto Fail;
        Q++;
        if (I == '+') {
          A[R] = 1;
          goto Upr;
        }
        if (I == '-') {
          A[R] = 2;
          goto Upr;
        }
        if (I == '&') {
          A[R] = 3;
          goto Upr;
        }
        J = Cc[Q];
        if (I == '*') {
          if (J != I) {
            A[R] = 6;
            goto Upr;
          }
          if (Cc[Q + 1] == I && I == Cc[Q + 2]) {
            A[R] = 4;
            Q += 3;
            goto Upr;
          }
          A[R] = 5;
          Q++;
          goto Upr;
        }
        if (I == '/') {
          if (J != I) {
            A[R] = 10;
            goto Upr;
          }
          A[R] = 9;
          Q++;
          goto Upr;
        }
        if (I == '!') {
          if (J != I) {
            A[R] = 8;
            goto Upr;
          }
          A[R] = 7;
          Q++;
          goto Upr;
        }
        if (I == '.') {
          A[R] = 13;
          goto Upr;
        }
        if (I == J && J == '<') {
          A[R] = 12;
          Q++;
          goto Upr;
        }
        if (I == J && J == '>') {
          A[R] = 11;
          Q++;
          goto Upr;
        }
        if (I == '\\') {
          if (J != I) {
            A[R] = 15;
            goto Upr;
          }
          Q++;
          A[R] = 14;
          goto Upr;
        }
        goto Fail;
      Bip_1027:;
        I = Cc[Q];
        if (Trtab[I] == 2 || I == '-') goto Succ;
        if ((unsigned)0x80000000 >> (I & 31) & 0x14043000) goto Succ;
        goto Fail;
      Bip_1028:;
        I = Cc[Q];
        if (I == '\\' || I == 0x7E) {
          A[R] = 3;
          Q++;
          goto Upr;
        }
        if (I == '-') {
          A[R] = 2;
          Q++;
          goto Upr;
        }
        if (I == '+') {
          A[R] = 1;
          Q++;
          goto Upr;
        }
        A[R] = 4;
        goto Upr;
      Bip_1029:;
        Toar4(R, 0);
        Push(Sfs[Level], 2, R, Line);
        R += 4;
        goto Succ;
      Bip_1030:;
        I = Cc[Q];
        if (I == ')') goto Fail;
        if (I == ',') Q++;
        goto Succ;
      Bip_1031:;
        I = Cc[Q];
        if (I <= 128 || ((unsigned)0x80000000 >> (I & 31) & 0x20C83000) == 0 ||
            ((unsigned)0x80000000 >> (Cc[Q + 2] & 31) & 0x400A2800) == 0)
          goto Fail;
        goto Succ;
      Bip_1032:;
      Bip_1037:;
        I = Cc[Q];
        if (32 >= I || I > 92 || ((unsigned)0x80000000 >> (I & 31) & 0x1004000E) == 0) goto Fail;
        if (I == '=') {
          if (Cc[Q + 1] == I) {
            J = 9;
            goto Join1;
          }
          J = 1;
          goto Join;
        }
        if (I == '#') {
          if (Cc[Q + 1] == I) {
            J = 10;
            goto Join1;
          }
          J = 4;
          goto Join;
        }
        if (I == '\\' && Cc[Q + 1] == '=') {
          Q++;
          if (Cc[Q + 1] == '=') {
            J = 10;
            goto Join1;
          }
          J = 4;
          goto Join;
        }
        if (I == '>') {
          if (Cc[Q + 1] == '=') {
            J = 2;
            goto Join1;
          }
          J = 3;
          goto Join;
        }
        if (I == '<') {
          if (Cc[Q + 1] == '=') {
            J = 5;
            goto Join1;
          }
          J = 6;
          goto Join;
        }
        if (I == '-' && Cc[Q + 1] == '>') {
          J = 8;
          goto Join1;
        }
        goto Fail;
      Join1:
        Q++;
      Join:
        Q++;
        A[R] = J;
        if (Item == 1032) {
          Savecomp = J;
          goto Upr;
        }
        if (Savecomp > 6 || J > 6) {
          Q--;
          goto Fail;
        }
        goto Upr;
      Bip_1033:;
        I = Cc[Q];
        if (I == '=') {
          if (Cc[Q + 1] == '=') {
            A[R] = 1;
            Q += 2;
            goto Upr;
          }
          A[R] = 2;
          Q++;
          goto Upr;
        }
        if (I == '<' && Cc[Q + 1] == '-') {
          A[R] = 3;
          Q += 2;
          goto Upr;
        }
        if (I == '-' && Cc[Q + 1] == '>') {
          A[R] = 4;
          Q += 2;
          goto Upr;
        }
        goto Fail;
      Bip_1034:;
        Toar4(R, 0);
        Push(Sfs[Level], 1, R, Line);
        R += 4;
        goto Succ;
      Bip_1035:;
        if (!Sfs[Level]) {
          Fault2(51, 0, 0);
          goto Succ;
        }
        Pop(Sfs[Level], I, J, K);
        if (I == 2) Fault2(59, K, 0);
        Toar4(J, Starstart);
        goto Succ;
      Bip_1036:;
        if (!Sfs[Level]) {
          Fault2(1, 0, 0);
          goto Succ;
        }
        Pop(Sfs[Level], I, J, K);
        if (I == 1) Fault2(52, K, 0);
        Toar4(J, Starstart);
        goto Succ;
      Bip_1038:;
        if (Vmeb == Yes) goto Fail;
        I = Cc[Q];
        if (I != Nl && I != ';') goto Fail;
        if (I == ';') Q++;
        if (Ctype != 5) goto Fail;
        Push(Ihead, Fileaddr, Fileptr, Fileend);
        Consource(*String(Addr(A[S])), Fileaddr);
        Fileptr = Fileaddr + *Integer(Fileaddr + 4);
        Fileend = Fileaddr + *Integer(Fileaddr);
        goto Succ;
      }
      void Pname(int Mode) {
        static const int Hash[8 /*0:7*/] = {71, 47, 97, 79, 29, 37, 53, 59};
        int Jj;
        int Kk;
        int Ll;
        int Fq;
        int Fs;
        int T;
        int S;
        int I;
        long long int Drdes;
        long long int Accdes;
        Hit = 0;
        Fq = Q;
        Fs = Cc[Q];
        if (Trtab[Fs] != 2 || '"' == Cc[Q + 1] || Cc[Q + 1] == '\'') return;
        T = 1;
        Lett[Next + 1] = Fs;
        Jj = 71 * Fs;
        for (;;) {
          Q++;
          I = Cc[Q];
          if (!Trtab[I]) break;
          if (T <= 7) Jj += Hash[T];
          T++;
          Lett[Next + T] = I;
        }
        Lett[Next] = T;
        S = T + 1;
        if (Next + S > Dsize) Fault(103, 0);
        Jj = (Jj + 113 * T) & Nnames;
        for (Kk = Jj; Kk <= Nnames; Kk++) {
          Ll = Word[Kk];
          if (!Ll) goto Hole;
          if (*String(Addr(Lett[Next])) == *String(Addr(Lett[Ll]))) goto Fnd;
        }
        for (Kk = 0; Kk <= Jj; Kk++) {
          Ll = Word[Kk];
          if (!Ll) goto Hole;
          if (*String(Addr(Lett[Next])) == *String(Addr(Lett[Ll]))) goto Fnd;
        }
        Fault(104, 0);
      Hole:
        if (!Mode) {
          Q = Fq;
          return;
        }
        Word[Kk] = Next;
        Next += S;
      Fnd:
        Lastat = Fq;
        Hit = 1;
        Lastname = Kk;
        A[R + 1] = Lastname;
        A[R] = (unsigned)Lastname >> 8;
        R += 2;
        Lastend = Q;
      }
      void Const(int Mode) {
        int Z;
        int Dotseen;
        int Ebcdic;
        int Fs;
        int Cprec;
        int Rr;
        int S;
        int T;
        int Ss;
        double X;
        double Cvalue;
        double Dummy;
        static const double Ten = 10.0;
        Cprec = 5;
        Rr = R;
        R++;
        Dotseen = 0;
        Hit = 0;
        Cvalue = 0;
        Dummy = 0;
        Fs = Cc[Q];
        S = 0;
        if ('0' <= Fs && Fs <= '9') goto N;
        if (Fs == '.' && Mode == 0 && '0' <= Cc[Q + 1] && Cc[Q + 1] <= '9') goto Dot;
        Ctype = 1;
        Ebcdic = 0;
        if (Fs == '\'') goto Quote;
        if (Fs == 34) goto Str2;
        if (Cc[Q + 1] != '\'') goto Notquote;
        Q += 2;
        if (Fs == 'X') goto Hex;
        if (Fs == 'M') goto Mult;
        if (Fs == 'B') goto Bin;
        if (Fs == 'R' && Mode == 0) goto Rhex;
        if (Fs == 'K') goto Oct;
        if (Fs == 'C') {
          Ebcdic = 1;
          goto Mult;
        }
        if (Fs == 'D' && Mode == 0) {
          Cprec = 7;
          if ('0' <= Cc[Q] && Cc[Q] <= '9') goto N;
          if (Cc[Q] == '.') goto Dot;
        }
        Q -= 2;
        return;
      Quote:;
        if (Cc[Q + 2] == '\'') {
          S = Cc[Q + 1];
          Q += 3;
          if (S != '\'') goto Iend;
          if (Cc[Q] == '\'') {
            Q++;
            goto Iend;
          }
        }
        return;
      Notquote:;
        if (Fs != 'E' || Cc[Q + 1] != '"') return;
        Ebcdic = 1;
        Q++;
      Str2:;
        A[Rr] = 0x35;
        Texttext(Ebcdic);
        Ctype = 5;
        return;
      Hex:
        T = 0;
        for (;;) {
          I = Cc[Q];
          Q++;
          if (I == '\'') break;
          T++;
          if ((('0' > I || I > '9') && ('A' > I || I > 'F')) || T >= 17) return;
          if (T == 9) {
            Ss = S;
            S = 0;
          }
          S = (S << 4) + (I & 15) + 9 * ((unsigned)I >> 6);
        }
        if (T > 8) {
          Z = 4 * (T - 8);
          S = S | (Ss << Z);
          Ss = (unsigned)Ss >> (32 - Z);
          Cprec = 6;
        }
      Iend:
        if (Cprec == 6) {
          Toar4(R, Ss);
          R += 4;
        }
        if (Cprec == 5 && 0 <= S && S <= 0x7FFF) {
          Cprec = 4;
          Toar2(R, S);
          R += 2;
        } else {
          Toar4(R, S);
          R += 4;
        }
        if (Mode == 0 || Cprec != 6) Hit = 1;
        A[Rr] = Cprec << 4 | Ctype;
        return;
      Rhex:;
        T = 0;
        for (;;) {
          I = Cc[Q];
          Q++;
          if ((T & 7) == 0 && T != 0) {
            Toar4(R, S);
            R += 4;
            S = 0;
          }
          if (I == '\'') break;
          T++;
          if (('0' > I || I > '9') && ('A' > I || I > 'F')) return;
          S = (S << 4) + (I & 15) + 9 * ((unsigned)I >> 6);
        }
        if (T != 8 && T != 16 && T != 32) return;
        if (T == 32)
          Cprec = 7;
        else
          Cprec = 4 + T / 8;
        A[Rr] = Cprec << 4 | 2;
        Hit = 1;
        return;
      Oct:;
        T = 0;
        for (;;) {
          I = Cc[Q];
          Q++;
          T++;
          if (I == '\'') break;
          if ('0' > I || I > '7' || T >= 12) return;
          S = S << 3 | (I & 7);
        }
        goto Iend;
      Mult:
        T = 0;
        for (;;) {
          I = Cc[Q];
          Q++;
          T++;
          if (I == '\'')
            if (Cc[Q] != '\'')
              break;
            else
              Q++;
          if (T >= 5) return;
          if (Ebcdic) I = Itoetab[I];
          S = S << 8 | I;
        }
        goto Iend;
      Bin:
        T = 0;
        for (;;) {
          I = Cc[Q];
          Q++;
          T++;
          if (I == '\'') break;
          if ('0' > I || I > '1' || T >= 33) return;
          S = S << 1 | I & 1;
        }
        goto Iend;
      N:;
        I = Cc[Q];
        do {
          Cvalue = Ten * Cvalue + (I & 15);
          Q++;
          I = Cc[Q];
        } while (I >= '0' && I <= '9');
        if (Mode != 0 || I != '.') goto Alpha;
      Dot:
        Q++;
        X = Ten;
        I = Cc[Q];
        Dotseen = 1;
        while ('0' <= I && I <= '9') {
          Cvalue += (I & 15) / X;
          X = Ten * X;
          Q++;
          I = Cc[Q];
        }
      Alpha:;
        if (Mode == 0 && Cc[Q] == '@') {
          Q++;
          X = Cvalue;
          Z = 1;
          I = Cc[Q];
          if (I == '-') Z = -1;
          if (I == '+' || I == '-') Q++;
          Const(2);
          if (!Hit) return;
          Hit = 0;
          R = Rr + 1;
          if ((unsigned)A[R] >> 4 != 4) return;
          S = Fromar2(R + 1) * Z;
          if (S == -99)
            Cvalue = 0;
          else {
            while (S > 0) {
              S--;
              Cvalue = Cvalue * Ten;
            }
            while (S < 0 && Cvalue != 0) {
              S++;
              Cvalue = Cvalue / Ten;
            }
          }
        }
        if (Fs == 'D') {
          I = Cc[Q];
          if (I == '\'')
            Q++;
          else
            return;
          Dotseen = 1;
        }
        if (Dotseen == 1 || Cvalue > Imax || Fracpt(Cvalue) != 0)
          Ctype = 2;
        else {
          Ctype = 1;
          S = Int(Cvalue);
        }
        if (Ctype == 1) goto Iend;
        if (Cprec == 5) Cprec = 6;
        if (Cprec == 6)
          ;
        Toar8(R, Cvalue);
        R += 8;
        if (Cprec == 7) {
          Toar8(R, *Longreal(Addr(Cvalue) + 8));
          R += 8;
        }
        A[Rr] = (Cprec << 4) + Ctype;
        Hit = 1;
      Fail:;
      }
      void Texttext(int Ebcdic) {
        int J;
        int Ii;
        static const int Qu = '"';
        I = Cc[Q];
        S = R + 4;
        R += 5;
        Hit = 0;
        if (I != Qu) return;
        Q++;
        for (;;) {
          I = Cc[Q];
          if (Ebcdic)
            Ii = Itoetab[I];
          else
            Ii = I;
          A[R] = Ii;
          R++;
          if (I == Qu) {
            Q++;
            if (Cc[Q] != Qu) break;
          }
          if (I == 10)
            Readline(1, Qu);
          else
            Q++;
          if (R - S > 256) Fault(106, 0);
        }
        R--;
        J = R - S - 1;
        A[S] = J;
        Hit = 1;
      }
    Bend:;
    }
    if (Level > 1) Fault(15, 0);
    I = 0;
    Newline();
    if (!Faulty) {
      Write(Line, 5);
      Printstring(_imp_str_literal(" LINES ANALYSED IN"));
      Write(Int(1000 * (Cputime() - Ctime)), 5);
      Printstring(_imp_str_literal(" MSECS  -  SIZE="));
      Write(P1size, 5);
      if (Line > 90 && List != 0)
        Newpage();
      else
        Newline();
    } else {
      Printstring(_imp_str_literal("CODE GENERATION NOT ATTEMPTED\n"));
      *Comreg(24) = 8;
      *Comreg(47) = Faulty;
      exit(0);
    }
    {
      int Register[8 /*0:7*/];
      int Gruse[8 /*0:7*/];
      int Grat[8 /*0:7*/];
      int Grinf1[8 /*0:7*/];
      int Grinf2[8 /*0:7*/];
      int Olink[8 /*0:7*/];
      unsigned char Code[269 /*0:268*/];
      unsigned char Glabuf[269 /*0:268*/];
      int Plabs[32 /*0:31*/];
      int Desads[32 /*0:31*/];
      int Plink[32 /*0:31*/];
      int Set[32 /*0:31*/];
      int Stackbase[32 /*0:31*/];
      int Ral[32 /*0:31*/];
      int Flag[32 /*0:31*/];
      int L[32 /*0:31*/];
      int M[32 /*0:31*/];
      int Nmdecs[32 /*0:31*/];
      int Onword[32 /*0:31*/];
      int Oninf[32 /*0:31*/];
      int Jump[32 /*0:31*/];
      int Label[32 /*0:31*/];
      int Jround[32 /*0:31*/];
      int Diaginf[32 /*0:31*/];
      int Display[32 /*0:31*/];
      int Auxsbase[32 /*0:31*/];
      int Names[32 /*0:31*/];
      int Avlwsp[5 /*0:4*/][32 /*0:31*/];
      typedef struct Rcf {
        int Val[24565 /*0:24564*/];
      } Rcf;
      Rcf *Ctable;
      auto void Cnop(int I, int J);
      auto void Pclod(int From, int To);
      auto void Pconst(int X);
      auto void Psf1(int Opcode, int K, int N);
      auto void Pf1(int Opcode, int Kp, int Kpp, int N);
      auto void Psorlf1(int Opcode, int Kp, int Kpp, int N);
      auto void Pf2(int Opcode, int H, int Q, int N, int Mask, int Filler);
      auto void Pf3(int Opcode, int Mask, int Kppp, int N);
      auto void Notecref(int Ca, int Val);
      auto int Paramdes(int Prec);
      auto int Mapdes(int Prec);
      auto int Specialconsts(int Which);
      auto void Storeconst(int *D, int L, int Ad);
      auto void Dumpconsts(void);
      auto void Plant(int Value);
      auto void Plug(int I, int J, int K, int Bytes);
      auto void Codeout(void);
      auto void Prologue(void);
      auto void Epilogue(void);
      auto void Compileastmnt(void);
      auto void Css(int P);
      auto void Loaddata(void);
      auto void Abort(void);
      auto void Printuse(void);
      for (I = 0; I <= 7; I++) {
        Register[I] = 0;
        Gruse[I] = 0;
        Grinf1[I] = 0;
        Grat[I] = 0;
        Grinf2[I] = 0;
      }
      for (I = 0; I <= Maxlevels; I++) {
        Set[I] = 0;
        Stackbase[I] = 0;
        Ral[I] = 0;
        Jump[I] = 0;
        Jround[I] = 0;
        Label[I] = 0;
        Flag[I] = 0;
        L[I] = 0;
        M[I] = 0;
        Diaginf[I] = 0;
        Display[I] = 0;
        Onword[I] = 0;
        Oninf[I] = 0;
        Names[I] = -1;
        for (J = 0; J <= 4; J++) Avlwsp[J][I] = 0;
      }
      Ctable = Record(Addr(Aslist[1]));
      Consthole = 0;
      Prologue();
      Line = 0;
      Nextp = 1;
      Level = 1;
      Stmts = 0;
      Rlevel = 0;
      Rbase = 0;
      while (A[Nextp + 3] | A[Nextp + 4]) Compileastmnt();
      Line = 99999;
      Epilogue();
      Loaddata();
      exit(0);
      void Compileastmnt(void) {
        int I;
        if (Dcomp != 0 && Ca > Cabuf) {
          Codeout();
          Printuse();
        }
        I = Nextp;
        Nextp = Nextp + (A[Nextp] << 16) + (A[Nextp + 1] << 8) + A[Nextp + 2];
        Line = (A[I + 3] << 8) + A[I + 4];
        Stmts++;
        Css(I + 5);
      }
      void Loaddata(void) {
        int Langflag;
        int Parms;
        Glaca = (Glaca + 7) & (-8);
        Ustptr = (Ustptr + 7) & (-8);
        Codeout();
        Cnop(0, 8);
        Dumpconsts();
        if (!Parmtrace)
          Langflag = 6;
        else
          Langflag = 1;
        Langflag = Langflag << 24;
        Parms = (Parmdiag << 1 | Parmline) << 1 | Parmtrace;
        Fixedgla[4] = Langflag | 1 << 16 | (Cprmode & 1) << 8 | Parms;
        I = Glaca - Glacabuf;
        if (!Inhcode) {
          if (I) Lput(2, I, Glacabuf, Addr(Glabuf[0]));
          Lput(2, Fixedglalen, 0, Addr(Fixedgla[0]));
          Lput(19, 2, 8, 5);
          Lput(19, 2, 12, 4);
          I = 0xE2E2E2E2;
          Lput(4, 4, Sstl, Addr(I));
        }
        Sstl = (Sstl + 11) & (-8);
        Printstring(_imp_str_literal("\nCODE"));
        Write(Ca, 6);
        Printstring(_imp_str_literal(" BYTES      GLAP"));
        Write(Glaca, 3);
        Printstring(_imp_str_literal("+"));
        Write(Ustptr, 1);
        Printstring(_imp_str_literal(" BYTES      DIAG TABLES"));
        Write(Sstl, 3);
        Printstring(_imp_str_literal(" BYTES\nTOTAL"));
        Register[0] = Ca;
        Register[1] = Glaca;
        Register[2] = 0;
        Register[3] = Sstl;
        Register[4] = Ustptr;
        K = Ca + Glaca + Sstl + Ustptr;
        Register[5] = K;
        Write(K, 5);
        Printstring(_imp_str_literal(" BYTES"));
        Newline();
        Printch(13);
        if (!Faulty) {
          Write(Stmts, 7);
          Printstring(_imp_str_literal(" STATEMENTS COMPILED IN"));
          Write(Int(1000 * (Cputime() - Ctime)), 5);
          Printstring(_imp_str_literal(" MSECS"));
          *Comreg(47) = Stmts;
        } else {
          Printstring(_imp_str_literal("PROGRAM CONTAINS"));
          Write(Faulty, 2);
          Printstring(_imp_str_literal(" FAULT"));
          if (Faulty > 1) Printsymbol('S');
          *Comreg(47) = Faulty;
        }
        Newlines(2);
        Newline();
        I = 0;
        if (Faulty) I = 8;
        *Comreg(24) = I;
        if (!Inhcode) Lput(7, 24, 0, Addr(Register[0]));
        exit(0);
      }
      void Recode(int S, int F, int Ad) {
        if (S != F) {
          Printstring(_imp_str_literal("\nCODE FOR LINE"));
          Write(Line, 5);
          Ncode(S, F, Ad);
        }
      }
      void Codeout(void) {
        if (Ppcurr > 0) {
          if (Dcomp) Recode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
          if (!Inhcode) Lput(1, Ppcurr, Cabuf, Addr(Code[0]));
          Ppcurr = 0;
          Cabuf = Ca;
        }
      }
      void Plant(int Halfword) {
        Code[Ppcurr] = (unsigned)Halfword >> 8;
        Code[Ppcurr + 1] = Halfword;
        Ppcurr += 2;
        Ca += 2;
        if (Ppcurr >= 256) Codeout();
      }
      void Pconst(int Word) {
        int I;
        for (I = 24; I >= 0; I -= 8) {
          Code[Ppcurr] = (unsigned)Word >> I & 255;
          Ppcurr++;
        }
        Ca += 4;
        if (Ppcurr >= 256) Codeout();
      }
      void Psf1(int Opcode, int K, int N) {
        int Kpp;
        if ((K == 0 && -64 <= N && N <= 63) || (K != 0 && 0 <= N && N <= 511)) {
          if (K) N = N / 4;
          Code[Ppcurr] = Opcode | (unsigned)K >> 1;
          Code[Ppcurr + 1] = (K & 1) << 7 | N & 127;
          Ppcurr += 2;
          Ca += 2;
          if (Ppcurr >= 256) Codeout();
        } else {
          if (!K)
            Kpp = 0;
          else
            Kpp = 2;
          Pf1(Opcode, (unsigned)K >> 1 << 1, Kpp, N);
        }
      }
      void Pf1(int Opcode, int Kp, int Kpp, int N) {
        int Inc;
        Inc = 2;
        if (Kpp == Pc) {
          if (N < 0) {
            N = N & 0x7FFFFFFF;
            Notecref(Ca, N);
          }
          N = (N - Ca) / 2;
        }
        if ((1 << Kpp) & 0b101100) N = N / 4;
        Code[Ppcurr] = Opcode | 1;
        Code[Ppcurr + 1] = 0x80 | Kp << 5 | Kpp << 2 | ((unsigned)N >> 16 & 3);
        Code[Ppcurr + 2] = (unsigned)N >> 8 & 255;
        Code[Ppcurr + 3] = N & 255;
        if (Kpp <= 5) Inc = 4;
        Ppcurr += Inc;
        Ca += Inc;
        if (Ppcurr >= 256) Codeout();
      }
      void Psorlf1(int Opcode, int Kp, int Kpp, int N) {
        int Inc;
        Inc = 2;
        if ((Kpp == 0 && 0 == Kp && -64 <= N && N <= 63) || (Kpp == Lnb && (Kp & 1) == 0 && 0 <= N && N <= 511)) {
          if (Kpp == Lnb) Kp = 1 + ((unsigned)Kp >> 1);
          if (Kp) N = N / 4;
          Code[Ppcurr] = Opcode | (unsigned)Kp >> 1;
          Code[Ppcurr + 1] = (Kp & 1) << 7 | (N & 127);
        } else {
          if (Kpp == Pc) {
            if (N < 0) {
              N = N & 0x7FFFFFFF;
              Notecref(Ca, N);
            }
            N = (N - Ca) / 2;
          }
          if ((1 << Kpp) & 0b101100) N = N / 4;
          Code[Ppcurr] = Opcode | 1;
          Code[Ppcurr + 1] = ((4 | Kp) << 3 | Kpp) << 2 | ((unsigned)N >> 16 & 3);
          Code[Ppcurr + 2] = (unsigned)N >> 8 & 255;
          Code[Ppcurr + 3] = N & 255;
          if (Kpp <= 5) Inc = 4;
        }
        Ca += Inc;
        Ppcurr += Inc;
        if (Ppcurr >= 256) Codeout();
      }
      void Pf2(int Opcode, int H, int Q, int N, int Mask, int Filler) {
        Plant(Opcode << 8 | H << 8 | Q << 7 | N);
        if (Q) Plant(Mask << 8 | Filler);
      }
      void Pf3(int Opcode, int Mask, int Kppp, int N) {
        if (Kppp == Pc) {
          if (N < 0) {
            N = N & 0x7FFFFFFF;
            Notecref(Ca, N);
          }
          N = (N - Ca) / 2;
        }
        Code[Ppcurr] = Opcode | (unsigned)Mask >> 3 & 1;
        Code[Ppcurr + 1] = (Mask & 7) << 5 | Kppp << 2 | ((unsigned)N >> 16 & 3);
        Ppcurr += 2;
        Ca += 2;
        if (Kppp <= 5) {
          Code[Ppcurr] = (unsigned)N >> 8 & 255;
          Code[Ppcurr + 1] = N & 255;
          Ppcurr += 2;
          Ca += 2;
        }
        if (Ppcurr >= 256) Codeout();
      }
      void Notecref(int Ca, int N) {
        Listf *Cell;
        Cell = &Aslist[Crefhead];
        if (Crefhead == 0 || Cell->S3 != 0) {
          Push(Crefhead, Ca, 0, 0);
          return;
        }
        if (!Cell->S2)
          Cell->S2 = Ca;
        else
          Cell->S3 = Ca;
      }
      void Pclod(int From, int To) { int I; }
      void Cnop(int I, int J) {
        while ((Ca & (J - 1)) != I) Psf1(Junc, 0, 1);
      }
      void Pgla(int Bdry, int L, int Infadr) {
        int I;
        int J;
        J = Glaca;
        Glaca = (J + Bdry - 1) & (-Bdry);
        Glacurr = Glacurr + Glaca - J;
        if (L + Glacurr > 256) {
          if (!Inhcode) Lput(2, Glacurr, Glacabuf, Addr(Glabuf[0]));
          Glacurr = 0;
          Glacabuf = Glaca;
        }
        for (I = 0; I <= L - 1; I++) Glabuf[Glacurr + I] = *Byteinteger(I + Infadr);
        Glaca += L;
        Glacurr += L;
      }
      void Plug(int Area, int At, int Value, int Bytes) {
        int *Wcabuf;
        int I;
        int Relad;
        int Bufad;
        Wcabuf = &Cabuf;
        Bufad = Addr(Code[0]);
        if (Area == 2) {
          Wcabuf = &Glacabuf;
          Bufad = Addr(Glabuf[0]);
        }
        Relad = At - *Wcabuf;
        if (0 <= Relad && Relad <= 256 && Area <= 3)
          for (I = 0; I <= Bytes - 1; I++) *Byteinteger(Relad + Bufad + I) = (unsigned)Value >> ((Bytes - 1 - I) << 3);
        else {
          if (Relad == -2) Codeout();
          if (!Inhcode) Lput(Area, Bytes, At, Addr(Value) + 4 - Bytes);
          if (Dcomp == 1 && 1 == Area) Ncode(Addr(Value) + 4 - Bytes, Addr(Value) + 4, At);
        }
      }
      int Paramdes(int Prec) {
        int K;
        int Des;
        K = Desads[Prec];
        if (K) return (K);
        if (Prec == 4)
          Des = 0x58000002;
        else
          Des = Prec << 27 | 1;
        Storeconst(K, 4, Addr(Des));
        Desads[Prec] = K;
        return (K);
      }
      int Mapdes(int Prec) {
        int K;
        int Des0;
        int Des1;
        K = Desads[Prec + 8];
        if (K) return (K);
        if (Prec == 4)
          Des0 = 0x58000002;
        else
          Des0 = 0x03000000 | Prec << 27;
        Des1 = 0;
        Storeconst(K, 8, Addr(Des0));
        Desads[Prec + 8] = K;
        return (K);
      }
      int Specialconsts(int Which) {
        static int Scs[6 /*0:5*/] = {0x40800000, 0, 0x41100000, 0, 1, 0};
        int K;
        K = Desads[Which + 16];
        if (K) return (K);
        Storeconst(K, 8, Addr(Scs[2 * Which]));
        Desads[Which + 16] = K;
        return (K);
      }
      void Storeconst(int *D, int L, int Ad) {
        int I;
        int J;
        int K;
        int C1;
        int C2;
        int C3;
        int C4;
        int Lp;
        Lp = L / 4;
        C2 = 0;
        C3 = 0;
        C4 = 0;
        for (I = 0; I <= L - 1; I++) *Byteinteger(Addr(C1) + I) = *Byteinteger(Ad + I);
        if (Parmopt) goto Skip;
        K = Constbtm;
        if (L == 4) {
          while (K < Constptr) {
            if (Ctable->Val == C1 && Consthole != K) {
              *D = 4 * K | 0x80000000;
              return;
            }
            K++;
          }
        } else {
          J = Constptr - Lp;
          while (K <= J) {
            if (Ctable->Val == C1 && Ctable->Val == C2 && (Consthole < K || Consthole >= K + Lp))
              if (L == 8 || (Ctable->Val == C3 && Ctable->Val == C4)) {
                *D = 4 * K | 0x80000000;
                return;
              }
            K += 2;
          }
        }
      Skip:;
        if (L == 4 && Consthole != 0) {
          Ctable->Val = C1;
          *D = 4 * Consthole | 0x80000000;
          Consthole = 0;
          return;
        }
        if (L > 4 && (Constptr & 1) != 0) {
          Consthole = Constptr;
          Constptr++;
        }
        *D = 4 * Constptr | 0x80000000;
        Ctable->Val = C1;
        Ctable->Val = C2;
        if (L == 16) {
          Ctable->Val = C3;
          Ctable->Val = C4;
        }
        Constptr += Lp;
        if (Constptr > Constlimit) Fault(107, 0);
      }
      void Getenv(int *Head) {
        int I;
        int Use;
        for (I = 0; I <= 7; I++) {
          Use = Gruse[I] & 0xFF;
          if (Use) Push(*Head, Grinf1[I], Grat[I], I << 8 | Use);
        }
      }
      void Restore(int Head) {
        int I;
        int R;
        int Use;
        int Inf;
        int At;
        for (I = 0; I <= 7; I++)
          if (Register[I] >= 0) {
            Gruse[I] = 0;
            Grinf1[I] = 0;
          }
        while (Head) {
          Pop(Head, Inf, At, I);
          R = (unsigned)I >> 8;
          Use = I & 255;
          if (Register[R] >= 0) {
            Gruse[R] = Use;
            Grinf1[R] = Inf;
          }
          Grat[R] = At;
        }
      }
      void Relocate(int Glarad, int Value, int Area) {
        if (Glarad < 0) {
          Pgla(4, 4, Addr(Value));
          Glarad = Glaca - 4;
        }
        Lput(19, 2, Glarad, Area);
      }
      void Gxref(_imp_string Name, int Mode, int Xtra, int At) {
        int Lputno;
        if (Mode == 2)
          Lputno = 15;
        else
          Lputno = Mode + 12;
        Lput(Lputno, Xtra, At, Addr(Name));
      }
      void Cxref(_imp_string Name, int Mode, int Xtra, int *At) {
        int Z1;
        int Z2;
        Z1 = 0;
        Z2 = 0;
        Pgla(8, 8, Addr(Z1));
        *At = Glaca - 8;
        Gxref(Name, Mode, Xtra, *At);
      }
      void Codedes(int *At) {
        int Desc1;
        int Desc2;
        Desc1 = 0xE1000000;
        Desc2 = 0;
        if (!Cdcount) {
          Fixedgla[0] = Desc1;
          *At = 0;
        } else {
          Pgla(8, 8, Addr(Desc1));
          *At = Glaca - 8;
        }
        Cdcount++;
      }
      void Defineep(_imp_string Name, int Adr, int At, int Main) {
        if (!At)
          Fixedgla[1] = Adr;
        else
          Plug(2, At + 4, Adr, 4);
        Relocate(At + 4, Adr, 1);
        if (*Length(Name) != 0) Lput(11, Main << 31 | 2, At, Addr(Name));
      }
      void Prologue(void) {
        auto int Stringin(int Pos);
        auto void Errexit(int A, int B, int C);
        int I;
        int K;
        int L;
        int Stca;
        I = 0xC2C2C2C2;
        Lput(4, 4, 0, Addr(I));
        Sstl = 4;
        for (I = 0; I <= 31; I++) {
          Plabs[I] = 0;
          Plink[I] = 0;
          Desads[I] = 0;
        }
        Plabs[1] = Ca;
        for (I = 0; I <= 1; I++) Pconst(Unasspat);
        Plabs[2] = Ca;
        Psf1(Prcl, 0, 4);
        Psf1(Jlk, 0, 1);
        Pf1(Stln, 0, Tos, 0);
        Pf1(St, 0, Tos, 0);
        Psf1(Lxn, 1, 16);
        Psf1(Raln, 0, 9);
        Pf1(Call, 2, Xnb, 40);
        Pf1(Junc, 0, Tos, 0);
        if (Parmdbug) {
          Plabs[3] = Ca;
          Cxref(_imp_str_literal("S#IMPMON"), Parmdynamic, 2, K);
          Psf1(Prcl, 0, 4);
          Pf1(St, 0, Tos, 0);
          Psf1(Lxn, 1, 16);
          Psf1(Raln, 0, 6);
          Pf1(Call, 2, Xnb, K);
          Pf1(Junc, 0, Tos, 0);
        }
        if (Parmchk == 1) {
          Cnop(0, 4);
          K = Ca;
          Pconst(0x58000000);
          Plabs[4] = Ca;
          Pf3(Jat, 12, 0, 13);
          Pf1(Lss, 0, Tos, 0);
          Pf1(Stsf, 0, Tos, 0);
          Pf1(Ldtb, 0, Pc, K);
          Pf1(Lda, 0, Tos, 0);
          Pf1(Asf, 0, Breg, 0);
          Psf1(Myb, 0, 4);
          Pf1(Ldb, 0, Breg, 0);
          Pf2(Mvl, 1, 1, 0, 0, Unasspat & 255);
          Pf1(St, 0, Tos, 0);
          Pf1(Junc, 0, Tos, 0);
        }
        if (Parmopt) Errexit(5, 0x801, 0);
        Errexit(6, 0x504, 0);
        Errexit(7, 0x505, 1);
        if (Parmopt) Errexit(8, 0x201, 0);
        Errexit(9, 0x601, 0);
        Errexit(10, 21, 0);
        if (Parmopt) Errexit(11, 0x501, 0);
        Errexit(12, 0x701, 0);
        if (Parmopt) Errexit(13, 36, 0);
        Ctable->Val = 0x18000001;
        Ctable->Val = 4;
        Stca = 8;
        L = Addr(Ctable->Val);
        Constptr = 2;
        while (Strlink) {
          I = Strlink;
          Strlink = Fromar4(I);
          Toar4(I, Stringin(I + 4));
        }
        Strlink = 0x80000000;
        Constbtm = Constptr;
        if (Parmopt) {
          Ctable->Val = 'IDIA';
          Constptr++;
        }
        Gxref(Mdep, Parmdynamic, 2, 40);
        if (Parmprof) {
          I = 0x38000001 + Line;
          K = 8;
          Parmprof = Glaca;
          Pgla(4, 8, Addr(I));
          K = 0;
          for (I = 0; I <= Line; I++) Pgla(4, 4, Addr(K));
          Line = 0;
        }
        Level = 1;
        for (I = 0; I <= 31; I++)
          if (Plink[I]) Clearlist(Plink[I]);
        return;
        int Stringin(int Pos) {
          int J;
          int K;
          int Ind;
          int Hd;
          Listf *Cell;
          K = A[Pos];
          if (!K) return (0);
          Ind = K & 31;
          Hd = Plink[Ind];
          while (Hd) {
            Cell = &Aslist[Hd];
            if (Cell->S1 == K && *String(L + Cell->S2) == *String(Addr(A[Pos]))) return (Cell->S2 - 4);
            Hd = Cell->Link;
          }
          Hd = Stca;
          *Byteinteger(L + Stca) = K;
          Stca++;
          for (J = Pos + 1; J <= Pos + K; J++) {
            *Byteinteger(L + Stca) = A[J];
            Stca++;
          }
          Constptr = (unsigned)((Stca + 7) & (-8)) >> 2;
          Push(Plink[Ind], K, Hd, 0);
          return (Hd - 4);
        }
        void Errexit(int Lab, int Errno, int Mode) {
          Plabs[Lab] = Ca;
          if (!Mode)
            Psf1(Lss, 0, 0);
          else
            Pf1(Lss, 0, Breg, 0);
          Psf1(Luh, 0, Errno);
          Psf1(Jlk, 0, (Plabs[2] - Ca) / 2);
        }
      }
      void Css(int P) {
        auto void Mergeinfo(void);
        auto void Reduceenv(int *Head);
        auto void Enterjump(int Mask, int Stad, int Flag);
        auto int Enterlab(int M, int Flag);
        auto void Removelab(int Lab);
        auto void Cend(int Kkk);
        auto int Ccond(int Cto, int A, int B);
        auto void Checkstof(void);
        auto int Reverse(int Mask);
        auto void Setline(void);
        auto int Setxorynb(int Which, int Rlevel);
        auto int Xorynb(int Use, int Inf);
        auto void Getinacc(int Acc, int Size, int Ac, int Area, int Disp);
        auto int Areacode(void);
        auto int Areacode2(int Bs);
        auto void Cui(int Code);
        auto void Assign(int A, int B);
        auto void Cstart(int Ccres, int Mode);
        auto void Ccycbody(int Ua, int Elab, int Clab);
        auto void Cloop(int Alt, int Markc, int Markui);
        auto void Cifthen(int Markiu, int Markc, int Markui, int Marke, int Markr, int Skip);
        auto void Createah(int Mode);
        auto void Torp(int *Head, int *Bot, int *Nops);
        auto int Intexp(int *Value);
        auto int Constexp(int Prectype);
        auto void Csexp(int Reg, int Mode);
        auto void Cstrexp(int A, int B);
        auto void Cres(int Lab);
        auto void Expop(int A, int B, int C, int D);
        auto void Testapp(int *Num);
        auto void Skipexp(void);
        auto void Skipapp(void);
        auto void Noapp(void);
        auto int Dopevector(int A, int B, int Mode, int Id, int *C, int *D);
        auto void Declarearrays(int A, int B);
        auto void Declarescalars(int A, int B);
        auto void Makedecs(int Q);
        auto void Saveauxstack(void);
        auto void Resetauxstack(void);
        auto void Crspec(int M);
        auto void Cfplist(int *A, int *B);
        auto void Cfpdel(void);
        auto void Clt(void);
        auto void Cqn(int P);
        auto void Getwsp(int *Place, int Size);
        auto void Returnwsp(int Place, int Size);
        auto int Tsexp(int *Value);
        auto void Crcall(int Rtname);
        auto void Nameop(int Z, int Reg, int Size, int Namep);
        auto void Cname(int Z, int Reg);
        auto void Caname(int Z, int Bs, int Dp);
        auto void Csname(int Z, int Reg);
        auto void Testass(int Reg, int Type, int Size);
        auto void Copytag(int Kk);
        auto void Reducetag(void);
        auto void Replacetag(int Kk);
        auto void Rtjump(int Code, int *L);
        auto void Storetag(int Kk, int Slink);
        auto void Unpack(void);
        auto void Pack(int *Ptype);
        auto void Diagpointer(int Level);
        auto void Rdisplay(int Kk);
        auto void Rhead(int Kk);
        auto void Oddalign(void);
        auto int Ptroffset(int Rlev);
        auto void Ppj(int Mask, int N);
        auto void Crformat(int *Ophead);
        auto int Displacement(int Link);
        auto int Copyrecordtag(int *Subs);
        auto void Saveirs(void);
        auto void Copydr(void);
        auto void Bootout(int Reg);
        auto void Changerd(int Reg);
        auto void Forget(int Reg);
        auto void Remember(void);
        auto void Noteassment(int Reg, int Assop, int Var);
        static int Sw_sw;
        static void *Sw[24 /*1:24*/] = {
            &&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,
        };
        typedef struct Rd {
          unsigned char Uptype;
          unsigned char Ptype;
          unsigned char Xb;
          unsigned char Flag;
          int D;
          int Xtra;
        } Rd;
        int Sndisp;
        int Acc;
        int K;
        int Kform;
        int Stname;
        int Midcell;
        int Tcell;
        int Nummod;
        int Jj;
        int Jjj;
        int Kk;
        int Qq;
        int Marker;
        int Reportui;
        int Xdisp;
        int Mask;
        int Base;
        int Area;
        int Access;
        int Disp;
        int Extrn;
        int Currinst;
        int Value;
        int Stringl;
        int Ptype;
        int I;
        int J;
        int Oldi;
        int Usebits;
        int Twsphead;
        int Kkk;
        int Strfnres;
        int Markiu;
        int Markui;
        int Markc;
        int Marke;
        int Markr;
        int Litl;
        int Rout;
        int Nam;
        int Arr;
        int Prec;
        int Type;
        Rd Expopnd;
        Currinst = 0;
        Twsphead = 0;
        int Sgruse[8 /*0:7*/];
        int Sgrinf[8 /*0:7*/];
        goto *Sw[Sw_sw = (A[P]) - 1];
      Sw_23:;
      Sw_24:;
      Sw_2:;
      Cssexit:
        Lastinst = Currinst;
        while (Twsphead) {
          Pop(Twsphead, Jj, Kk, Qq);
          Returnwsp(Jj, Kk);
        }
        return;
      Sw_1:;
        if (Level < 2) Fault(57, 0);
        Marker = P + 1 + (A[P + 1] << 8) + A[P + 2];
        P += 3;
        if (A[Marker] == 1) goto Labfnd;
        if (A[Marker] == 2) {
          Setline();
          Cui(0);
          goto Cssexit;
        }
        Marke = 0;
        Markr = 0;
        Markui = P;
        Markiu = Marker + 1;
        Markc = Markiu + 1;
        if (A[Marker] == 3) {
          Cifthen(Markiu, Markc, Markui, 0, 0, No);
          goto Cssexit;
        }
        Cloop(A[Markiu], Markc + 2, Markui);
        goto Cssexit;
      Labfnd:
        if (A[P] != 1 || A[P + 5] != 2) goto Switch;
        if (A[P + 6] != 2 || A[P + 7] != 2) goto Switch;
        Jj = Enterlab(Fromar2(P + 3), 0);
        goto Cssexit;
      Sw_5:;
        if (Level < 2) Fault(57, 0);
        if (A[P + 5] == 2)
          Cloop(0, P + 1, 0);
        else
          Cloop(6, P + 6, P + 1);
        goto Cssexit;
      Sw_6:;
        goto Cssexit;
      Sw_22:;
        J = Fromar4(P + 2);
        Codeout();
        Dcomp = (unsigned)J >> 28;
        goto Cssexit;
      Sw_3:;
        Markiu = P + 1;
        Markc = Markiu + 3;
        Markr = P + 2 + (A[P + 2] << 8) + A[P + 3];
        Marke = 0;
        if (A[Markr] == 3) {
          Marke = Markr + 1 + Fromar2(Markr + 1);
          Markui = Markr + 3;
        }
        Cifthen(Markiu, Markc, Markui, Marke, Markr, No);
        goto Cssexit;
      Sw_4:;
        goto Cssexit;
      Switch : {
        int Head;
        int Basept;
        int Naps;
        int Fname;
        int Bits[3 /*0:2*/];
        Forget(-1);
        Fname = Fromar2(P + 3);
        if (A[P] != 1 || A[P + 5] != 1) {
          Fault2(5, 0, Fname);
          goto Bend;
        }
        P += 3;
        Testapp(Naps);
        P += 6;
        if (Intexp(Jj)) {
          Fault2(41, 0, 0);
          goto Bend;
        }
        if (Naps != 1) {
          Fault2(21, Naps - 1, Fname);
          goto Bend;
        }
        if (A[P + 1] != 2 || 2 != A[P + 2]) {
          Fault2(5, 0, Fname);
          goto Bend;
        }
        Copytag(Fname);
        Head = K;
        if (Oldi != Level || Type != 6) {
          Fault(4, Fname);
          goto Bend;
        }
        From123(Head, Basept, Kkk, Kk);
        Mlink(Head);
        if (Kkk <= Jj && Jj <= Kk) goto Inbd;
        Fault2(50, Jj, Fname);
        goto Bend;
      Inbd:
        Q = Jj - Kkk;
        while (Q >= 96) {
          Mlink(Head);
          Q -= 96;
        }
        From123(Head, Bits[0], Bits[1], Bits[2]);
        Qq = (unsigned)Q >> 5;
        Q = Q & 31;
        Jjj = 1 << Q;
        if (Bits[Qq] & Jjj) Fault2(6, Jj, Fname);
        Bits[Qq] = Bits[Qq] | Jjj;
        Replace123(Head, Bits[0], Bits[1], Bits[2]);
        if (Arr == 2) Kkk = 0;
        Qq = Basept + (Jj - Kkk) * 4;
        Plug(2, Qq, Ca, 4);
      Bend:;
      }
        goto Cssexit;
      Sw_7:;
        if (Level < 2) Fault(57, 0);
        Markiu = P + 1;
        Markc = Markiu + 3;
        Cloop(A[Markiu] + 3, Markc, Markiu + 1 + Fromar2(Markiu + 1));
        goto Cssexit;
      Sw_8:;
        if (Level < 2) Fault(57, 0);
        if (Nmdecs[Level] & 1) Fault(40, 0);
        Qq = P;
        P += 5;
        Clt();
        Rout = 0;
        Litl = 0;
        if (A[P] != 1) {
          if (Type == 5 && Acc == 0) Fault(70, 0);
          Nam = 0;
          Setline();
          Qq = 2 - A[P + 1];
          P += 2;
          Declarearrays(Qq, 0);
        } else if (A[Qq + 1] == 128) {
          Cqn(P + 1);
          P += 2;
          Declarescalars(1, 0);
        }
        goto Cssexit;
      Sw_9:;
        {
          static int S_sw;
          static void *S[5 /*1:5*/] = {
              &&S_1, &&S_2, &&S_3, &&S_4, &&S_default,
          };
          goto *S[S_sw = (A[P + 1]) - 1];
        S_1:;
        S_2:;
          if (!Cprmode) Cprmode = 2;
          if (Level + Cprmode != 3) Fault(15, 0);
          if (A[P + 1] != Cprmode) Fault(56, 0);
          Cend(Cprmode);
          goto Bend;
        S_3:;
          List = 0;
          goto Bend;
        S_4:;
          Cend(Flag[Level]);
        Bend:;
          goto S_skip;
        S_default:
          fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw + 1, __PRETTY_FUNCTION__);
          fflush(stderr);
          abort();
        S_skip:;
        }
        goto Cssexit;
      Sw_11:;
        {
          int Marker1;
          int Kk;
          int Kkk;
          _imp_string Xname;
          P++;
          Marker1 = Fromar2(P) + P;
        Agn:
          Q = P;
          Kk = Fromar2(Marker1 + 5);
          Extrn = A[P + 2];
          Litl = Extrn & 3;
          if (A[Marker1] == 1) {
            P += 3;
            Crspec(1 - ((unsigned)Extrn >> 2));
            goto Bend;
          }
          Copytag(Kk);
          if (Oldi == Level) {
            if (!Cprmode) Cprmode = 2;
            if (Cprmode == 2 && Level == 1) {
              if (Extrn == 3) Extrn = 2;
              Xname = *String(Dictbase + Word[Kk]);
              if (Extrn == 1) Xname = _imp_join(_imp_str_literal("S#"), Xname);
              if (Extrn == 4) Xname = _imp_str_literal("");
              Jj = Midcell;
              if (Extrn != 4) Usebits = 2;
              Defineep(Xname, Ca, Jj, 0);
              if (Jj) Psf1(Inca, 0, -Jj);
            } else {
              if (Extrn != 4) Fault(55, Kk);
              Extrn = 4;
            }
            if (A[P + 3] == 1)
              Kkk = Litl << 14 | 0x1000;
            else {
              Rout = 1;
              P += 4;
              Clt();
              Arr = 0;
              Nam = 0;
              if (A[P] == 2) Nam = 2;
              Pack(Kkk);
            }
          }
          if (Oldi != Level || J != 15 || Ptype != Kkk) {
            P = Q + 3;
            Crspec(0);
            P = Q;
            goto Agn;
          }
          Ptype = Ptype | (Extrn & 3) << 14;
          {
            int Ptr;
            int Ptypep;
            int Cnt;
            int Pp;
            J = 0;
            Replacetag(Kk);
            Jj = K;
            Plabel--;
            if (Compiler != 1 && (Cprmode != 2 || Level != 1))
              if (!Jround[Level + 1]) {
                Jround[Level + 1] = Plabel;
                Enterjump(15, Plabel, 0);
              }
            Ptypep = Ptype;
            P = Marker1 + 7;
            Rhead(Kk);
            N = 20;
            Cnt = 1;
            while (A[P] == 1) {
              Pp = P + 1 + Fromar2(P + 1);
              P += 3;
              Cfpdel();
              Ptr = P;
              do {
                if (Jj) {
                  From12(Jj, J, Jjj);
                  if ((unsigned)J >> 16 != Ptype || (Ptype == 5 && (unsigned)Jjj >> 16 != Acc)) Fault2(9, Cnt, Kk);
                } else
                  Fault2(8, 0, Kk);
                Ptr += 3;
                Cnt++;
                Mlink(Jj);
              } while (A[Ptr - 1] != 2);
              Declarescalars(0, 0);
              P = Pp;
            }
            N = (N + 3) & (-4);
            if (Jj) Fault2(10, 0, Kk);
            Ptype = Ptypep;
            if ((Ptype & 0xF0F) == 5) N += 8;
            Rdisplay(Kk);
            Makedecs(Marker1 + 1);
          }
        Bend:;
        }
        goto Cssexit;
      Sw_13:;
        if (Cprmode) Fault(58, 0);
        Alllong = A[P + 1] & 1;
        goto Cssexit;
      Sw_14:;
        {
          Ptype = 0;
          if (Level == 1 && Rlevel == 0 && Cprmode == 0) {
            Codedes(Jj);
            Defineep(Mainep, Ca, Jj, 1);
            Rlevel = 1;
            Rbase = 1;
            L[1] = 0;
            M[1] = 0;
            Diaginf[1] = 0;
            Auxsbase[1] = 0;
            Cprmode = 1;
            N = 24;
            Nmax = N;
            Forget(-1);
            Diagpointer(Level + 1);
            Psf1(Std, 1, 12);
            Psf1(Lxn, 1, 16);
            Pf1(Stln, 0, Xnb, 20);
            Pf1(Stln, 0, Tos, 0);
            Pf1(Lss, 0, Tos, 0);
            Psf1(Iad, 0, 24);
            Pf1(Stsf, 0, Tos, 0);
            Pf1(Isb, 0, Tos, 0);
            Psf1(Ish, 0, -2);
            Pf1(St, 0, Breg, 0);
            Pf1(Asf, 0, Breg, 0);
            Pf1(Mpsr, 0, 0, 0x40C0);
            Ptype = 1;
          } else
            Setline();
          Rhead(-1);
          Rdisplay(-1);
          Makedecs(P + 1);
        }
        goto Cssexit;
      Sw_15:;
        if (Level < 2) Fault(57, 0);
        if (Nmdecs[Level] & 1) Fault(40, 0);
        Nmdecs[Level] = Nmdecs[Level] | 0x11;
        if (!Stack) {
          Saveauxstack();
          Disp = Auxsbase[Level];
          Psf1(Lss, 2, Disp);
          Psf1(St, 1, Disp + 12);
        }
        Gruse[Accr] = 0;
        Psf1(Cpsr, 1, N + 8);
        Plabel--;
        Jjj = Plabel;
        Enterjump(15, Jjj, 0b10);
        P += 2;
        Jj = 0;
        do {
          Kk = A[P];
          if (1 > Kk || Kk > 14) Fault2(26, Kk, 0);
          Jj = Jj | 1 << (Kk - 1);
          P += 2;
        } while (A[P - 1] != 2);
        Kk = Ca;
        Pgla(4, 4, Addr(Ca));
        Relocate(Glaca - 4, Kk, 1);
        Onword[Level] = Jj << 18 | (Glaca - 4);
        Forget(-1);
        Psf1(St, 1, N);
        Psf1(Mpsr, 1, N + 8);
        Oninf[Level] = N;
        N += 12;
        if (!Stack) {
          Psf1(Lss, 1, Disp + 12);
          Psf1(St, 2, Disp);
        }
        Cstart(0, 3);
        Nmdecs[Level] = Nmdecs[Level] ^ 0x10;
        Jj = Enterlab(Jjj, 0b111);
        goto Cssexit;
      Sw_16:;
        if (Level < 2) Fault(57, 0);
        {
          int Q;
          int Range;
          int Kkk;
          int Kk;
          int Lb;
          int Pp;
          int D0;
          int D1;
          int Ophead;
          int V;
          int Arrp;
          int R;
          Q = P;
          Arrp = 1;
          if (!Parmopt) Arrp = 2;
          do {
            P += 3;
            while (A[P] == 1) P += 3;
            P += 4;
            Kkk = Intexp(Lb);
            P += 3;
            Kkk = Kkk | Intexp(Kk);
            Range = (Kk - Lb + 1);
            if (Range <= 0 || Kkk != 0) {
              Fault2(38, 1 - Range, Fromar2(Q + 1));
              Lb = 0;
              Kk = 10;
              Range = 11;
            }
            if (Glaca + 8 - 4 * Lb < 0) Arrp = 1;
            Ptype = 0x56 + (Arrp << 8);
            Pp = P;
            P = Q + 1;
            do {
              K = Fromar2(P);
              P += 3;
              Ophead = 0;
              R = Lb;
              do {
                Push(Ophead, 0, 0, 0);
                R += 96;
              } while (R <= Kk);
              D1 = (Glaca + 15) & (-8);
              D0 = 0x28000000 | Range;
              if (Arrp == 2) {
                if (Lb) D0 = D0 | 0x01000000;
                D1 -= 4 * Lb;
              }
              Pgla(8, 8, Addr(D0));
              Sndisp = ((unsigned)Glaca >> 2) - 2;
              Relocate(Glaca - 4, D1, 2);
              Push(Ophead, D1, Lb, Kk);
              Kform = 0;
              Acc = 4;
              J = 1;
              Storetag(K, Ophead);
              V = Plabs[6];
              for (Kkk = Lb; Kkk <= Kk; Kkk++) {
                Relocate(-1, V, 1);
              }
            } while (A[P - 1] != 2);
            Q = Pp;
            P = Q;
          } while (A[Q] != 2);
        }
        goto Cssexit;
      Sw_17:
        List = 1;
        goto Cssexit;
      Sw_12:;
        {
          auto void Clear(int L);
          auto void Stag(int J, int Datalen);
          auto void Xtractconst(int Contype, int Conprec);
          auto void Initspace(int A, int B);
          int Length;
          int Bp;
          int Pp;
          int Sign;
          int Cbase;
          int Mode;
          int Uiconst;
          int Iconst;
          int Tagdisp;
          int Eptype;
          int Epdisp;
          int Ah1;
          int Ah2;
          int Ah3;
          int Ah4;
          int Ad;
          int Fnam;
          int Finf;
          int Spoint;
          int Constsfound;
          int Cprec;
          int Extrn;
          int Nnames;
          int Mark;
          int Lputp;
          int Marker1;
          int Lb;
          int Ctype;
          int Constp;
          int Format;
          int Ptsize;
          int Dimen;
          int Sacc;
          int Typep;
          double Rconst;
          double Lrconst;
          static double Zero = 0;
          _imp_string Sconst;
          _imp_string Namtxt;
          int *Stptr;
          Lputp = 5;
          Stptr = &Ustptr;
          Extrn = A[P + 1];
          if (Extrn >= 4) Extrn = 0;
          Litl = Extrn;
          if (Litl <= 1) Litl = Litl ^ 1;
          Kform = 0;
          Sndisp = 0;
          Constsfound = 0;
          if (!Extrn) {
            Lputp = 4;
            Stptr = &Sstl;
          }
          P += 3;
          Cbase = 0;
          Mode = A[P - 1];
          if (Mode > 1) goto Record;
          Clt();
          if (A[P] == 1)
            Cqn(P + 1);
          else {
            Arr = 1;
            Nam = 0;
          }
          if (Type == 5 && Acc == 0 && 0 == Nam) {
            Fault(70, 0);
            Acc = 2;
          }
          Rout = 0;
          Pack(Ptype);
          if (Arr != 0 && Nam == 0) goto Nonscalar;
          P++;
          do {
            Mark = P + 1 + Fromar2(P + 1);
            Nnames = 1;
            Pp = P + 3;
            P = Pp + 2;
            while (A[P] == 1) {
              Nnames++;
              P += 3;
            }
            P++;
            Iconst = 0;
            Uiconst = 0;
            Rconst = 0;
            Lrconst = 0;
            Sconst = _imp_str_literal("");
            Sign = 3;
            Ctype = Type;
            Constsfound = 0;
            Cprec = Prec;
            if (Nam) {
              Ctype = 1;
              Cprec = 5;
            }
            if (A[P] == 1) {
              P++;
              Xtractconst(Ctype, Cprec);
            }
            do {
              J = 0;
              K = Fromar2(Pp);
              Namtxt = *String(Dictbase + Word[K]);
              if (Nam) {
                if (Extrn == 3) Fault2(46, 0, K);
                Uiconst = 0xFFFF | Prec << 27;
                Pgla(8, Acc, Addr(Uiconst));
                Tagdisp = Glaca - Acc;
                Epdisp = Tagdisp;
              } else if (Type == 5) {
                Qq = *Stptr;
                Ad = Addr(Sconst);
                if (Extrn == 3) {
                  Ah3 = 0;
                  Ah2 = Prec << 27 | Acc;
                } else {
                  if (!Inhcode) Lput(Lputp, Acc, Qq, Ad);
                  *Stptr = (*Stptr + Acc + 3) & (-4);
                  Ah3 = Qq;
                  Ah2 = 3 << 27 | Acc;
                }
                Pgla(8, 8, Addr(Ah2));
                Tagdisp = Glaca - 8;
                if (Extrn == 3)
                  Gxref(Namtxt, 2, 2 << 24 | Acc, Tagdisp + 4);
                else
                  Relocate(Tagdisp + 4, Ah3, Lputp);
                Eptype = 5;
                Epdisp = Qq;
              } else if (Extrn == 3) {
                Ptype = Ptype | 1 << 10;
                Ah2 = Prec << 27;
                Ah3 = 0;
                Pgla(8, 8, Addr(Ah2));
                Tagdisp = Glaca - 8;
                Gxref(Namtxt, 2, 2 << 24 | Acc, Tagdisp + 4);
              } else {
                if (Type == 2)
                  Ad = Addr(Rconst);
                else
                  Ad = Addr(Iconst) + 4 - Acc;
                if (Extrn) Pgla(Acc, Acc, Ad);
                Tagdisp = Glaca - Acc;
                Epdisp = Tagdisp;
                Eptype = 2;
              }
              Stag(Tagdisp, Acc);
              if (Extrn == 0 && 0 == Nam) {
                Replace2(Tags[K], *Integer(Ad & (-4)));
                if (Prec == 6) Replace3(Tags[K], *Integer(Ad + 4));
                if (Prec == 7) Replace3(Tags[K], Constp);
              }
              Pp += 3;
              Nnames--;
            } while (Nnames);
            P = Mark;
          } while (A[Mark] != 2);
          goto Bend;
        Record:;
          Marker1 = P + 1 + Fromar2(P + 1);
          Fnam = Fromar2(Marker1);
          Copytag(Fnam);
          Finf = Tcell;
          if (Ptype != 4) {
            Fault(62, Fnam);
            goto Bend;
          }
          Ptype = 0x133 | Litl << 14;
          Kform = Finf;
          Unpack();
          if (Mode == 3) {
            Format = 2 - A[P];
            P += 2;
            goto Recin;
          }
          P++;
          Bp = Acc;
          Ptype = 0x33;
          J = 0;
          if (A[P - 1] != 3) {
            Cqn(P - 1);
            Pack(Ptype);
          }
          P++;
          Ptsize = Acc;
          do {
            P++;
            K = Fromar2(P);
            Namtxt = *String(Dictbase + Word[K]);
            if (Nam) {
              if (Extrn == 3) Fault2(46, 0, K);
              Uiconst = 0xFFFF | Prec << 27;
              Pgla(8, Ptsize, Addr(Uiconst));
              Eptype = 2;
              Tagdisp = Glaca - Ptsize;
              Epdisp = Tagdisp;
            } else if (Extrn == 3) {
              Ptype = Ptype | 0x400;
              Ah2 = 0x18000000 + Bp;
              Ah3 = 0;
              Pgla(8, 8, Addr(Ah2));
              Tagdisp = Glaca - 8;
              Gxref(Namtxt, 2, 2 << 24 | Bp, Tagdisp + 4);
            } else {
              Epdisp = (Glaca + 15) & (-8);
              Ah3 = Epdisp;
              Ah2 = 0x18000000 + Bp;
              Pgla(8, 4, Addr(Ah2));
              Relocate(-1, Ah3, 2);
              Tagdisp = Epdisp;
              Eptype = 2;
              I = 0;
              Iconst = 0;
              while (I < Bp) {
                Pgla(4, 4, Addr(Iconst));
                I += 4;
              }
            }
            Acc = Bp;
            Stag(Tagdisp, Bp);
            P += 2;
          } while (A[P] != 2);
          goto Bend;
        Nonscalar:;
          P++;
          Format = 2 - A[P];
        Recin:
          Pp = P + 1;
          P += 3;
          Nnames = 1;
          K = Fromar2(Pp);
          Namtxt = *String(Dictbase + Word[K]);
          if (Type >= 3)
            Bp = Acc;
          else
            Bp = Bytes[Prec];
          Sacc = Acc;
          Typep = Ptype;
          Ah4 = 12 + Dopevector(Type, Bp, 0, K, Qq, Lb);
          Sndisp = Ah4 - 12;
          if (Sndisp == -1) Sndisp = 0;
          Sndisp = (unsigned)(Sndisp & 0x3FFFF) >> 2;
          Dimen = J;
          Acc = Sacc;
          Ptype = Typep;
          Unpack();
          if (Lb == 0 && J == 1 && Type <= 3) {
            Arr = 2;
            Pack(Ptype);
          }
          Length = Qq / Bp;
          Spoint = *Stptr;
          if (Mode != 3 && Format == 0)
            if (A[P] == 1) {
              P++;
              Initspace(Qq, Length);
            }
          if (!Constsfound) {
            Constsfound = Length;
            if (Length >= 1 && Extrn != 3 && Format == 0) Clear(Qq);
          } else if (Extrn == 3 || Format != 0)
            Fault2(49, 0, K);
          if (Extrn == 3)
            Epdisp = 0;
          else
            Epdisp = Spoint;
          J = Dimen;
          if (Type <= 2)
            Ah1 = Prec << 27 | Length;
          else
            Ah1 = 3 << 27 | 1 << 25 | Qq;
          Ah1 = Ah1 | (1 - Parmarr) << 24;
          if (Prec == 4) Ah1 = 0x58000002;
          Ah2 = Epdisp;
          Ah3 = 5 << 27 | 3 * J;
          if (Type <= 3 && Parmarr == 0 && 0 == Format && Parmchk == 0 && J == 1) Ah2 -= Bp * Lb;
          Pgla(8, 16, Addr(Ah1));
          Tagdisp = Glaca - 16;
          if (Extrn == 3) {
            Gxref(Namtxt, 2, 2 << 24 | Qq, Tagdisp + 4);
          } else {
            Relocate(Tagdisp + 4, Ah2, Lputp);
          }
          Relocate(Tagdisp + 12, Ah4, 1);
          Ah4 = ((unsigned)Ah4 << 1 >> 3) | 0x80000000;
          Notecref(Ah4 | (unsigned)(Tagdisp + 12) >> 2 << 16, (Ah4 & 0xFFFF) << 2);
          Eptype = 5;
          Stag(Tagdisp, Qq);
          goto Bend;
          void Initspace(int Size, int Nels) {
            int Rf;
            int I;
            int K;
            int Elsize;
            int Ad;
            int Spp;
            int Length;
            int Saver;
            int Wsize;
            int Writ;
            if (Size > 4096)
              Wsize = 4096;
            else
              Wsize = Size;
            Saver = R;
            R = R + Wsize + 256;
            if (R > Arsize) Fault(102, 0);
            unsigned char Sp[(Wsize + 256) + 1];
            if (Type == 1) Ad = Addr(Iconst) + 4 - Acc;
            if (Type == 2) Ad = Addr(Rconst);
            if (Type == 5) Ad = Addr(Sconst);
            Spp = 0;
            Writ = 0;
            Elsize = Size / Nels;
            do {
              Xtractconst(Type, Prec);
              if (A[P] == 1) {
                P++;
                if (Intexp(Rf)) {
                  Fault(44, Constsfound);
                  Rf = 1;
                }
                P++;
              } else {
                Rf = 1;
                P += 2;
              }
              if (Rf <= 0) Fault(44, Constsfound);
              for (I = Rf; I >= 1; I--) {
                for (K = 0; K <= Elsize - 1; K++)
                  if (Constsfound <= Nels) {
                    Sp[Spp] = *Byteinteger(Ad + K);
                    Spp++;
                  }
                Constsfound++;
                if (Spp >= 4096) {
                  if (!Inhcode) Lput(Lputp, Spp, *Stptr + Writ, Addr(Sp[0]));
                  Writ += Spp;
                  Spp = 0;
                }
              }
            } while (A[P - 1] != 2);
            if (Constsfound != Nels) Fault(45, Constsfound);
            *Stptr = (*Stptr + 3) & (-4);
            Length = (Size + 3) & (-4);
            if (!Inhcode) Lput(Lputp, Length - Writ, *Stptr + Writ, Addr(Sp[0]));
            *Stptr = *Stptr + Length;
            R = Saver;
          }
          void Clear(int Length) {
            *Stptr = (*Stptr + 3) & (-4);
            Length = (Length + 3) & (-4);
            if (!Inhcode) Lput(Lputp, Length, *Stptr, 0);
            *Stptr = *Stptr + Length;
          }
          void Stag(int J, int Datalen) {
            if (Extrn == 2) Lput(14, Eptype << 24 | Datalen, Epdisp, Addr(Namtxt));
            Rbase = Cbase;
            Storetag(K, J);
            Rbase = Rlevel;
          }
          void Xtractconst(int Contype, int Conprec) {
            int Length;
            int Stype;
            int Sprec;
            int Sacc;
            int Cprec;
            int Mode;
            int I;
            Stype = Ptype;
            Sacc = Acc;
            if (Contype == 5) {
              Ctype = 5;
              if (A[P] == 4 && A[P + 1] == 2 && A[P + 2] == 0x35 && A[P + A[P + 7] + 8] == 2) {
                Sconst = *String(Addr(A[P + 7]));
                Length = A[P + 7];
                P = P + A[P + 7] + 9;
              } else {
                Fault(44, Constsfound);
                Sconst = _imp_str_literal("");
                Length = 0;
                P -= 3;
                Skipexp();
              }
            } else {
              Mode = Conprec << 4 | Contype;
              if (Conprec < 5) Mode = Contype | 0x50;
              Constp = Constexp(Mode);
              if (!Constp) {
                Fault(41, 0);
                Constp = Addr(Zero);
              }
              Ctype = Type;
              Cprec = Prec;
              if (Ctype == 1) {
                Iconst = *Integer(Constp);
                if (Conprec == 6) {
                  Uiconst = Iconst;
                  Iconst = *Integer(Constp + 4);
                }
              } else {
                Rconst = *Longreal(Constp);
                if (Conprec == 7)
                  for (I = 0; I <= 15; I++) *Byteinteger(Addr(Rconst) + I) = *Byteinteger(Constp + I);
              }
            }
            Ptype = Stype;
            Unpack();
            Acc = Sacc;
            if (Extrn == 3 || (Ctype == 5 && Length >= Acc) ||
                (Contype == 1 && ((Conprec == 3 && Iconst > 255) || (Conprec == 4 && Iconst > 0xFFFF))))
              Fault(44, Constsfound);
          }
        Bend:;
        }
        goto Cssexit;
      Sw_18:;
        Abort();
      Sw_10:;
        {
          int Mode;
          int Recl;
          int Alloc;
          int Fnam;
          int Finf;
          int Name;
          int Ophead;
          P++;
          Mode = A[P];
          Sndisp = 0;
          if (Mode == 1) {
            Name = Fromar2(P + 1);
            P += 3;
            Crformat(Ophead);
            K = Name;
            Ptype = 4;
            J = 0;
            Kform = Ophead;
            Storetag(K, Ophead);
            goto Bend;
          }
          P++;
          Marker = P + Fromar2(P);
          Fnam = Fromar2(Marker);
          Copytag(Fnam);
          Finf = Tcell;
          if (Type != 4) {
            Finf = Dummyformat;
            Acc = 4;
            Fault(62, Fnam);
          }
          Recl = Acc;
          if (Mode == 2) {
            Copytag(Fromar2(P + 2));
            if (A[P + 4] == 1 && Type == 4) {
              P += 5;
              Q = Displacement(Tcell);
              Unpack();
            }
            if (Type == 3 && Nam == 1 && (From3(Tcell) & 0xFFFF) == 0) {
              Replace3(Tcell, Finf | K << 16);
              Replace2(Tcell, Sndisp << 16 | Recl);
            } else
              Fault(63, 0);
          } else {
            if (Level < 2) Fault(57, 0);
            if (Nmdecs[Level] & 1) Fault(40, 0);
            Type = 3;
            Prec = 3;
            Rout = 0;
            if (A[P + 2] == 1) {
              Alloc = Acc;
              Cqn(P + 3);
              Acc = Alloc;
              P += 4;
              Declarescalars(1, Finf);
            } else {
              Nam = 0;
              Q = 2 - A[P + 3];
              P += 4;
              Setline();
              Declarearrays(Q, Finf);
            }
          }
        Bend:;
        }
        goto Cssexit;
      Sw_19:;
        if (Level < 2) Fault(57, 0);
        {
          auto void Cind(void);
          int Fname;
          int Alt;
          int Opcode;
          int Form;
          int H;
          int Q;
          int Mask;
          int Filler;
          static int Sw_sw;
          static void *Sw[5 /*1:5*/] = {
              &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5,
          };
          static int F_sw;
          static void *F[3 /*1:3*/] = {
              &&F_1,
              &&F_2,
              &&F_3,
          };
          static int Pop_sw;
          static void *Pop[6 /*1:6*/] = {
              &&Pop_1, &&Pop_2, &&Pop_3, &&Pop_4, &&Pop_5, &&Pop_6,
          };
          static int Top_sw;
          static void *Top[4 /*1:4*/] = {
              &&Top_1,
              &&Top_2,
              &&Top_3,
              &&Top_4,
          };
          Alt = A[P + 1];
          P += 2;
          Opcode = Call;
          goto *Sw[Sw_sw = (Alt)-1];
        Sw_1:
        Sw_2:;
          Fname = Fromar2(P);
          Copytag(Fname);
          if (Rout != Nam || Nam != 0 || Arr != 0 || Prec <= 4 || I != Rbase || Type == 7) Fault(33, Fname);
          if (Alt == 1)
            Psf1(St, 1, K);
          else
            Getinacc(Accr, (unsigned)Bytes[Prec] >> 2, 0, Lnb, K);
          goto Exit;
        Sw_3:;
          Type = A[P];
          Prec = (unsigned)Type >> 4;
          Type = Type & 7;
          if (Type != 1 || Prec >= 6) Fault(32, 0);
          if (Prec == 5) P += 2;
          Plant(Fromar2(P + 1));
          goto Exit;
        Sw_5:;
          Cnop(A[P], A[P + 1]);
          goto Exit;
        Sw_4:;
          Form = A[P];
          Opcode = A[P + 1];
          P += 2;
          goto *F[F_sw = (Form)-1];
        F_1:;
          Alt = A[P];
          P++;
          goto *Pop[Pop_sw = (Alt)-1];
        Pop_1:;
          Fname = Fromar2(P);
          P += 2;
          Enterjump(Opcode << 24 | 3 << 23, Fname, 0);
          goto Exit;
        Pop_2:;
          Cind();
        Popi:
          Psorlf1(Opcode, Access, Area, Disp);
          goto Exit;
        Pop_3:;
          Cind();
          Access = 4 - A[P];
          P++;
          goto Popi;
        Pop_4:;
          Cind();
          Access = 1;
          goto Popi;
        Pop_5:;
          Access = 4 - A[P];
          Area = 7;
          Disp = 0;
          P++;
          goto Popi;
        Pop_6:;
          Access = 0;
          Area = 7;
          Disp = 0;
          goto Popi;
        F_2:;
          Mask = 0;
          Filler = 0;
          Q = 0;
          Fname = 0;
          H = 2 - A[P];
          if (!H) {
            Fname = Fromar2(P + 1) - 1;
            P += 2;
          }
          if (0 > Fname || Fname > 127) Fault(32, 0);
          Alt = A[P + 1];
          P += 2;
          if (Alt == 1) {
            Q = 1;
            Mask = Fromar2(P);
            Filler = Fromar2(P + 2);
            P += 4;
            if (0 > (Mask | Filler) || (Mask | Filler) > 255) Fault(32, 0);
          }
          Pf2(Opcode, H, Q, Fname, Mask, Filler);
          goto Exit;
        F_3:;
          Mask = Fromar2(P);
          Alt = A[P + 2];
          if (0 > Mask || Mask > 15) Fault(32, 0);
          P += 3;
          goto *Top[Top_sw = (Alt)-1];
        Top_1:;
          Fname = Fromar2(P);
          P += 2;
          Enterjump(Opcode << 24 | Mask << 21, Fname, 0);
          goto Exit;
        Top_2:;
          Cind();
          if (Area >= 6) Fault(32, 0);
          if (Area == Lnb || Area == Xnb || Area == Ctb) Disp = Disp / 4;
        Topi:
          Pf3(Opcode, Mask, Area, Disp);
          goto Exit;
        Top_3:;
          Disp = 0;
          Area = 8 - A[P];
          P++;
          goto Topi;
        Top_4:;
          Disp = Fromar2(P);
          P += 2;
          Area = 1;
          goto Topi;
          void Cind(void) {
            int Alt;
            int Afn;
            int Fn0;
            int Fn1;
            int Fn2;
            int Fn3;
            int Jj;
            int D;
            int Ctype;
            int Cprec;
            static int Sw_sw;
            static void *Sw[4 /*1:4*/] = {
                &&Sw_1,
                &&Sw_2,
                &&Sw_3,
                &&Sw_4,
            };
            Afn = Addr(Fn0);
            Alt = A[P];
            Access = 0;
            P++;
            goto *Sw[Sw_sw = (Alt)-1];
          Sw_1:;
            P++;
            D = A[P];
            Ctype = A[P + 1];
            Cprec = (unsigned)Ctype >> 4;
            Ctype = Ctype & 7;
            if (Cprec == 4)
              Fn0 = Fromar2(P + 2);
            else
              for (Jj = 0; Jj <= Bytes[Cprec] - 1; Jj++) *Byteinteger(Afn + Jj) = A[P + Jj + 2];
            P = P + 2 + Bytes[Cprec];
            if (D == 2)
              if (Ctype == 2)
                Fn0 = Fn0 ^ 0x80000000;
              else if (Cprec == 6)
                Longinteger = -Longinteger;
              else
                Fn0 = -Fn0;
          Cnst:
            if (Ctype != 1 || Cprec > 5 || 0xFFFE0000 > Fn0 || Fn0 > 0x1FFFF) goto Lit;
            Area = 0;
            Disp = Fn0;
            return;
          Lit:
            if (1 > Ctype || Ctype > 2 || 5 > Cprec || Cprec > 7) Fault(32, 0);
            Storeconst(Disp, Bytes[Cprec], Afn);
            Area = Pc;
            Access = 0;
            return;
          Sw_2:;
            Fn0 = Fromar2(P);
            P += 2;
            Copytag(Fn0);
            if (Litl == 1 && Arr == 0) {
              Ctype = Type;
              Cprec = Prec;
              Alt = Tags[Fn0];
              From123(Alt, D, Fn0, Fn1);
              if (Cprec == 7) Afn = Fn1;
              goto Cnst;
            }
            if (Type >= 6 || Type == 4 || (Rout == 1 && Nam == 0)) {
              Fault(33, Fn0);
              return;
            }
            if (Rout == 1) K = From1(K);
            Area = Lnb;
            if (I != Rbase) Area = Setxorynb(Xnb, I);
            Alt = A[P];
            D = Fromar2(P + 1);
            if (Alt == 1) K += D;
            if (Alt == 2) K -= D;
            P++;
            if (Alt <= 2) P += 2;
            Disp = K;
            return;
          Sw_3:;
            Area = A[P] + 1;
            Alt = A[P + 1];
            P += 2;
            Disp = 0;
            D = Fromar2(P);
            if (Alt == 1) Disp = D;
            if (Alt == 2) Fault(32, 0);
            if (Area == Pc)
              Disp = Ca + 2 * Disp;
            else
              Disp = 4 * Disp;
            if (Alt != 3) P += 2;
            return;
          Sw_4:;
            Area = 6;
            Disp = 0;
          }
        Exit:
          Gruse[Accr] = 0;
          Gruse[Dr] = 0;
          Gruse[Breg] = 0;
          if (Opcode == Call || Opcode == Lxn || Opcode == Jlk || Opcode == Out) Gruse[Xnb] = 0;
          if (Opcode == Call || Opcode == Lct || Opcode == Jlk || Opcode == Out) Gruse[Ctb] = 0;
        }
        goto Cssexit;
      Sw_20:;
        if (Parmarr == 0 && Parmchk == 0) Compiler = 1;
        goto Cssexit;
      Sw_21:;
        Kk = Fromar2(P + 1);
        if (Cprmode) Fault(58, 0);
        Mainep = *String(Dictbase + Word[Kk]);
        goto Cssexit;
        void Crformat(int *Ophead) {
          int D1;
          int D2;
          int Nlist;
          int Form;
          int Rl;
          int Mrl;
          int Unscal;
          int Sc;
          int Desc;
          int Fn;
          int Inc;
          int Q;
          int R;
          int A0;
          int A1;
          int A2;
          int Dv;
          int Rfd;
          int Lb;
          int Ob;
          int Typep;
          int Sacc;
          static int Rfel_sw;
          static void *Rfel[5 /*1:5*/] = {
              &&Rfel_1, &&Rfel_2, &&Rfel_3, &&Rfel_4, &&Rfel_5,
          };
          auto void Sn(int Q);
          auto void Round(void);
          Nlist = 0;
          *Ophead = 0;
          Form = 0;
          Acc = 0;
          Ob = 0;
          Mrl = 0;
          Inc = 0;
        Next:
          Rout = 0;
          Litl = 0;
          Nam = 0;
          Rfd = A[P];
          if (Rfd <= 2) {
            P++;
            Clt();
          }
          goto *Rfel[Rfel_sw = (Rfd)-1];
        Rfel_1:;
          Cqn(P);
          P++;
          Pack(Ptype);
          D2 = 0;
          Rl = 3;
          if (Nam == 0 && 3 <= Prec && Prec <= 4) Rl = Prec - 3;
        Agn:
          Round();
          J = 0;
          do {
            D1 = Inc;
            Sn(P);
            P += 3;
            Inc += Acc;
          } while (A[P - 1] != 2);
          P += (unsigned)Rfd >> 2 << 1;
        Tryend:
          if (A[P] == 2) goto End;
          P++;
          goto Next;
        Rfel_2:
        Rfel2:;
          Q = P;
          Arr = 1;
          Pack(Ptype);
          if (Type <= 2) {
            Unscal = 0;
            Sc = Prec;
          } else {
            Unscal = 1;
            Sc = 3;
          }
          if (Prec == 4)
            Desc = 0x58000002;
          else
            Desc = Sc << 27 | Unscal << 25 | (1 - Parmarr) << 24;
          do {
            do
              P += 3;
            while (A[P - 1] != 2);
            Typep = Ptype;
            Sacc = Acc;
            Dv = Dopevector(Type, Acc, 0, Fromar2(Q), R, Lb) + 12;
            Acc = Sacc;
            Ptype = Typep;
            Unpack();
            if (Type == 5 || (Type == 1 && Prec == 3))
              Rl = 0;
            else
              Rl = 3;
            Round();
            do {
              A0 = R;
              if (!Unscal) A0 = A0 / Acc;
              if (Prec == 4) A0 = 0;
              A0 = A0 | Desc;
              A1 = Inc;
              if (Type <= 3 && Parmarr == 0 && 0 == Parmchk && J == 1) A1 -= Lb * Acc;
              A2 = 5 << 27 | 3 * J;
              Pgla(4, 16, Addr(A0));
              D1 = Glaca - 16;
              Relocate(D1 + 12, Dv, 1);
              Notecref(0x80000000 | ((unsigned)Dv << 1 >> 3) | (unsigned)(D1 + 12) >> 2 << 16, (Dv & 0xFFFF) << 2);
              D2 = Inc;
              Sn(Q);
              Inc += R;
              Q += 3;
            } while (A[Q - 1] != 2);
            P++;
            Q = P;
          } while (A[P - 1] != 2);
          if (Rfd == 5) P += 2;
          goto Tryend;
        Rfel_3:;
          Type = 3;
          Prec = 3;
          Nam = 1;
          Arr = 2 - A[P + 1];
          P += 2;
          Pack(Ptype);
          D2 = 0;
          Rl = 3;
          Acc = 8 + 8 * Arr;
          Form = 0;
          goto Agn;
        Rfel_4:;
        Rfel_5:;
          Q = P + Fromar2(P + 1) + 1;
          Fn = Fromar2(Q);
          Copytag(Fn);
          if (Ptype != 4) Fault(62, Fn);
          Type = 3;
          Prec = 3;
          Form = Tcell;
          if (Rfd == 4) {
            Ptype = 0x33;
            P += 3;
            D2 = 0;
            Rl = 3;
            goto Agn;
          }
          P += 3;
          goto Rfel2;
        End:;
          Rl = Mrl;
          Round();
          Acc = Inc;
          if (Inc > 0x7FFF) Fault(98, 0);
          Clearlist(Nlist);
          return;
          void Sn(int Q) {
            Fname = Fromar2(Q);
            if (Find(Fname, Nlist) != -1) Fault2(61, 0, Fname);
            Binsert(*Ophead, Ob, Fname << 20 | Ptype << 4 | J, D2 << 16 | Acc, D1 << 16 | Form);
            Push(Nlist, 0, Fname, 0);
          }
          void Round(void) {
            if (Rl > Mrl) Mrl = Rl;
            while (Inc & Rl) Inc++;
          }
        }
        int Displacement(int Link) {
          Listf *Fcell;
          Listf *Pcell;
          Listf *Lcell;
          int Rr;
          int Ii;
          int Ename;
          int Cell;
          Ename = (A[P] << 8) + A[P + 1];
          Cell = 0;
          if (Link) {
            Fcell = &Aslist[Link];
            Link = Fcell->S3 & 0x7FFF;
            Cell = Link;
            Ii = -1;
            Acc = -1;
            while (Link > 0) {
              Lcell = &Aslist[Link];
              if ((unsigned)Lcell->S1 >> 20 == Ename) {
                Tcell = Link;
                Rr = Lcell->S1;
                Sndisp = Lcell->S2;
                K = Lcell->S3;
                J = Rr & 15;
                Ptype = (unsigned)Rr >> 4 & 0xFFFF;
                Acc = Sndisp & 0xFFFF;
                Sndisp = (Sndisp & 0xFFFF0000) / 0x10000;
                Kform = K & 0xFFFF;
                K = (unsigned)K >> 16;
                if (Link != Cell) {
                  Pcell->Link = Lcell->Link;
                  Lcell->Link = Cell;
                  Fcell->S3 = Fcell->S3 & 0xFFFF0000 | Link;
                }
                return (K);
              }
              Pcell = Lcell;
              Link = Lcell->Link;
            }
          }
          Fault(65, Ename);
          if (Cell > 0) Push(Aslist[Cell].Link, Ename << 20 | 7 << 4, 0, 0);
          Ptype = 7;
          Tcell = 0;
          return (-1);
        }
        int Copyrecordtag(int *Subs) {
          int Q;
          int Fname;
          *Subs = 0;
          do {
            Fname = Kform;
            P += 2;
            Skipapp();
            if (A[P] == 2 || Fname <= 0) return (0);
            *Subs = *Subs + 1;
            P++;
            Q = Displacement(Fname);
            Unpack();
          } while (Type == 3);
          return (Q + 1);
        }
        void Crname(int Z, int Reg, int Mode, int Bs, int Ar, int Dp, int *Namep) {
          int Depth;
          int Fname;
          auto void Cename(int Mode, int Fname, int Bs, int Ar, int Dp, int Xd);
          Depth = 0;
          Fname = Kform;
          if (Arr == 0 || (Z == 6 && A[P + 2] == 2)) {
            if (A[P + 2] == 2)
              P += 3;
            else
              Noapp();
            Cename(Mode, Fname, Bs, Ar, Dp, 0);
          } else {
            Caname(Arr, Bs, Dp);
            Cename(Access, Fname, Base, Area, Disp, 0);
          }
          return;
          void Cename(int Mode, int Fname, int Bs, int Ar, int Dp, int Xd) {
            auto void Fetchrad(void);
            auto void Localise(int Size);
            int Q;
            int Qq;
            int D;
            int C;
            int W;
            Depth++;
            if (A[P] == 2) {
              Access = Mode;
              Area = Ar;
              Xdisp = Xd;
              Base = Bs;
              Disp = Dp;
              if (Z < 14)
                if ((3 > Z || Z > 4) && Z != 6) {
                  Fault(64, 0);
                  Base = Rbase;
                  Area = -1;
                  Disp = 0;
                  Access = 0;
                  Ptype = 1;
                  Unpack();
                }
              return;
            }
            P++;
            Q = Displacement(Fname);
            Unpack();
            if (Q == -1 && -1 == Acc || Ptype == 7) {
              P += 2;
              Skipapp();
              P -= 3;
              Access = 0;
              Base = Rbase;
              Disp = 0;
              Area = -1;
              return;
            }
            *Namep = (A[P] << 8 | A[P + 1]) << 16 | *Namep;
            if (Arr == 1) goto Ae;
            if (A[P + 2] == 2)
              P += 3;
            else
              Noapp();
            if (Type <= 2 || Type == 5 || (Type == 3 && A[P] == 2 && (3 <= Z && Z <= 4 || Z == 6))) {
              Access = Mode + 4 + 4 * Nam;
              Base = Bs;
              Area = Ar;
              Disp = Dp;
              Xdisp = Xd + Q;
              return;
            }
            Xd += Q;
            *Namep = -1;
            if (Nam == 1)
              if (!Mode) {
                Dp += Xd;
                Xd = 0;
                Mode = 2;
              } else {
                Localise(8);
                Ar = Area;
                Dp = Disp;
                Bs = Base;
              }
            Cename(Mode, Kform, Bs, Ar, Dp, Xd);
            return;
          Ae:;
            From123(Tcell, Q, Sndisp, K);
            Acc = Sndisp & 0xFFFF;
            Sndisp = (Sndisp & 0xFFFF0000) / 0x10000;
            Kform = K & 0xFFFF;
            K = (unsigned)K >> 16;
            C = Acc;
            D = Sndisp;
            Q = K;
            Qq = Kform;
            if ((Z == 6 || Z == 12) && A[P + 2] == 2) {
              P += 3;
              if (Nam == 1) {
                Access = Mode + 8;
                Base = Bs;
                Area = Ar;
                Disp = Dp;
                Xdisp = Xd + Q;
                return;
              }
              *Namep = -1;
              Fetchrad();
              Area = -1;
              Disp = Q;
              Base = 0;
              Access = 0;
              Createah(1);
            } else {
              *Namep = -1;
              if (Nam == 1) {
                Xd += Q;
                Localise(16);
                Caname(3, Base, Disp);
              } else {
                if (Mode == 0 || Mode == 2)
                  if (!Mode)
                    W = Dp - 4;
                  else
                    W = Dp + 4;
                else {
                  Fetchrad();
                  Getwsp(W, 1);
                  Psf1(St, 1, W);
                  Xd = 0;
                  Bs = Rbase;
                }
                Caname(3, 0, Q);
                if (Parmarr == 0 && 0 == Parmchk && Access == 3 && (Prec == 3 || Type >= 3)) {
                  Psorlf1(Adb, 0, Areacode2(Bs), W);
                  if (Xd) Psf1(Adb, 0, Xd);
                  Gruse[Breg] = 0;
                } else {
                  Getinacc(Dr, 2, 0, Areacode(), Q);
                  Psorlf1(Inca, 0, Areacode2(Bs), W);
                  if (Access == 1) {
                    Access = 2;
                    Area = 7;
                    Xd += Nummod * Bytes[Prec];
                  }
                  if (Xd) Psf1(Inca, 0, Xd);
                  Forget(Dr);
                  Area = 7;
                  Disp = 0;
                  if (Type == 3 && A[P] == 1) {
                    Getwsp(Disp, 2);
                    Psf1(Std, 1, Disp);
                    Area = Lnb;
                    Base = Rbase;
                  }
                }
              }
              if (Type == 3) Cename(Access, Qq, Base, Area, Disp, 0);
            }
            return;
            void Fetchrad(void) {
              Access = Mode + 4;
              Area = Ar;
              Base = Bs;
              Disp = Dp;
              Xdisp = Xd;
              Nameop(4, Accr, 4, -1);
            }
            void Localise(int Size) {
              int Hole;
              Access = Mode + 4;
              Area = Ar;
              Base = Bs;
              Disp = Dp;
              Xdisp = Xd;
              Nameop(2, Accr, Size, -1);
              Getwsp(Hole, (unsigned)Size >> 2);
              Psf1(St, 1, Hole);
              Mode = 2;
              Area = Lnb;
              Base = Rbase;
              Disp = Hole;
              Xd = 0;
            }
          }
        }
        void Cstrexp(int Mode, int Reg) {
          int Pp;
          int Wkarea;
          int Dots;
          int Rexp;
          int Err;
          int Clen;
          int Keepwa;
          int Fnam;
          auto int Strop(int Reg);
          Keepwa = Mode & 16;
          Mode = Mode & 15;
          Pp = P;
          Stringl = 0;
          Fnam = 0;
          Wkarea = 0;
          Rexp = 2 - A[P + 1 + Fromar2(P + 1)];
          if (A[P + 3] != 4 || Rexp != 0 || Mode != 0) goto Normal;
          if (A[P + 4] == 2) goto Simple;
          if (A[P + 4] != 1) goto Normal;
        Simple:
          P += 4;
          Err = Strop(Reg);
          if (Err) goto Error;
          Value = Wkarea;
          P++;
          Strfnres = 0;
          return;
        Error:
          Fault2(Err, 0, Fnam);
          Base = Rbase;
          Disp = 0;
          Value = 0;
          Access = 0;
          P = Pp;
          Skipexp();
          return;
        Normal:
          Clen = 0;
          P += 3;
          Err = 72;
          if (A[P] != 4) goto Error;
          P++;
          Getwsp(Wkarea, 268);
          Dots = 0;
        Next:
          Stringl = 0;
          Err = Strop(Dr);
          if (Err) goto Error;
          if (Register[Accr]) Bootout(Accr);
          Psf1(Lb, 0, Wkarea);
          Ppj(0, 19 + Dots);
          if (A[P] == 2) goto Tidy;
          Err = 72;
          if (A[P + 1] != Concop) goto Error;
          Dots = Dots | 1;
          P += 2;
          goto Next;
        Tidy:;
          Value = Wkarea;
          P++;
          if (!Keepwa) Returnwsp(Wkarea, 268);
          Stringl = 0;
          return;
          int Strop(int Reg) {
            int Ctype;
            int Val;
            int Mode;
            Mode = A[P];
            if (Mode > 2) return (75);
            if (Mode != 1) {
              Ctype = A[P + 1];
              if (Ctype == 0x35) {
                Stringl = A[P + 6];
                Disp = Fromar4(P + 2);
                P = P + Stringl + 7;
              } else
                return (71);
              Pf1(Ldrl, 0, Pc, Strlink);
              if (Disp) Psf1(Inca, 0, Disp);
              if (Stringl != 1) {
                if (Stringl <= 63)
                  Psf1(Ldb, 0, Stringl);
                else
                  Pf1(Ldb, 2, 7, 0);
              }
              Gruse[Dr] = 0;
              if (!Reg) Copydr();
            } else {
              P++;
              Reducetag();
              if (5 != Type && Type != 7) {
                Fnam = Fromar2(P);
                return (71);
              }
              Cname(2, Reg);
              Stringl = 0;
              if (Rout != 0 && Nam <= 1)
                if (Wkarea == 0 && Keepwa != 0)
                  Wkarea = Strfnres;
                else
                  Returnwsp(Strfnres, 268);
            }
            return (0);
          }
        }
        void Cres(int Lab) {
          int P1;
          int P2;
          int Sexprn;
          int W;
          int Last;
          int Err;
          int Fnam;
          Rd R;
          Last = 0;
          Fnam = 0;
          Sexprn = 0;
          Err = 74;
          Psf1(Inca, 0, 1);
          P1 = P;
          P += 3;
          if (A[P] == 4) goto Res;
          Err = 72;
        Error:
          Fault2(Err, 0, Fnam);
          P = P1;
          Skipexp();
          return;
        Res:
          P++;
          Psf1(Prcl, 0, 4);
          if (!Sexprn)
            W = Std;
          else
            W = St;
          Pf1(W, 0, Tos, 0);
          if (A[P] == 3) {
            Psf1(Lsd, 0, 0);
            Gruse[Accr] = 0;
          } else {
            if (A[P] != 1) goto Error;
            P++;
            P2 = P;
            Cname(3, Accr);
            if (Type != 5) {
              Err = 71;
              Fnam = Fromar2(P2);
              goto Error;
            }
            if (A[P + 1] != Concop) {
              Err = 72;
              goto Error;
            }
            P += 2;
          }
          Pf1(St, 0, Tos, 0);
          if (A[P] != 3) goto Error;
          Sexprn++;
          P++;
          Cstrexp(0, Dr);
          Pf1(Std, 0, Tos, 0);
          Psf1(Raln, 0, 11);
          Ppj(-1, 16);
          if (Lab)
            Enterjump(7, Lab, 0b11);
          else
            Ppj(7, 12);
          if (A[P] == 2) goto End;
          if (A[P + 1] != Concop) {
            Err = 72;
            goto Error;
          }
          if (A[P + 2] != 1) goto Error;
          P2 = P + 1;
          P = P2 + 1;
          do {
            P += 3;
            Skipapp();
          } while (A[P] != 2);
          if (A[P + 1] == 1) {
            P = P2;
            goto Res;
          }
          P1 = P + 1;
          Register[Accr] = 1;
          Olink[Accr] = Addr(R);
          R.Ptype = 1;
          R.Xb = Accr;
          R.Flag = 9;
          P = P2 + 2;
          Cname(1, Dr);
          if (R.Flag != 9) Pf1(Lsd, 0, Tos, 0);
          Register[Accr] = 0;
          Pf1(Stuh, 0, Breg, 0);
          Pf1(Luh, 0, Breg, 0);
          Pf2(Mvl, 0, 0, 0, 0, 0);
          if (Rout != 0 || Nam != 0) Ppj(0, 18);
          Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
          Gruse[Accr] = 0;
          if (Parmarr == 1) {
            Psf1(Ush, 0, 8);
            Psf1(Ush, 0, -40);
            Ppj(36, 9);
          }
          P = P1;
        End:;
          P++;
        }
        void Saveauxstack(void) {
          int Xynb;
          int Dr0;
          int Dr1;
          if (!Auxst) {
            Dr0 = 0x30000001;
            Dr1 = 0;
            Pgla(8, 8, Addr(Dr0));
            Auxst = Glaca - 8;
            Gxref(Auxstep, 2, 0x02000008, Auxst + 4);
          }
          if (!Auxsbase[Level]) {
            Xynb = Setxorynb(-1, -1);
            Pf1(Ld, 2, Xynb, Auxst);
            if (Parmopt) {
              Pf1(Lss, 1, 0, 2);
              Psf1(St, 1, N + 16);
            }
            Pf1(Lss, 2, 7, 0);
            Psf1(Std, 1, N);
            Psf1(St, 1, N + 8);
            Auxsbase[Level] = N;
            N += 16;
            if (Parmopt) N += 4;
            Gruse[Dr] = 0;
            Gruse[Accr] = 11;
            Grinf1[Accr] = 0;
          }
        }
        void Resetauxstack(void) {
          if (Auxsbase[Level]) {
            Psf1(Lb, 1, Auxsbase[Level] + 8);
            Psf1(Stb, 2, Auxsbase[Level]);
            Gruse[Breg] = 0;
          }
        }
        void Rtexit(void) {
          Resetauxstack();
          Psf1(Exit, 0, -0x40);
        }
        void Claimstframe(int At, int Value) {
          int Instr;
          int Wk;
          Wk = (unsigned)At >> 18;
          At = At & 0x3FFFF;
          Instr = (Asf + 12 * Parmchk) << 24 | 3 << 23 | (unsigned)(Value - Wk + 3) >> 2;
          Plug(1, At, Instr, 4);
        }
        void Cend(int Kkk) {
          int Kp;
          int Jj;
          int Bit;
          auto void Dtable(int Level);
          if (Kkk != 2) Setline();
          Forget(-1);
          Bit = 1 << Level;
          if ((Kkk & 0x3FFF) > 0x1000 && Compiler == 0 && Lastinst == 0) Ppj(15, 10);
          if (N > Nmax) Nmax = N;
          while (Label[Level]) {
            Pop(Label[Level], I, J, Kp);
            I = (unsigned)I >> 24;
            if (J & 0xFFFF) {
              J = J & 0xFFFF;
              if (0 < Kp && Kp <= Maxulab) Fault2(11, From3(J), Kp);
              Clearlist(J);
            } else if (I == 0 && Kp < Maxulab)
              Warn(3, Kp);
          }
          for (Jj = 0; Jj <= 4; Jj++) {
            Clearlist(Avlwsp[Jj][Level]);
          }
          Dtable(Level);
          Nmax = (Nmax + 7) & (-8);
          if (Kkk == 2) return;
          if (Kkk >= 0x1000 || Kkk == 1) Claimstframe(Set[Rlevel], Nmax);
          if ((Kkk & 0x3FFF) == 0x1000 && Lastinst == 0) Rtexit();
          if (Kkk == 1 && Lastinst == 0) Ppj(15, 21);
          if (!Kkk) {
            if (Parmtrace == 1) {
              Psf1(Ld, 1, 12);
              Diagpointer(Level - 1);
              Psf1(Std, 1, 12);
            }
            if (Stack) {
              Jj = (unsigned)Nmdecs[Level] >> 14;
              if (Jj) {
                Pf1(Stsf, 0, Tos, 0);
                Pf1(Lss, 0, Tos, 0);
                Psf1(Isb, 1, Jj);
                Psf1(Ush, 0, -2);
                Pf1(St, 0, Tos, 0);
                Pf1(Asf, 0, Tos, 0);
                Gruse[Accr] = 0;
              }
            } else
              Resetauxstack();
          }
          if (Level <= 2 && (Level != 2 || Cprmode != 2))
            if (Kkk == 1 && Level == 2)
              Kkk = 2;
            else {
              Fault(14, 0);
              exit(0);
            }
          Level--;
          if (Kkk >= 0x1000) {
            Rlevel--;
            Rbase = Rlevel;
          }
          Pop(Levelinf, Kp, N, Kp);
          if (Kkk >= 0x1000) Nmax = (unsigned)N >> 16;
          N = N & 0x7FFF;
          if (Kkk == 2) Cend(Kkk);
          if (Aslwarn) {
            Aslwarn = 0;
            Epilogue();
          }
          if (Kkk >= 0x1000 && Compiler == 0 && (Rlevel > 0 || Cprmode != 2)) {
            Jj = Nextp + 6;
            if (A[Nextp + 5] != 11 || A[Jj + Fromar2(Jj)] != 2) {
              Jj = Enterlab(Jround[Level + 1], 0);
              Jround[Level + 1] = 0;
            }
          }
          return;
          void Dtable(int Level) {
            _imp_string Rtname;
            _imp_string Localname;
            Listf *Lcell;
            static const int Larrrout = 0xF300;
            int Dptr;
            int Lnum;
            int Ml;
            int Kk;
            int Jj;
            int Q;
            int Dend;
            int Bit;
            int S1;
            int S2;
            int S3;
            int S4;
            int Langd;
            int Ii;
            int Dd[501 /*0:500*/];
            Bit = 1 << Level;
            Langd = (unsigned)Kkk >> 14 << 30 | Level << 18;
            while (Ral[Level]) {
              Pop(Ral[Level], Q, Jj, Kk);
              Plug(Q, Jj, Kk | Sstl, 4);
            }
            if (Parmtrace) Push(Ral[Level - 1], 4, Sstl + 4, Langd);
            Dd[0] = L[Level] << 16 | (Diaginf[Level]);
            Dd[1] = Langd;
            Dd[2] = Display[Rlevel] << 16 | Flag[Level] & 0x3FFF;
            Ml = M[Level];
            Lnum = *Byteinteger(Dictbase + Ml);
            Dptr = 4;
            Dend = 0;
            if (!Lnum)
              Dd[3] = 0;
            else {
              Q = Dictbase + Ml;
              Rtname = *String(Q);
              Lnum = *Byteinteger(Addr(Rtname));
              *String(Addr(Dd[3])) = Rtname;
              Dptr += (unsigned)Lnum >> 2;
            }
            Dd[Dptr] = Onword[Level];
            Dptr++;
            Jj = Names[Level];
            while (0 <= Jj && Jj < 0x3FFF) {
              Lcell = &Aslist[Tags[Jj]];
              if (!(Lcell->S1 & 0xF000)) Warn(2, Jj);
              S1 = Lcell->S1;
              S2 = Lcell->S2;
              S3 = Lcell->S3;
              S4 = Lcell->Link;
              Lcell->Link = Asl;
              Asl = Tags[Jj];
              Tags[Jj] = S4 & 0x3FFFF;
              Ptype = (unsigned)S1 >> 16;
              Type = Ptype & 15;
              I = (unsigned)S1 >> 4 & 15;
              J = S1 & 15;
              K = (unsigned)S3 >> 16;
              if (Parmdiag != 0 && (Ptype & 0x7300) <= 0x200 && Dptr < 497 && (Type == 1 || Type == 2 || Type == 5)) {
                Q = Dictbase + Word[Jj];
                if (!I)
                  Ii = 1;
                else
                  Ii = 0;
                Dd[Dptr] = Ptype << 20 | Ii << 18 | K;
                Localname = *String(Q);
                Lnum = *Byteinteger(Addr(Localname));
                *String(Addr(Dd[Dptr]) + 4) = Localname;
                Dptr += (unsigned)(Lnum + 8) >> 2;
              }
              if (J == 15 && S2 != 0) Fault2(28, 0, Jj);
              if ((Ptype & 0x3000) != 0 || Type == 4 || Type == 6)
                Clearlist(K);
              else if (I != 0 && K > 511 && (Ptype & Larrrout) == 0 && Type != 7)
                Warn(5, Jj);
              Jj = (unsigned)S4 >> 18;
            }
            Dd[Dptr] = -1;
            Dptr = (Dptr << 2) + 4;
            if (Parmtrace == 1) {
              Lput(4, Dptr, Sstl, Addr(Dd[0]));
              Sstl += Dptr;
            }
          }
        }
        void Makedecs(int Q) {
          int Qq;
          int Head;
          int Prio;
          int Count;
          int Sl;
          int *Thead;
          Listf *Cell;
          Sl = Line;
          Qq = Fromar4(Q);
          Head = 0;
          Count = 0;
          while (Qq) {
            Count++;
            if (A[Qq + 5] != 8) Abort();
            P = Qq + 10;
            Clt();
            if (Prec == 3 || A[P] != 1 || A[P + 1] != 3) {
              if (A[P] == 1) Insertatend(Head, 0xFFFF, Qq, 0);
            } else {
              Prio = Prec << 4 | Type;
              Thead = &Head;
              for (;;) {
                Cell = &Aslist[*Thead];
                if (*Thead == 0 || Prio < Cell->S1) {
                  Push(*Thead, Prio, Qq, 0);
                  break;
                }
                Thead = &Cell->Link;
              }
            }
            Qq = Fromar4(Qq + 6);
          }
          if (Count >= 7) {
            Getwsp(Qq, 2);
            if (!Avlwsp[1][Level]) Getwsp(Qq, 1);
          }
          while (Head) {
            Pop(Head, Prio, Qq, Count);
            Line = Fromar2(Qq + 3);
            P = Qq + 10;
            Clt();
            Rout = 0;
            Litl = 0;
            Cqn(P + 1);
            P += 2;
            Declarescalars(1, 0);
          }
          Line = Sl;
        }
        void Declarescalars(int Permit, int Xtra) {
          int Inc;
          int Q;
          int Schain;
          int Dmade;
          int Nparms;
          int D0;
          int Scalname;
          int Typep;
          Pack(Ptype);
          J = 0;
          Inc = Acc;
          Dmade = 0;
          Sndisp = 0;
          if (Ptype == 0x33) Inc = (Inc + 3) & (-4);
          if (Nam != 0 && Rout == 0 && Arr == 0) Inc = 8;
          if (Nam > 0 && Arr > 0) Inc = 16;
          if (Ptype == 0x35 && Acc == 0) Fault(70, 0);
          if (Permit != 0 && (Inc == 8 || Inc == 16)) Oddalign();
          if (Ptype == 0x33 || (Ptype == 0x35 && Permit != 0)) {
            D0 = 0x18000000 + Acc;
            Storeconst(Q, 4, Addr(D0));
            Pf1(Ldtb, 0, Pc, Q);
            Gruse[Dr] = 0;
          }
          if (Ptype == 0x35) {
            Inc = 8;
            if (Permit) {
              Pf1(Stsf, 0, Tos, 0);
              Pf1(Lda, 0, Tos, 0);
            }
          }
          N = (N + 3) & (-4);
          if (Ptype == 0x33) {
            Psf1(Lda, 1, Ptroffset(Rbase));
            Psf1(Inca, 0, N + 8);
          }
          do {
            Dmade++;
            Scalname = Fromar2(P);
            if (Ptype == 0x31 && Permit == 0) N += 3;
            if (Ptype == 0x41 && Permit == 0) N += 2;
            Schain = N;
            Kform = Xtra;
            if (Rout == 1) {
              Typep = Ptype;
              Q = P;
              do
                P += 3;
              while (A[P - 1] != 2);
              Cfplist(Schain, Nparms);
              P = Q;
              J = 13;
              Kform = Nparms;
              Acc = N;
              Ptype = Typep;
              Unpack();
            }
            P += 3;
            if (Ptype == 0x33) {
              Psf1(Std, 1, N);
              N += 8;
              Schain = N;
              if (A[P - 1] == 1) Psf1(Inca, 0, Inc + 8);
            }
            if (Ptype == 0x35 && Permit != 0) {
              Psf1(Std, 1, N);
              if (A[P - 1] == 1)
                Psf1(Inca, 0, (Acc + 3) & (-4));
              else {
                Q = ((unsigned)(Acc + 3) >> 2) * Dmade;
                Psf1(Asf + 12 * Parmchk, 0, Q);
                if (Parmchk) Ppj(0, 4);
              }
            }
            Storetag(Scalname, Schain);
            N += Inc;
          } while (A[P - 1] != 2);
          if (Permit) N = (N + 3) & (-4);
        }
        int Dopevector(int Typep, int Elsize, int Mode, int Iden, int *Asize, int *Lb) {
          int I;
          int Jj;
          int K;
          int Nd;
          int D;
          int Unscal;
          int M0;
          int Head;
          int Nops;
          int Typepp;
          int Pin;
          int Ptr;
          Listf *Lcell;
          int Lbh[13 /*0:12*/];
          int Lbb[13 /*0:12*/];
          int Ubh[13 /*0:12*/];
          int Ubb[13 /*0:12*/];
          int Dv[40 /*0:39*/];
          Nd = 0;
          Nops = 0;
          Typepp = 0;
          Pin = P;
          if (Typep > 2 || (Typep == 1 && Prec == 4)) {
            Unscal = 1;
            M0 = Elsize;
          } else {
            Unscal = 0;
            M0 = 1;
          }
          do {
            Nd++;
            P += 4;
            Lbh[Nd] = 0;
            Lbb[Nd] = 0;
            Ubb[Nd] = 0;
            Ubh[Nd] = 0;
            Torp(Lbh[Nd], Lbb[Nd], Nops);
            P += 3;
            Typepp = Typepp | Type;
            Torp(Ubh[Nd], Ubb[Nd], Nops);
            Typepp = Typepp | Type;
          } while (A[P] != 2);
          P++;
          if (Typepp != 1 || (Nops & 0x40040000) != 0) goto Nonconst;
          Ptr = 1;
          for (D = Nd; D >= 1; D--) {
            K = 3 * D;
            Expop(Lbh[Ptr], Accr, Nops, 0x251);
            if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51) {
              Expopnd.D = 0;
              Fault(41, 0);
            }
            Dv[K] = Expopnd.D;
            Dv[K + 1] = M0;
            Expop(Ubh[Ptr], Accr, Nops, 0x251);
            if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51) {
              Expopnd.D = 10;
              Fault(41, 0);
            }
            Jj = Expopnd.D;
            M0 = M0 * (Jj - Dv[K] + 1);
            if (Jj < Dv[K]) Fault2(38, 1 - M0, Iden);
            Dv[K + 2] = M0;
            Ptr++;
          }
          if (!Unscal) M0 = M0 * Elsize;
          if (Nd == 1) *Lb = Dv[3];
          *Asize = M0;
          Dv[2] = *Asize;
          Dv[1] = 12;
          Dv[0] = 5 << 27 | 3 * Nd;
          K = 3 * Nd + 2;
          J = Nd;
          Head = Dvheads[Nd];
          while (Head) {
            Lcell = &Aslist[Head];
            if (Lcell->S2 == *Asize && Lcell->S3 == Dv[5]) {
              for (D = 0; D <= K; D++)
                if (Dv[D] != Ctable->Val) goto On;
              return (0x80000000 | 4 * Lcell->S1);
            }
          On:;
            Head = Lcell->Link;
          }
          if (Constptr & 1) {
            Consthole = Constptr;
            Constptr++;
          }
          I = 4 * Constptr | 0x80000000;
          Push(Dvheads[Nd], Constptr, *Asize, Dv[5]);
          for (D = 0; D <= K; D++) {
            Ctable->Val = Dv[D];
            Constptr++;
          }
          if (Constptr > Constlimit) Fault(107, 0);
        Wayout:;
          for (D = Nd; D >= 1; D--) {
            Aslist[Lbb[D]].Link = Asl;
            Asl = Lbh[D];
            Aslist[Ubb[D]].Link = Asl;
            Asl = Ubh[D];
          }
          return (I);
        Nonconst:;
          J = Nd;
          I = -1;
          *Lb = 0;
          *Asize = Elsize;
          if (!Mode)
            Fault(41, 0);
          else
            P = Pin;
          goto Wayout;
        }
        void Declarearrays(int Format, int Finf) {
          auto void Claimas(void);
          int Dvdisp;
          int Pp;
          int Dvf;
          int Elsize;
          int Totsize;
          int D0;
          int D1;
          int Ptypep;
          int Arrp;
          int Nn;
          int Nd;
          int Ii;
          int Jj;
          int Qq;
          int R;
          int Cdv;
          int Unscal;
          int Desc;
          int Sc;
          int Lwb;
          int Ptypepp;
          int Jjj;
          int Jjjj;
          int Adj;
          if (Stack != 0 && Flag[Level] == 0 && 0 == (unsigned)Nmdecs[Level] >> 14) {
            Psf1(Stsf, 1, N);
            Nmdecs[Level] = Nmdecs[Level] | (N << 14);
            N += 4;
          }
          if (!Stack) Saveauxstack();
          Arrp = 2 * Format + 1;
          Arr = Arrp;
          Pack(Ptypep);
          Elsize = Acc;
          if (Type > 2 || (Type == 1 && Prec == 4)) {
            Unscal = 1;
            Sc = 3;
          } else {
            Unscal = 0;
            Sc = Prec;
          }
          Desc = Sc << 27 | Unscal << 25 | (1 - Parmarr) << 24;
          if (Prec == 4) Desc = 0x58000002;
        Start:
          Nn = 1;
          P++;
          Pp = P;
          Cdv = 0;
          Ptypepp = Ptypep;
          while (A[P + 2] == 1) {
            P += 3;
            Nn++;
          }
          P += 3;
          Dvdisp = Dopevector(Type, Elsize, 1, Fromar2(Pp), Totsize, Lwb);
          Nd = J;
          if (Dvdisp != -1) goto Constdv;
          Dvf = 0;
          Totsize = 0xFFFF;
          Dvdisp = N;
          N = N + 12 * Nd + 12;
          if (Nd > 12) Fault(37, 0);
          D0 = 5 << 27 | 3 * Nd;
          D1 = 12;
          Storeconst(Jj, 8, Addr(D0));
          Pf1(Ld, 0, Pc, Jj);
          Psf1(Std, 1, Dvdisp);
          Gruse[Dr] = 0;
          if (!Unscal)
            Jj = 1;
          else
            Jj = Elsize;
          Psf1(Lss, 0, Jj);
          Gruse[Accr] = 0;
          for (Ii = Nd; Ii >= 1; Ii--) {
            P++;
            Qq = Dvdisp + 12 * Ii;
            Psf1(St, 1, Qq + 4);
            Csexp(Accr, 0x51);
            if (Nd == 1 && (Ptypep & 7) <= 3 && Format == 0 && Gruse[Accr] == 5 && Grinf1[Accr] == 0) Ptypepp += 256;
            Psf1(St, 1, Qq);
            Csexp(Accr, 0x51);
            Psf1(Isb, 1, Qq);
            Gruse[Accr] = 0;
            if (Compiler == 0 || Parmarr != 0) {
              Pf3(Jaf, 6, 0, 3);
              Psf1(Lss, 0, -1);
            }
            Psf1(Iad, 0, 1);
            Psf1(Imy, 1, Qq + 4);
            Psf1(St, 1, Qq + 8);
          }
          P++;
          if (Unscal == 0 && Elsize != 1) Psf1(Imy, 0, Elsize);
          Psf1(St, 1, Dvdisp + 8);
          Sndisp = 0;
          goto Decl;
        Constdv:;
          Dvf = 1;
          Cdv = 1;
          if (Nd == 1 && Lwb == 0 && (Ptypep & 15) <= 3 && Format == 0) Ptypepp = Ptypep + 256;
          Sndisp = (unsigned)(Dvdisp & 0xFFFFFF) >> 2;
        Decl:;
          J = Nd;
          Oddalign();
          Ptype = Ptypepp;
          Unpack();
          if (Dvf) {
            R = Totsize;
            if (!Unscal) R = R / Elsize;
            D0 = Desc;
            if (Prec != 4) D0 = D0 | R;
            Storeconst(D1, 4, Addr(D0));
            Pf1(Lb, 0, Pc, D1);
          } else {
            Storeconst(D1, 4, Addr(Desc));
            Pf1(Lb, 0, Pc, D1);
            if (Prec != 4) Psf1(Adb, 1, Dvdisp + 20);
          }
          if (Dvf)
            Qq = Pc;
          else
            Qq = Lnb;
          Psorlf1(Ldrl, 0, Qq, Dvdisp);
          Gruse[Breg] = 0;
          Gruse[Dr] = 0;
          for (Jjj = 0; Jjj <= Nn - 1; Jjj++) {
            Psf1(Stb, 1, N + 16 * Jjj);
            Psf1(Std, 1, N + 8 + 16 * Jjj);
          }
          if (Parmarr == 0 && Parmchk == 0 && Nd == 1 && Type <= 3 && (Ptypepp & 0xF00) != 0x200)
            Adj = 1;
          else
            Adj = 0;
          for (Jjj = 0; Jjj <= Nn - 1; Jjj++) {
            if (Adj)
              if (Stack) {
                Pf1(Stsf, 0, Breg, 0);
                if (Dvf)
                  Psf1(Sbb, 0, Lwb * Elsize);
                else if (Elsize == 1)
                  Psf1(Sbb, 1, Dvdisp + 12);
                else {
                  Psf1(Slb, 1, Dvdisp + 12);
                  Psf1(Myb, 0, Elsize);
                  Pf1(Slb, 0, Tos, 0);
                  Pf1(Sbb, 0, Tos, 0);
                }
                Psf1(Stb, 1, N + 4);
                Gruse[Breg] = 0;
              } else {
                if (Dvf) {
                  if (Gruse[Accr] != 11) {
                    Psf1(Lss, 2, Auxsbase[Level]);
                    Gruse[Accr] = 11;
                    Grinf1[Accr] = 0;
                  }
                  Jjjj = Lwb * Elsize - Grinf1[Accr];
                  if (Jjjj) Psf1(Isb, 0, Jjjj);
                  Grinf1[Accr] = Lwb * Elsize;
                } else {
                  if (Gruse[Accr] == 11 && Grinf1[Accr] == 0 && Elsize == 1)
                    Psf1(Isb, 1, Dvdisp + 12);
                  else {
                    Psf1(Lss, 1, Dvdisp + 12);
                    if (Elsize != 1) Psf1(Imy, 0, Elsize);
                    Psf1(Irsb, 2, Auxsbase[Level]);
                  }
                  Gruse[Accr] = 0;
                }
                Psf1(St, 1, N + 4);
              }
            else if (Stack)
              Psf1(Stsf, 1, N + 4);
            else {
              if (Gruse[Accr] != 11 || Grinf1[Accr] != 0) Psf1(Lss, 2, Auxsbase[Level]);
              Psf1(St, 1, N + 4);
              Gruse[Accr] = 11;
              Grinf1[Accr] = 0;
            }
            Acc = Elsize;
            Kform = Finf;
            K = Fromar2(Pp + 3 * Jjj);
            Storetag(K, N);
            if (!Format) Claimas();
            N += 16;
          }
          P++;
          if (A[P - 1] == 1) goto Start;
          return;
          void Claimas(void) {
            int T;
            int B;
            int D;
            int Adjment;
            if (Stack == 1) {
              if (Cdv == 1) {
                T = (Totsize + 3) / 4;
                Psf1(Asf + 12 * Parmchk, 0, T);
                if (Parmchk) Ppj(0, 4);
              } else if (Parmchk == 0 && (Ptypep & 7) <= 2 && (Elsize == 4 || Elsize == 8)) {
                Psf1(Asf, 1, Dvdisp + 20);
                if (Elsize == 8) Psf1(Asf, 1, Dvdisp + 20);
              } else {
                Psf1(Lss, 1, Dvdisp + 8);
                if (Elsize & 3) Psf1(Iad, 0, 3);
                Psf1(Ush, 0, -2);
                Pf1(St, 0, Breg, 0);
                Forget(Breg);
                if (Parmchk)
                  Ppj(0, 4);
                else
                  Pf1(Asf, 0, Breg, 0);
              }
              Checkstof();
            } else {
              if (Gruse[Accr] != 11 || (Grinf1[Accr] != 0 && Cdv != 1)) {
                Psf1(Lss, 2, Auxsbase[Level]);
                Gruse[Accr] = 11;
                Grinf1[Accr] = 0;
              }
              if (Cdv == 1) {
                Adjment = ((Totsize + 7) & (-8)) + Grinf1[Accr];
                if (Adjment < 0x1FFFF) {
                  B = 0;
                  D = Adjment;
                } else {
                  Storeconst(D, 4, Addr(Adjment));
                  B = Pc;
                }
                if (Adj == 1 && Jjj != Nn - 1 && Parmopt == 0)
                  Grinf1[Accr] = Adjment;
                else {
                  Grinf1[Accr] = 0;
                  if (B != D || D != 0) Psorlf1(Iad, 0, B, D);
                }
              } else {
                B = Lnb;
                D = Dvdisp + 8;
                Psf1(Iad, 1, D);
                if (Elsize & 7) {
                  Psf1(Iad, 0, 7);
                  Psf1(And, 0, -8);
                }
                Grinf1[Accr] = 0;
              }
              if (Jjj == Nn - 1 || (Adj == 1 && Cdv == 0)) Psf1(St, 2, Auxsbase[Level]);
              if (Parmopt) {
                Psf1(Icp, 1, Auxsbase[Level] + 16);
                Ppj(2, 8);
              }
              if (Parmchk) {
                Pf1(Ldtb, 0, Pc, Paramdes(3));
                Psorlf1(Ldb, 0, B, D);
                Psf1(Lda, 1, N + 4);
                Pf2(Mvl, 1, 1, 0, 0, Unasspat & 255);
                Gruse[Dr] = 0;
              }
            }
          }
        }
        void Clt(void) {
          static const unsigned char Typeflag[10 /*1:10*/] = {0x51, 0x52, 0, 0x31, 0x35, 0x41, 0, 0x62, 0x61, 0x72};
          int Alt;
          Alt = A[P];
          Type = Typeflag[Alt];
          if (!Type) {
            P++;
            Type = Typeflag[A[P] + 7];
          }
          Prec = (unsigned)Type >> 4;
          Type = Type & 7;
          if (Type == 2 && Alllong != 0 && Prec <= 5) Prec = 6;
          Acc = Bytes[Prec];
          if (Type == 5)
            if (A[P + 1] == 1) {
              P += 2;
              Acc = A[P] + 1;
            } else {
              Acc = 0;
              P++;
            }
          P++;
        }
        void Cqn(int P) {
          int I;
          I = A[P];
          Nam = 0;
          Arr = 0;
          if (I == 1) {
            Arr = 1;
            Acc = 16;
          }
          if (I <= 2) Nam = 1;
          if (I == 2) Acc = 8;
        }
        void Crspec(int M) {
          int Kk;
          int Jj;
          int Typep;
          int Ophead;
          int Nparms;
          _imp_string Xname;
          Litl = Extrn & 3;
          if (A[P] == 1) {
            Typep = Litl << 14 | 0x1000;
            P += 2;
          } else {
            Rout = 1;
            Arr = 0;
            P++;
            Clt();
            Nam = 0;
            if (A[P] == 2) Nam = 2;
            Pack(Typep);
            P += 2;
          }
          P += 4;
          Kk = Fromar2(P);
          Jj = 0;
          P += 2;
          Cfplist(Ophead, Nparms);
          if (M == 1) {
            Xname = *String(Dictbase + Word[Kk]);
            if (Extrn == 1) Xname = _imp_join(_imp_str_literal("S#"), Xname);
            Cxref(Xname, Parmdynamic | (Extrn / 3), 2, Jj);
          }
          if (M == 0 && Rlevel == 0) Codedes(Jj);
          J = 15 - M;
          Ptype = Typep;
          Kform = Nparms;
          Sndisp = (unsigned)Jj >> 16;
          Acc = Jj & 0xFFFF;
          Storetag(Kk, Ophead);
        }
        void Cfplist(int *Ophead, int *Nparms) {
          int Opbot;
          int Pp;
          *Ophead = 0;
          Opbot = 0;
          *Nparms = 0;
          while (A[P] == 1) {
            Pp = P + 1 + Fromar2(P + 1);
            P += 3;
            Cfpdel();
            do {
              Binsert(*Ophead, Opbot, Ptype << 16, Acc << 16, 0);
              *Nparms = *Nparms + 1;
              P += 3;
            } while (A[P - 1] != 2);
            P = Pp;
          }
          P++;
        }
        void Cfpdel(void) {
          static int Fp_sw;
          static void *Fp[4 /*1:4*/] = {
              &&Fp_1,
              &&Fp_2,
              &&Fp_3,
              &&Fp_4,
          };
          int Fpalt;
          Fpalt = A[P];
          P++;
          Kform = 0;
          Litl = 0;
          goto *Fp[Fp_sw = (Fpalt)-1];
        Fp_1:;
          Rout = 0;
          Clt();
          Cqn(P);
          if (Type == 5 && Acc == 0) Fault(70, 0);
          P++;
          goto Pk;
        Fp_2:;
          Arr = 2 - A[P];
          Rout = 0;
          Acc = 8 + 8 * Arr;
          Type = 3;
          Prec = 3;
          Nam = 1;
          P++;
          goto Pk;
        Fp_3:;
          Rout = 1;
          Nam = 1;
          Arr = 0;
          if (A[P] == 1) {
            Type = 0;
            Prec = 0;
            P += 2;
          } else {
            P++;
            Clt();
            Nam = 1;
            if (A[P] == 2) Nam = 3;
            P += 2;
          }
          Acc = 16;
          goto Pk;
        Fp_4:;
          Acc = 8;
          Nam = 1;
          Rout = 0;
          Type = 0;
          Arr = 0;
          Prec = 0;
        Pk:
          Pack(Ptype);
        }
        void Diagpointer(int Level) {
          if (Parmtrace) {
            Push(Ral[Level], 1, Ca, Ldb << 24 | 3 << 23);
            Pf1(Ldb, 0, 0, 0);
            Gruse[Dr] = 0;
          }
        }
        void Rhead(int Kk) {
          int W1;
          int W3;
          int Insrn;
          int At;
          Push(Levelinf, 0, Nmax << 16 | N, 0);
          Level++;
          Nmdecs[Level] = 0;
          Auxsbase[Level] = 0;
          Names[Level] = -1;
          Oninf[Level] = 0;
          Onword[Level] = 0;
          if (Kk >= 0) {
            Rlevel++;
            Rbase = Rlevel;
          }
          if (Level == Maxlevels) Fault(34, 0);
          if (Level > Maxlevels) Fault(105, 0);
          if (Kk >= 0 && Rlevel > 1) {
            Copytag(Kk);
            Jj = K;
            J = Midcell;
            if (J == 0 && Level > 2) Replace1(Tags[Kk], From1(Tags[Kk]) & 0xFFFF3FFF);
            while (J) {
              Pop(J, Insrn, At, W1);
              W3 = Ca - At;
              if ((unsigned)Insrn >> 25 == (unsigned)Call >> 1) W3 = W3 / 2;
              Insrn += W3;
              Plug(1, At, Insrn, 4);
            }
            Replace2(Tags[Kk], Ca);
          }
          if (Kk >= 0 && Rlevel == 1) {
            Diagpointer(Level);
            Psf1(Std, 1, 12);
          }
          if (Kk < 0)
            W3 = 0;
          else
            W3 = Word[Kk];
          L[Level] = Line;
          M[Level] = W3;
          Flag[Level] = Ptype;
        }
        void Rdisplay(int Kk) {
          int W1;
          int W2;
          int Stack;
          int Op;
          int Inc;
          if (Kk >= 0 || Level == 2) {
            Stack = 0;
            Display[Rlevel] = N;
            Gruse[Xnb] = 0;
            Gruse[Ctb] = 0;
            Gruse[Breg] = 0;
            if (Level != 2) {
              Gruse[Xnb] = 4;
              Grinf1[Xnb] = Rlevel - 1;
              Grat[Xnb] = Ca;
              Pf1(Ld, 0, Xnb, 12);
              Diagpointer(Level);
              Psf1(Std, 1, 12);
              W1 = Rlevel - 1;
              W2 = Display[W1];
              if (W1 == 1) {
                Pf1(Stxn, 0, Tos, 0);
                N += 4;
              } else
                while (W1 > 0) {
                  Op = Lss;
                  Inc = 1;
                  if (W1 >= 2) {
                    Op = Lsd;
                    Inc = 2;
                  }
                  if (W1 >= 4) {
                    Op = Lsq;
                    Inc = 4;
                  }
                  Pf1(Op + Stack, 0, Xnb, W2);
                  Stack = -32;
                  N += 4 * Inc;
                  W2 += 4 * Inc;
                  W1 -= Inc;
                }
            }
            if (Stack) Pf1(St, 0, Tos, 0);
            Pf1(Stln, 0, Tos, 0);
            N += 4;
          }
          if (Parmtrace) {
            if (Parmopt) Pf1(Lss, 0, Pc, 4 * Constbtm | 0x80000000);
            if (Kk >= 0 || Level == 2) {
              if (Parmopt) {
                Psf1(Slss, 0, Line);
                N += 4;
              } else
                Psf1(Lss, 0, Line);
              Pf1(St, 0, Tos, 0);
            } else {
              if (Parmopt) {
                Psf1(St, 1, N);
                N += 4;
              }
              Psf1(Lss, 0, Line);
              Psf1(St, 1, N);
              Psf1(Ld, 1, 12);
              Diagpointer(Level);
              Psf1(Std, 1, 12);
            }
            Diaginf[Level] = N;
            N += 4;
            Gruse[Accr] = 0;
          }
          if (Parmopt != 0 && Kk >= 0 && Level == 2) {
            Pf1(Stsf, 0, Breg, 0);
            Pf1(Stln, 0, Tos, 0);
            Pf1(Sbb, 0, Tos, 0);
            Psf1(Cpb, 0, N);
            Ppj(7, 13);
          }
          if (Kk >= 0 || Level == 2) {
            Set[Rlevel] = N << 18 | Ca;
            Nmax = N;
            Pf1(Asf + 12 * Parmchk, 0, 0, 0);
            if (Parmchk) Ppj(0, 4);
          }
          if (Kk >= 0 && Parmchk != 0) {
            Checkstof();
          }
          if (Parmdbug) Setline();
        }
        void Checkstof(void) {
          if (Parmopt) {
            Pf1(Stsf, 0, Tos, 0);
            Pf1(Lss, 0, Tos, 0);
            Psf1(Ush, 0, 14);
            Psf1(Ush, 0, -15);
            Pf1(Icp, 0, 0, (unsigned)Stlimit >> 1);
            Ppj(2, 8);
          }
        }
        void Ciocp(int N, int Reg) {
          int Xynb;
          int Op1;
          int Op2;
          if (!Iocpdisp) Cxref(Iocpep, Parmdynamic, 2, Iocpdisp);
          if (Register[Breg]) Bootout(Breg);
          if (!Reg) {
            Op1 = Luh;
            Op2 = St;
          } else {
            Op1 = Ldtb;
            Op2 = Std;
          }
          Psf1(Op1, 0, N);
          Psf1(Prcl, 0, 4);
          Pf1(Op2, 0, Tos, 0);
          Xynb = Setxorynb(-1, -1);
          Psf1(Raln, 0, 7);
          Pf1(Call, 2, Xynb, Iocpdisp);
          Forget(-1);
        }
        void Cui(int Code) {
          int Marker;
          int J;
          int Lname;
          int Typep;
          int Precp;
          int Gwrdd;
          int Lwb;
          int Xynb;
          int Arrp;
          int Alt;
          static int Sw_sw;
          static void *Sw[9 /*1:9*/] = {
              &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6, &&Sw_7, &&Sw_8, &&Sw_9,
          };
          Reportui = 0;
          Alt = A[P];
          goto *Sw[Sw_sw = (Alt)-1];
        Sw_1:;
          P++;
          Marker = P + Fromar2(P);
          if (A[Marker] == 1) {
            J = P + 2;
            P = Marker + 2;
            Assign(A[Marker + 1], J);
          } else {
            P += 2;
            Cname(0, 0);
            P++;
          }
        Aui:
          J = A[P];
          P++;
          if (J == 1) Cui(Code);
          return;
        Sw_2:;
          Nmdecs[Level] = Nmdecs[Level] | 1;
          if (!Code) Currinst = 1;
          Lname = Fromar2(P + 1);
          J = A[P + 3];
          P += 4;
          if (J == 2) {
            Enterjump(15, Lname, 0);
            Reportui = 1;
          } else {
            Copytag(Lname);
            Arrp = Arr;
            Gwrdd = Sndisp << 2;
            if (Oldi != Level || Type != 6) {
              Fault(4, Lname);
              P--;
              Skipapp();
              return;
            }
            Lwb = From2(K);
            Csexp(Breg, 0x51);
            if (Arrp == 1) Psf1(Sbb, 0, Lwb);
            Xynb = Setxorynb(-1, -1);
            Pf1(Junc, 3, Xynb, Gwrdd);
            Reportui = 1;
            Forget(-1);
          }
          return;
        Sw_3:;
          if ((Flag[Level] & 0x3FFF) != 0x1000) Fault(30, 0);
          P++;
        Ret:
          Rtexit();
          Reportui = 1;
          if (!Code) Currinst = 1;
          return;
        Sw_4:;
          Ptype = Flag[Level] & 0x3FFF;
          Unpack();
          if (Ptype > 0x1000 && A[P + 1] != 3) {
            if (A[P + 1] == 1 && Nam != 0 && A[P + 5] == 4 && A[P + 6] == 1) {
              P += 7;
              Typep = Type;
              Precp = Prec;
              Cname(4, Accr);
              if (A[P] != 2) Fault(81, 0);
              P++;
              if (Typep != Type || Precp != Prec) Fault(83, 0);
              goto Ret;
            }
            if (A[P + 1] == 2) {
              P += 2;
              if (Nam) Type = 1;
              if (Type == 5) {
                Cstrexp(0, Accr);
                Psf1(Ld, 1, Display[Rbase] - 8);
                Pf1(Iad, 0, Pc, Specialconsts(2));
                Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
                Psf1(Ldb, 2, Display[Rbase] - 8);
                Copydr();
              } else {
                if (Prec < 5) Prec = 5;
                if (!Nam)
                  Kk = Prec << 4 | Type;
                else
                  Kk = 0x51;
                Csexp(Accr, Kk);
              }
              goto Ret;
            }
          }
          Fault(31, 0);
          P += 2;
          Skipexp();
          return;
        Sw_5:;
          Psf1(Lsd, 0, 0);
          Ppj(0, 2);
          P++;
          goto Aui;
        Sw_6:;
          Ppj(0, 21);
          P++;
          if (!Code) Currinst = 1;
          Reportui = 1;
          return;
        Sw_7:;
          Psf1(Prcl, 0, 4);
          Psf1(Jlk, 0, 1);
          if (Nmdecs[Level] & 16)
            if (Flag[Level] <= 2) {
              Psf1(Ld, 1, 12);
              Diagpointer(Level - 1);
              Psf1(Std, 1, 12);
              Pf1(Stln, 0, Tos, 0);
            } else {
              Psf1(Lss, 1, 0);
              Pf1(St, 0, Tos, 0);
            }
          else
            Pf1(Stln, 0, Tos, 0);
          Gruse[Accr] = 0;
          J = A[P + 2];
          if (1 > J || J > 15) Fault2(26, J, 0);
          if (A[P + 3] == 1) {
            P += 4;
            Csexp(Accr, 0x51);
            Pf1(And, 0, 0, 255);
            Pf1(Or, 0, 0, 256 * J);
          } else
            Pf1(Lss, 0, 0, 256 * J);
          Psf1(Slss, 0, 0);
          Pf1(St, 0, Tos, 0);
          Xynb = Setxorynb(-1, -1);
          Psf1(Raln, 0, 9);
          Pf1(Call, 2, Xynb, 40);
          if (!Code) Currinst = 1;
          Reportui = 1;
          return;
        Sw_8:;
        Sw_9:;
          Alt = Alt & 7;
          if (!Exitlab) {
            Fault2(54 + Alt, 0, 0);
            return;
          }
          Kk = *Integer(Addr(Exitlab) + 4 * Alt);
          Enterjump(15, Kk, 0b10);
          Reportui = 1;
          if (!Code) Currinst = 1;
        }
        void Cifthen(int Markiu, int Markc, int Markui, int Marke, int Markr, int Skip) {
          int Altui;
          int Ccres;
          int Elres;
          int Thenlab;
          int Elselab;
          int Userlab;
          int Report;
          int Start;
          int Elsealt;
          int K;
          static const int Nullelse = 4;
          static int Esw_sw;
          static void *Esw[4 /*1:4*/] = {
              &&Esw_1,
              &&Esw_2,
              &&Esw_3,
              &&Esw_4,
          };
          if (Skip != Yes) Setline();
          Markiu = A[Markiu];
          Plabel--;
          Thenlab = Plabel;
          Start = 0;
          Elselab = 0;
          P = Markc;
          if (Markr > 0 && A[Markr] <= 2) Start = 1;
          if (Marke != 0 && Level < 2 && Start == 0) Fault(57, 0);
          Userlab = -1;
          if (Start)
            Altui = 0;
          else
            Altui = A[Markui];
          if (Altui == 2 && A[Markui + 3] == 2) Userlab = Fromar2(Markui + 1);
          if (8 <= Altui && Altui <= 9 && Exitlab != 0)
            if (Altui == 8)
              Userlab = Exitlab;
            else
              Userlab = Contlab;
          if (Skip == Yes) {
            if (Start) {
              P = Markr + 1;
              Cstart(2, 1);
              Marke = P;
            }
            Ccres = 1;
            goto Else;
          }
          if (Userlab >= 0) {
            Nmdecs[Level] = Nmdecs[Level] | 1;
            Ccres = Ccond(0, 3 - Markiu, Userlab);
            if (Ccres) Ccres = Ccres ^ 3;
            Thenlab = 0;
            Report = 1;
          } else {
            Ccres = Ccond(1, Markiu, Thenlab);
            if (Start) {
              if (!Ccres) {
                if (Level < 2) Fault(57, 0);
                Nmdecs[Level] = Nmdecs[Level] | 1;
              }
              P = Markr + 1;
              Cstart(Ccres, 1);
              if (A[P] <= 2) {
                Plabel--;
                Elselab = Plabel;
              }
              Marke = P;
              Report = Lastinst;
            } else if (Ccres != 2) {
              P = Markui;
              Cui(1);
              Report = Reportui;
            } else
              Report = 1;
          }
        Else:;
          if (!Marke)
            Elsealt = Nullelse;
          else
            Elsealt = A[Marke];
          if (Elsealt < Nullelse) {
            Plabel--;
            Elselab = Plabel;
          }
          P = Marke + 1;
          if (Report == 0 && 0 == Ccres && Elsealt < Nullelse) {
            Report = 1;
            Enterjump(15, Elselab, 0b10);
          }
          if (Thenlab > 0) Elres = Enterlab(Thenlab, 0b11 | Report << 2);
          goto *Esw[Esw_sw = (Elsealt)-1];
        Esw_1:;
          if (!Ccres) Nmdecs[Level] = Nmdecs[Level] | 1;
          Cstart(Ccres, 2);
          Report = Lastinst;
          goto Enterelselab;
        Esw_2:;
          Marke = 0;
          Markui = 0;
          Markr = P + 1 + Fromar2(P + 1);
          if (A[Markr] == 3) {
            Marke = Markr + 1 + Fromar2(Markr + 1);
            Markui = Markr + 3;
          }
          if (Ccres == 1 || Skip == Yes)
            K = Yes;
          else
            K = No;
          Cifthen(P, P + 3, Markui, Marke, Markr, K);
          goto Enterelselab;
        Esw_3:;
          if (Ccres != 1) {
            if (Start) Setline();
            if (!Thenlab)
              K = 0;
            else
              K = 2;
            Cui(K);
            Report = Reportui;
          }
        Enterelselab:;
          if (Elselab > 0) Elres = Enterlab(Elselab, 0b11 | Report << 2);
        Esw_4:;
        }
        void Cstart(int Ccres, int Code) {
          int Skipcode;
          int Finishar;
          int Oldnextp;
          int Oldline;
          Skipcode = No;
          if (1 <= Code && Code <= 2 && (Ccres | Code) == 3) Skipcode = Yes;
          Finishar = Fromar4(P);
          if (Finishar <= P) Abort();
          Oldline = Line;
          do {
            Oldnextp = Nextp;
            if (!Skipcode)
              Compileastmnt();
            else {
              Line = A[Nextp + 3] << 8 | A[Nextp + 4];
              Nextp = Nextp + (A[Nextp] << 16) + (A[Nextp + 1] << 8) + A[Nextp + 2];
            }
          } while (Oldnextp < Finishar);
          P = Finishar + 6;
          if (A[P] <= 2 && Code != 1) Fault2(45 + Code, Oldline, 0);
          if (Skipcode == Yes) Lastinst = 1;
        }
        void Ccycbody(int Ua, int Elab, int Clab) {
          int Finishar;
          int Oldline;
          int Savee;
          int Savec;
          Finishar = Fromar4(P);
          if (Finishar <= P) Abort();
          Oldline = Line;
          Savee = Exitlab;
          Savec = Contlab;
          Exitlab = Elab;
          Contlab = Clab;
          while (Nextp <= Finishar) Compileastmnt();
          Exitlab = Savee;
          Contlab = Savec;
          P = Finishar + 6;
          if (A[P] == 1 && Ua == 0) Fault2(12, Oldline, 0);
        }
        void Cloop(int Alt, int Markc, int Markui) {
          int L1;
          int L2;
          int L3;
          int Ccres;
          int Elres;
          int Forname;
          int Inittype;
          int Initval;
          int Steptype;
          int Stepval;
          int Finaltype;
          int Finalval;
          int Facc;
          int Fdisp;
          int Fbase;
          int Initp;
          int Repmask;
          int Usedebj;
          int Debto;
          auto void Forexp(int *Etype, int *Evalue, int Tt, int Reg);
          auto void Validatefor(void);
          static int Sw_sw;
          static void *Sw[7 /*0:6*/] = {
              &&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6,
          };
          P = Markc;
          Sflabel -= 2;
          L1 = Sflabel;
          L2 = L1 + 1;
          L3 = 0;
          if (0b1100001 & 1 << Alt) {
            L3 = Sflabel - 1;
            Sflabel = L3;
          }
          if (1 <= Alt && Alt <= 3) Setline();
          if (0b0110111 & 1 << Alt) Elres = Enterlab(L1, 0);
          goto *Sw[Sw_sw = Alt];
        Sw_0:;
          Ccycbody(1, L2, L3);
          Elres = Enterlab(L3, 0b011);
          if (A[P] == 1) {
            P++;
            Ccres = Ccond(0, 1, L1);
          } else
            Enterjump(15, L1, 0);
          Elres = Enterlab(L2, 0b011);
        Wayout:;
          Removelab(L1);
          Removelab(L2);
          if (L3 > 0) Removelab(L3);
          return;
        Sw_1:;
          Ccres = Ccond(0, 1, L2);
          P = Markui;
          Cui(1);
          Enterjump(15, L1, 0);
          Elres = Enterlab(L2, 0b111);
          goto Wayout;
        Sw_2:;
          P = Markui;
          Cui(1);
          P = Markc;
          Ccres = Ccond(0, 1, L1);
          goto Wayout;
        Sw_3:;
        Sw_6:;
          Forname = Fromar2(P);
          Initp = P + 2;
          P = Initp;
          Copytag(Forname);
          Fdisp = K;
          Fbase = I;
          Facc = 2 * Nam;
          if (Type != 1 || Prec != 5 || Rout != 0 || 0 != Arr) Fault2(91, 0, Forname);
          if (Fbase != Rbase) Warn(4, Forname);
          Skipexp();
          Forexp(Steptype, Stepval, 1, Accr);
          if (!Steptype) {
            if (!Stepval) Fault2(92, 0, 0);
          } else {
            if (Parmopt) Ppj(26, 11);
          }
          Forexp(Finaltype, Finalval, 1, Accr);
          P = Initp;
          Forexp(Inittype, Initval, 0, Breg);
          if (Parmopt) Validatefor();
          Usedebj = 0;
          if (Stepval == -1 && (Finaltype | Steptype) == 0 && Finalval == 1) {
            Usedebj = 1;
            if (!Inittype) Psf1(Lb, 0, Initval);
            if (Inittype != 0 || Initval < 1) Enterjump(32 + 13, L2, 0b10);
            Debto = Ca;
          } else {
            if (!(Inittype | Steptype))
              Psf1(Lb, 0, Initval - Stepval);
            else {
              if (!Inittype) Psf1(Lb, 0, Initval);
              Psf1(Sbb, Steptype, Stepval);
            }
            if (Steptype == 1) {
              Pf1(Lss, 0, Breg, 0);
              Psf1(Irsb, Finaltype, Finalval);
              Psf1(Idv, 1, Stepval);
              Gruse[Accr] = 0;
              Enterjump(37, L2, 0b10);
              Repmask = 7;
            } else
              Repmask = 8 | (2 << ((unsigned)Stepval >> 31));
            Elres = Enterlab(L1, 0);
            if (Steptype == 0 && Stepval == 1)
              Psf1(Cpib, Finaltype, Finalval);
            else {
              Psf1(Cpb, Finaltype, Finalval);
              Psf1(Adb, Steptype, Stepval);
            }
            Gruse[Breg] = 0;
            Enterjump(Repmask, L2, 0b10);
          }
          Base = Fbase;
          Area = -1;
          Psorlf1(Stb, Facc, Areacode(), Fdisp);
          Noteassment(Breg, 2, Forname);
          P = Markui;
          if (Alt == 3)
            Cui(0);
          else {
            Ccycbody(0, L2, L3);
            Elres = Enterlab(L3, 0b011);
          }
          Base = Fbase;
          Access = Facc;
          Area = -1;
          Disp = Fdisp;
          Nameop(2, Breg, 4, Forname);
          if (!Usedebj)
            Enterjump(15, L1, 0);
          else {
            Psf1(Debj, 0, (Debto - Ca) / 2);
            Gruse[Breg] = 0;
          }
          Elres = Enterlab(L2, 0b111 ^ (Usedebj << 2));
          goto Wayout;
        Sw_4:;
          Ccres = Ccond(0, 1, L2);
          Ccycbody(0, L2, L1);
          Enterjump(15, L1, 0);
          Elres = Enterlab(L2, 0b111);
          goto Wayout;
        Sw_5:;
          P = Markui;
          Ccycbody(0, L2, L3);
          P = Markc;
          Elres = Enterlab(L3, 0b011);
          Ccres = Ccond(0, 1, L1);
          Elres = Enterlab(L2, 0b011);
          goto Wayout;
          void Forexp(int *Etype, int *Evalue, int Totemp, int Usereg) {
            int Inp;
            int Val;
            int Op;
            Inp = P;
            P += 3;
            if (Intexp(Val) == 0 && Imod(Val) < 0x1FFFF) {
              *Evalue = Val;
              *Etype = 0;
              return;
            }
            P = Inp;
            Csexp(Usereg, 0x51);
            *Etype = 1;
            if (Totemp) {
              Getwsp(Val, 1);
              if (!Usereg)
                Op = St;
              else
                Op = Stb;
              Psf1(Op, 1, Val);
              *Evalue = Val;
            }
          }
          void Validatefor(void) {
            int I;
            if (!(Inittype | Steptype | Finaltype)) {
              J = Finalval - Initval;
              if ((J / Stepval) * Stepval != J) Fault2(93, 0, 0);
              return;
            }
            if (Steptype == 0 && Imod(Stepval) == 1) return;
            if (!Inittype)
              Psf1(Lss, 0, Initval);
            else
              Pf1(Lss, 0, Breg, 0);
            Psf1(Irsb, Finaltype, Finalval);
            Psf1(Imdv, Steptype, Stepval);
            Pf1(Lss, 0, Tos, 0);
            Gruse[Accr] = 0;
            Ppj(36, 11);
          }
        }
        void Assign(int Assop, int P1) {
          int Q;
          int Qq;
          int Kk;
          int Typep;
          int Precp;
          int Ptypep;
          int Jjj;
          int P2;
          int Jj;
          int Reg;
          int Stcode;
          int Rhtype;
          int Accp;
          int Ii;
          int Head1;
          int Nops;
          int Tpcell;
          int Lvl;
          int Bot1;
          int Lhname;
          int Rhname;
          Rd R;
          static int Sw_sw;
          static void *Sw[4 /*0:3*/] = {
              &&Sw_0,
              &&Sw_1,
              &&Sw_2,
              &&Sw_3,
          };
          P2 = P;
          if (Assop > 4) Rhtype = Type;
          Lhname = A[P1] << 8 | A[P1 + 1];
          P = P1;
          Reducetag();
          Ptypep = Ptype;
          Jj = J;
          Kk = K;
          Ii = I;
          Lvl = Oldi;
          Tpcell = Tcell;
          Accp = Acc;
          P = P2;
          Typep = Type;
          Precp = Prec;
          goto *Sw[Sw_sw = Assop & 3];
        Sw_2:
        Sw_3:;
          if (Type == 3) goto Recop;
          if (Type != 2 && Type != 5) Type = 1;
          if (Type == 5) goto String;
        Back:
          Head1 = 0;
          if (Type != 2) Type = 1;
          Typep = Type;
          Nops = (1 << 18) + 1;
          P = P2 + 3;
          Push(Head1, (Assop & 3) + 33, Precp, 0);
          Bot1 = Head1;
          Push(Head1, Ptypep << 16 | 2, P1, 0);
          if (Assop > 4) {
            if (Type != Rhtype) Fault(24, 0);
            Push(Head1, Rhtype << 16 | 9, 0, 0);
            Olink[Accr] = Head1;
          } else
            Torp(Head1, Bot1, Nops);
          Expop(Head1, -1, Nops, 256 + (Precp << 4) + Typep);
          Aslist[Bot1].Link = Asl;
          Asl = Head1;
          return;
        String:;
          if (A[P + 3] == 4 && A[P + 4] == 2 && A[P + 5] == 0x35 && A[P + 10] == 0 && A[P + 11] == 2) {
            Q = P + 12 - ((unsigned)A[P + 10] >> 1);
            P = P1;
            Cname(1, Dr);
            Pf2(Mvl, 0, 1, 0, 0, 0);
            P = Q;
            return;
          }
          if (Assop <= 3) Cstrexp(0, Accr);
          Assop = Assop & 3;
          Qq = Stringl;
          Q = P;
          Register[Accr] = 1;
          Olink[Accr] = Addr(R);
          R.Ptype = 0x51;
          R.Flag = 9;
          R.Uptype = 0;
          R.Xb = Accr;
          P = P1;
          Cname(1, Dr);
          if (R.Flag != 9) Pf1(Lsd, 0, Tos, 0);
          Pf1(Iad, 0, Pc, Specialconsts(2));
          if (Assop != 3 && (Rout != 0 || Nam != 0 && 0 == Arr) && Qq == 0) {
            if (Parmopt)
              Ppj(0, 18);
            else {
              Pf1(Stuh, 0, Breg, 0);
              Pf1(Luh, 0, Breg, 0);
              Pf1(Ldb, 0, Breg, 0);
            }
            Gruse[Breg] = 0;
          }
          Gruse[Accr] = 0;
          Register[Accr] = 0;
          if (Qq > 0 && Assop != 3)
            Pf2(Mv, 0, 0, Qq, 0, 0);
          else {
            if (Assop == 3) Pf1(Std, 0, Tos, 0);
            Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
            if (Parmarr != 0 || Assop == 3) {
              Psf1(Ush, 0, 8);
              Psf1(Ush, 0, -40);
            }
            if (Parmarr != 0 && Assop == 2) Ppj(36, 9);
            if (Assop == 3) {
              Pf1(Irsb, 2, Tos, 0);
              Pf1(St, 2, 7, 0);
            }
          }
          P = Q;
          return;
        Recop:;
          Reg = Accr;
          Q = Tsexp(Jjj);
          if (Q == 1 && Jjj == 0) {
            P = P1;
            Cname(3, Dr);
            if (Acc <= 128) {
              Jj = 0;
              Kk = Acc - 1;
            } else {
              Jj = 1;
              Kk = 0;
              if (Nam != 0 || Arr != 0) Psf1(Ldb, 0, Acc);
            }
            Pf2(Mvl, Jj, 1, Kk, 0, 0);
          } else {
            if (Type != 3 || A[P2 + 3] != 4 || A[P2 + 4] != 1) goto Back;
            P = P2 + 5;
            Cname(3, Accr);
            Accp = Acc;
            if (A[P] != 2) {
              Fault2(66, 0, Lhname);
              goto F00;
            }
            R.Ptype = 0x61;
            R.Flag = 9;
            R.Xb = Accr << 5;
            R.D = 0;
            Olink[Accr] = Addr(R);
            Register[Accr] = 1;
            P = P1;
            Cname(3, Dr);
            Register[Accr] = 0;
            if (R.Flag != 9) Pf1(Lsd, 0, Tos, 0);
            if (Assop == 2 && Accp != Acc) {
              Fault2(67, Lhname, Fromar2(P2 + 5));
              goto F00;
            }
            if (Accp > Acc) Accp = Acc;
            do {
              if (Accp > 128)
                Kk = 128;
              else
                Kk = Accp;
              Pf2(Mv, 0, 0, Kk - 1, 0, 0);
              Accp -= Kk;
            } while (Accp);
            Gruse[Accr] = 0;
          }
          P = P2;
          Skipexp();
          Gruse[Dr] = 0;
          return;
        Sw_0:;
          P = P1;
          Cname(2, Dr);
          P = P2;
          if (Type == 5)
            Cres(0);
          else {
            Skipexp();
            if (Type != 7) Fault2(71, 0, Fromar2(P1));
          }
          return;
        Sw_1:;
          Reg = Accr;
          Stcode = St;
          if (A[P2 + 3] != 4 || A[P2 + 4] != 1) goto F81;
          if (Nam != 1) {
            Fault2(82, 0, Lhname);
            goto F00;
          }
          P = P2 + 5;
          Rhname = A[P] << 8 | A[P + 1];
          if (Arr == 1) goto Arrname;
          if (A[P1 + 2] == 2 && 2 == A[P1 + 3]) {
            Copytag(Rhname);
            if (Ptype != Snpt && Arr != 0) {
              Reg = Dr;
              Stcode = Std;
            }
          }
          Cname(3, Reg);
          R.Ptype = 0x61;
          R.Flag = 9;
          R.Xb = Reg;
          Olink[Reg] = Addr(R);
          Register[Reg] = 1;
          if (A[P] != 2) goto F81;
          Q = P + 1;
          P = P1;
          if (Type != Typep || Prec != Precp) goto F83;
          if (Oldi > Lvl && Base != 0 && Nam == 0) goto F86;
          Cname(6, 0);
          if (R.Flag != 9) {
            if (Reg) Abort();
            Pf1(Lsd, 0, Tos, 0);
            Gruse[Accr] = 0;
          }
          Register[Reg] = 0;
        Com:
          Psorlf1(Stcode, Access, Areacode(), Disp);
          if (Reg == Dr && Access != 0) Abort();
          Noteassment(Reg, 1, A[P1] << 8 | A[P1 + 1]);
          P = Q;
          return;
        Arrname:
          Cname(12, Accr);
          if (Access >= 8)
            Access -= 4;
          else
            Access = 0;
          if (Type != Typep || Prec != Precp || Arr <= 0) goto F83;
          if (Oldi > Lvl && Base != 0 && Nam == 0) goto F86;
          Type = 0;
          Nameop(2, Accr, 16, -1);
          R.Ptype = 0x72;
          R.Uptype = 0;
          R.Flag = 9;
          R.Xb = Accr;
          R.D = -1;
          Register[Accr] = 1;
          Olink[Accr] = Addr(R);
          if (A[P] != 2) goto F81;
          Q = P + 1;
          P = P1;
          Cname(6, 0);
          if (R.Flag != 9) Pf1(Lsq, 0, Tos, 0);
          Register[Accr] = 0;
          goto Com;
        F83:
          Fault2(83, Lhname, Rhname);
          goto F00;
        F86:
          Fault2(86, Lhname, Rhname);
          goto F00;
        F81:
          Fault2(81, 0, Lhname);
        F00:;
          Register[Reg] = 0;
          P = P2;
          Skipexp();
        }
        void Csexp(int Reg, int Mode) {
          int Exphead;
          int Nops;
          int Expbot;
          Exphead = 0;
          Expbot = 0;
          Nops = 0;
          P += 3;
          Torp(Exphead, Expbot, Nops);
          Expop(Exphead, Reg, Nops, Mode);
          Aslist[Expbot].Link = Asl;
          Asl = Exphead;
        }
        int Constexp(int Prectype) {
          int Exphead;
          int Expbot;
          int Nops;
          int Res;
          Exphead = 0;
          Expbot = 0;
          Nops = 0;
          Res = 0;
          Torp(Exphead, Expbot, Nops);
          if (Nops & 0x00040000) goto Wayout;
          Expop(Exphead, Accr, Nops, 0x200 + Prectype);
          if (Expopnd.Flag == 3) {
            Res = Expopnd.Xtra;
            goto Wayout;
          }
          if (Expopnd.Flag > 1) goto Wayout;
          Res = Addr(Expopnd.D);
        Wayout:;
          if (Res == 0 && Dcomp != 0) _imp_monitor();
          Aslist[Expbot].Link = Asl;
          Asl = Exphead;
          return (Res);
        }
        int Intexp(int *Value) {
          int Exphead;
          int Expbot;
          int Nops;
          int Code;
          int Sptype;
          int Sacc;
          Exphead = 0;
          Expbot = 0;
          Nops = 0;
          Code = 0;
          Sptype = Ptype;
          Sacc = Acc;
          Torp(Exphead, Expbot, Nops);
          if ((Nops & 0x00040000) == 0 && Type == 1) {
            Expop(Exphead, Accr, Nops, 0x251);
            if (Expopnd.Flag > 1 || Expopnd.Ptype != 0x51) Code = 1;
            *Value = Expopnd.D;
          } else {
            Code = 1;
            *Value = 1;
          }
          Aslist[Expbot].Link = Asl;
          Asl = Exphead;
          Acc = Sacc;
          Ptype = Sptype;
          Unpack();
          return (Code);
        }
        void Torp(int *Head, int *Bot, int *Nops) {
          static int Operand_sw;
          static void *Operand[3 /*1:3*/] = {
              &&Operand_1,
              &&Operand_2,
              &&Operand_3,
          };
          static const unsigned char Precedence[15 /*1:15*/] = {3, 3, 4, 5, 5, 4, 3, 3, 4, 4, 5, 5, 3, 5, 5};
          static const unsigned char Opval[15 /*1:15*/] = {20, 21, 27, 37, 30, 24, 22, 23, 25, 26, 28, 29, 20, 37, 30};
          int Rphead;
          int Passhead;
          int Savehead;
          int Real;
          int Realop;
          int Complex;
          int Operator;
          int Opprec;
          int Opnd;
          int C;
          int D;
          int E;
          int Rptype;
          int Rpinf;
          int Bdisp;
          int Opname;
          int Opmask;
          int Xtra;
          int Rpbot;
          int Opstk;
          int Oppstk;
          int Passbot;
          Listf *Lcell;
          Passhead = 0;
          Rphead = 0;
          Savehead = 0;
          Real = 0;
          Realop = 0;
          Bdisp = 0;
          Rpbot = 0;
          Opstk = 0;
          Oppstk = 0;
          C = A[P];
          if (2 <= C && C <= 3) {
            *Nops = *Nops + 1;
            Opstk = 4 - C;
            Oppstk = (C << 1) - 1;
            Opmask = 1 << (19 + C);
          } else
            Opmask = 0;
        Nextopnd:
          Opnd = A[P + 1];
          P += 2;
          Complex = 0;
          Xtra = 0;
          goto *Operand[Operand_sw = (Opnd)-1];
        Operand_1:;
          Opname = (A[P] << 8) + A[P + 1];
          Lcell = &Aslist[Tags[Opname]];
          Ptype = (unsigned)Lcell->S1 >> 16;
          if (Ptype == 0xFFFF) Ptype = 7;
          Type = Ptype & 7;
          Prec = (unsigned)Ptype >> 4 & 15;
          if (Ptype == Snpt) {
            D = (unsigned)Lcell->S3 >> 16;
            if (D == 38 && A[P + 2] == 2) {
              Rptype = 0;
              Rpinf = 10;
              Ptype = 0x51;
              P += 2;
              goto Sknam;
            }
            if (D == 52 && A[P + 2] == 2) {
              Rptype = 1;
              Ptype = 0x62;
              Rpinf = 0x413243F6;
              Xtra = 0xA8885A31;
              P += 2;
              Real = 1;
              goto Sknam;
            }
            Complex = 1;
            Ptype = Tsname[D];
            Unpack();
          }
          if ((Ptype & 0xFF00) == 0x4000 && A[P + 2] == 2 && 2 == A[P + 3] && 1 <= Type && Type <= 2) {
            Lcell->S1 = Lcell->S1 | 0x8000;
            Rpinf = Lcell->S2;
            Xtra = Lcell->S3;
            Rptype = 1;
            Ptype = Ptype & 255;
            if (Type == 1 && Prec <= 5 && 0xFFFE0000 <= Rpinf && Rpinf <= 0x1FFFF) {
              Rptype = 0;
              Ptype = 0x51;
            }
            if (Prec == 7) Rptype = 3;
            if (Type == 2) Real = 1;
            P += 2;
            goto Sknam;
          }
          Xtra = Opname;
          if ((Ptype & 0x3F00) != 0 || Parmchk == 1 || Prec < 5) {
            Complex = 1;
            Xtra = -1;
          }
          Opmask = Opmask | (Complex << 19);
          if (A[P + 2] != 2 || A[P + 3] != 2) Xtra = -1;
          if (Type == 3) {
            D = P;
            Kform = Lcell->S3 & 0xFFFF;
            C = Copyrecordtag(E);
            P = D;
            if (E != 1 || 1 > Type || Type > 2 || Nam != Arr || Arr != 0 || Prec == 3) Complex = 1;
          }
          if (Prec >= 6) Opmask = Opmask | 1 << 17;
          Rptype = 2;
          Rpinf = P;
          if (Ptype == 7) Ptype = 0x51;
          if (Type == 5) {
            Fault2(76, 0, Opname);
            Rptype = 0;
            Ptype = 0x51;
          }
          if (Type == 2) Real = 1;
          P += 2;
        Sknam:
          if (A[P] == 2)
            P++;
          else
            Skipapp();
          if (A[P] == 1) {
            P += 3;
            goto Sknam;
          }
          P += 2;
        Ins:
          if (Rptype == 2) Opmask = Opmask | 1 << 18;
          Binsert(Rphead, Rpbot, Ptype << 16 | Complex << 8 | Rptype, Rpinf, Xtra);
          goto Op;
        Operand_2:;
          Ptype = A[P];
          D = (unsigned)Ptype >> 4;
          C = Ptype & 7;
          if (D == 4) {
            Rpinf = Fromar2(P + 1);
            Ptype = 0x51;
          } else
            Rpinf = Fromar4(P + 1);
          if (C == 2) Real = 1;
          Rptype = 1;
          if (D == 6) Xtra = Fromar4(P + 5);
          if (C == 5) {
            Fault2(77, 0, 0);
            Rpinf = 1;
            Rptype = 0;
            P = P + A[P + 5] + 7;
            Ptype = 0x51;
          } else {
            if (D == 7) {
              Xtra = Addr(A[P + 1]);
              Rptype = 3;
            }
            if (Ptype == 0x51 && 0xFFFE0000 <= Rpinf && Rpinf <= 0x1FFFF) Rptype = 0;
            P = P + 2 + Bytes[D];
          }
          goto Ins;
        Operand_3:;
          Passhead = 0;
          Passbot = 0;
          P += 3;
          Torp(Passhead, Passbot, *Nops);
          if (Type == 2) Real = 1;
          if (!Rpbot)
            Rphead = Passhead;
          else
            Aslist[Rpbot].Link = Passhead;
          Rpbot = Passbot;
          P++;
        Op:;
          if (A[P - 1] == 2) goto Eoe;
          Operator = A[P];
          if (Operator == Concop) Fault2(78, 0, 0);
          Opprec = Precedence[Operator];
          Operator = Opval[Operator];
          if (Operator == 26 || Operator == 30) Real = 1;
          *Nops = *Nops + 1;
          while (Opprec <= (Oppstk & 31)) {
            Binsert(Rphead, Rpbot, (Opstk & 31) + 9, 0, 0);
            Opstk = (unsigned)Opstk >> 5;
            Oppstk = (unsigned)Oppstk >> 5;
          }
          Opstk = Opstk << 5 | (Operator - 9);
          Oppstk = Oppstk << 5 | Opprec;
          if (Operator >= 31) Operator = 30;
          Opmask = Opmask | (1 << Operator);
          goto Nextopnd;
        Eoe:;
          while (Opstk) {
            Binsert(Rphead, Rpbot, (Opstk & 31) + 9, 0, 0);
            Opstk = (unsigned)Opstk >> 5;
          }
          Ptype = Real + 1;
          Type = Ptype;
          if (!*Head)
            *Bot = Rpbot;
          else
            Aslist[Rpbot].Link = *Head;
          *Head = Rphead;
          *Nops = *Nops | Opmask;
        }
        void Expop(int Inhead, int Reg, int Nops, int Mode) {
          auto void Ctop(int *A);
          auto void Vmy(void);
          auto void Vmy1(void);
          auto void Choose(int *I);
          auto void Put(void);
          auto void Starstar(void);
          auto void Rexp(void);
          auto void Load(Rd * Op, int Reg, int Mode);
          auto void Float(Rd * Opnd, int Otherptype);
          auto void Coercet(Rd * Op1, Rd * Op2, int Mode);
          auto void Coercep(Rd * Op1, Rd * Op2);
          auto void Lengthen(Rd * Op);
          auto void Shorten(Rd * Op);
          int Operand[2 /*1:2*/];
          int Stk[100 /*0:99*/];
          Listf *List;
          Rd *Opnd1;
          Rd *Opnd2;
          Rd *Opnd;
          int C;
          int D;
          int Kk;
          int Jj;
          int Opcode;
          int Comm;
          int Xtra;
          int Pp;
          int Pt;
          int Jjj;
          int Loadreg;
          int Evalreg;
          int Stptr;
          int Constform;
          int Condform;
          int Savep;
          static const int Mcinst[28 /*10:37*/] = {
              0x8E8E,        0xF4F4E4E4,           0xA8A8,     0xF4F4E4E4,
              [4 ... 9] = 0, 0xF0F0E0E0,           0xF2F4E2E4, 0x8E8E,
              0x8C8C,        0xFAFAEAEA,           0xAAAC,     0xBABC0000,
              0x8A8A,        [18 ... 19] = 0xC800, 0xFA000000, 0xF6F6E6E6,
              0x00F600E6,    0x2C002C00,           0x02000200, [25 ... 26] = 0x48004800,
              0xEA00};
          static const unsigned char Corules[18 /*20:37*/] = {
              [0 ... 1] = 0x1F,   [2 ... 3] = 0x11, 0x1F, 0x11, 0x12, 0x11, 1, 1, 0,
              [11 ... 12] = 0x1F, [13 ... 16] = 0,  1};
          static const unsigned char Fcomp[28 /*1:28*/] = {8,  10, 2,  7,  12, 4,  7,  8,  12, 4,  7,  10, 2,  7,
                                                           16, 34, 17, 32, 33, 18, 32, 16, 33, 18, 32, 34, 17, 32};
          static int Sw_sw;
          static void *Sw[28 /*10:37*/] = {
              &&Sw_10,      &&Sw_11,      &&Sw_12,      &&Sw_13, &&Sw_14, &&Sw_default, &&Sw_default,
              &&Sw_default, &&Sw_default, &&Sw_default, &&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,
          };
          Stptr = 0;
          Constform = Mode & 512;
          Condform = Mode & 256;
          Savep = P;
          Evalreg = Accr;
          if (Reg == Breg && (Nops & 0x7EC20000) == 0) Evalreg = Breg;
        Next:
          List = &Aslist[Inhead];
          C = List->S1;
          Xtra = List->S2;
          Jj = C & 255;
          D = Inhead;
          Inhead = List->Link;
          if (Jj >= 10) goto Operator;
          Operand[1] = Addr(Aslist[D]);
          Opnd1 = Record(Addr(Aslist[D]));
          if (Opnd1->Flag == 2 && Opnd1->Xb != 0) Load(*Opnd1, Evalreg, 0);
          Stk[Stptr] = Operand[1];
          Stptr++;
          if (Stptr > 99) Abort();
        Anymore:;
          if (Inhead != 0 && Mode != 100) goto Next;
          goto Finish;
        Operator:;
          if (Jj < 19)
            Kk = 1;
          else
            Kk = 2;
          for (Kk = Kk; Kk >= 1; Kk--) {
            Stptr--;
            C = Stk[Stptr];
            Operand[Kk] = C;
          }
          Opcode = Mcinst[Jj];
          Comm = 1;
          Opnd1 = Record(Operand[1]);
          Opnd2 = Opnd1;
          if (Jj >= 19) {
            Opnd2 = Record(Operand[2]);
            C = Corules[Jj];
            if (C & 15) Coercet(*Opnd1, *Opnd2, C & 15);
            if ((unsigned)C >> 4) Coercep(*Opnd1, *Opnd2);
          }
          if (Jj > 19) {
            Choose(Comm);
            Opnd1 = Record(Operand[Comm]);
            Opnd2 = Record(Operand[3 - Comm]);
          }
          Ptype = Opnd1->Ptype;
          Type = Ptype & 7;
          if (Type == 1)
            Opcode = Opcode & 0xFFFF;
          else
            Opcode = (unsigned)Opcode >> 16;
          if (2 != Opnd1->Flag && Opnd1->Flag < 4 && 2 != Opnd2->Flag && Opnd2->Flag < 4) Ctop(Jj);
          if (!Jj) goto Stres;
          goto *Sw[Sw_sw = (Jj)-10];
        Sw_10:;
          Load(*Opnd1, Evalreg, 2);
          if (Type != 1 && Type != 7) Fault(24, 0);
          Psf1(Opcode & 255, 0, -1);
          Gruse[Evalreg] = 0;
        Suse:
          Olink[Evalreg] = Operand[Comm];
        Stres:
          Stk[Stptr] = Operand[Comm];
          Stptr++;
          goto Anymore;
        Sw_11:;
          Load(*Opnd1, Evalreg, 2);
          if (Evalreg == Breg) {
            Psf1(Slb, 0, 0);
            Pf1(Sbb, 0, Tos, 0);
          } else
            Psf1(Opcode & 255, 0, 0);
          Gruse[Evalreg] = 0;
          goto Suse;
        Sw_12:;
          Abort();
        Sw_13:;
          Load(*Opnd1, Evalreg, 2);
          if (Type == 2)
            C = 2;
          else
            C = 6;
          Pf3(Jaf, C, 0, 3);
          Psf1(Opcode & 255, 0, 0);
          Gruse[Evalreg] = 0;
          goto Suse;
        Sw_14:;
          Abort();
        Sw_20:;
          if (Type == 1 && Gruse[Evalreg] == 10 && Opnd1->Flag == 2 && Opnd2->Flag == 0 && Register[Evalreg] == 0) {
            P = Opnd1->D;
            D = Grinf1[Evalreg];
            if (Fromar2(P) == (D & 0xFFFF) && A[P + 2] == 2 && 2 == A[P + 3]) {
              if (!Evalreg)
                C = Iad;
              else
                C = Adb;
              Psf1(C, 0, Opnd2->D - ((unsigned)D >> 16));
              Grinf1[Evalreg] = D & 0xFFFF | Opnd2->D << 16;
              Register[Evalreg] = 1;
              Opnd1->Flag = 9;
              Opnd1->Xb = Evalreg << 4;
              Opnd1->D = 0;
              goto Suse;
            }
          }
        Binop:
          Load(*Opnd1, Evalreg, 2);
          Load(*Opnd2, Evalreg, 1);
          Put();
          goto Suse;
        Sw_21:;
          goto Binop;
        Sw_22:;
        Sw_23:;
        Sw_27:;
          if (Type == 1) goto Binop;
        F24:
          if (Type != 7) Fault(24, 0);
          Jj = 20;
          Opcode = Mcinst[20];
          goto Binop;
        Sw_28:;
          if (!Opnd2->Flag)
            Opnd2->D = -Opnd2->D;
          else {
            Load(*Opnd2, Evalreg, 2);
            Psf1(Irsb, 0, 0);
            Gruse[Evalreg] = 0;
          }
        Sw_29:;
          if ((unsigned)Opnd2->Ptype >> 4 == 6) Shorten(*Opnd2);
          goto Binop;
        Sw_24:;
          goto Binop;
        Sw_25:;
          if (Type != 1) goto F24;
          goto Binop;
        Sw_26:;
          goto Binop;
        Sw_30:;
          if ((Opnd1->Ptype & 7) == 1) Float(*Opnd1, 0);
          if ((Opnd2->Ptype & 7) == 1) {
            Starstar();
            goto Suse;
          }
          Rexp();
          Comm = 2;
          goto Suse;
        Sw_37:;
          Starstar();
          goto Suse;
        Sw_31:;
        Sw_32:;
          Ptype = Opnd1->Ptype;
          if (Opnd1->Flag <= 1 && Opnd1->D == 0 && Jj == 31 && (Opnd1->Xtra == 0 || (unsigned)Ptype >> 4 == 5)) goto Z1;
          if (Opnd2->Flag <= 1 && Opnd2->D == 0 && (Opnd2->Xtra == 0 || (unsigned)Opnd2->Ptype >> 4 == 5)) goto Z2;
          Load(*Opnd1, Evalreg, 2);
          Load(*Opnd2, Evalreg, 1);
          Put();
          Register[Evalreg] = 0;
          Bfflag = Comm - 1;
          Mask = Fcomp[Xtra + 7 * Bfflag];
          Comm = 2;
          goto Stres;
        Z1:
          Comm -= 3;
        Z2:
          Opnd = Record(Operand[Comm]);
          C = Evalreg;
          D = Evalreg ^ 7;
          if (Opnd->Flag == 2 && Gruse[D] == 9 &&
              ((Grinf1[D] & 0xFFFF) == Opnd->Xtra || (unsigned)Grinf1[D] >> 16 == Opnd->Xtra))
            C = D;
          Load(*Opnd, C, 2);
          Register[C] = 0;
          Mask = Fcomp[Xtra + 7 * Comm + 7];
          if (Type == 1) Mask += 4;
          if (C == Breg) Mask += 8;
          Comm = 2;
          goto Stres;
        Sw_33:;
          C = (unsigned)Opnd2->D >> 24;
          D = (unsigned)Opnd2->D >> 16 & 31;
          if (D == 1)
            Vmy1();
          else
            Vmy();
          if (Opnd1->Flag > 1) Olink[Loadreg] = Operand[Comm];
          if (C == 1) goto Stres;
          goto Anymore;
        Sw_34:;
          Abort();
        Sw_35:;
        Sw_36:;
          Pt = Opnd2->Ptype;
          Pp = Opnd2->D;
          if ((Pt & 7) == 1 && (Opnd1->Ptype & 7) == 2) Fault(24, 0);
          if ((Pt & 7) == 2 && (Opnd1->Ptype & 7) == 1) Float(*Opnd1, Opnd2->Ptype);
          Load(*Opnd1, Evalreg, 2);
          Register[Evalreg] = 2;
          C = (unsigned)Pt >> 4;
          D = (unsigned)Opnd1->Ptype >> 4;
          if (C < 5) C = 5;
          if (D < 5) D = 5;
          while (D < C) {
            Lengthen(*Opnd1);
            D = (unsigned)Opnd1->Ptype >> 4;
          }
          while ((C < D && Type == 1 && Jj != 36) || C < D - 1) {
            Shorten(*Opnd1);
            D = (unsigned)Opnd1->Ptype >> 4;
          }
          P = Pp;
          Cname(1, 0);
          D = Disp;
          C = Access;
          Jjj = Area;
          Kk = Prec;
          Load(*Opnd1, Evalreg, 2);
          if (Jj == 36 && Type == 1) {
            if (3 <= Xtra && Xtra <= 4) {
              Pf1(And, 0, 0, (unsigned)(-1) >> (8 * (6 - Xtra)));
              Gruse[Accr] = 0;
            }
            if (Kk <= 5 && Prec == 6) {
              Psf1(Mpsr, 0, 17);
              Gruse[Accr] = 0;
            }
          }
          if (Type == 2 && Kk < Prec)
            Kk = Stuh;
          else
            Kk = St;
          if (Evalreg == Breg) Kk = Stb;
          Psorlf1(Kk, C, Jjj, D);
          if (((C & 1) == 0 && Stname > 0) || (C == 3 && (unsigned)Stname >> 16 > 0))
            Noteassment(Evalreg, Jj - 33, Stname);
          if (C >= 2 && Jjj != 7)
            if (Stname > 0) {
              Gruse[Dr] = 7;
              Grinf1[Dr] = Stname & 0xFFFF;
            } else
              Gruse[Dr] = 0;
          if (Kk == Stuh) Gruse[Accr] = 0;
          Comm = 1;
          goto Stres;
        Finish:
          C = Stk[Stptr - 1];
          Operand[1] = C;
          Opnd1 = Record(C);
          if (((unsigned)Opnd1->Ptype >> 4 & 15) < 5) Opnd1->Ptype = Opnd1->Ptype & 0xF | 0x50;
          if (!Condform) {
            D = (unsigned)Mode >> 4 & 7;
            if (D < 5) D = 5;
            if ((Mode & 7) == 2 && (Opnd1->Ptype & 7) == 1) Float(*Opnd1, D << 4);
            while (D<(unsigned)Opnd1->Ptype>> 4) Shorten(*Opnd1);
            while (D > (unsigned)Opnd1->Ptype >> 4) Lengthen(*Opnd1);
            if (Constform == 0 || 2 <= Opnd1->Flag && Opnd1->Flag != 3) Load(*Opnd1, Reg, 2);
          }
          Expopnd = *Opnd1;
          Ptype = Opnd1->Ptype;
          Type = Ptype & 7;
          Prec = (unsigned)Ptype >> 4;
          if (Type == 2 && (Mode & 7) == 1) Fault(24, 0);
          if (Opnd1->Flag == 9) Register[(unsigned)Opnd1->Xb >> 4] = 0;
          P = Savep;
          return;
          void Choose(int *Choice) {
            Rd *Opnd1;
            Rd *Opnd2;
            Opnd1 = Record(Operand[1]);
            Opnd2 = Record(Operand[2]);
            *Choice = 1;
            if (Jj == 21 && Evalreg == Breg) return;
            if ((Opcode & 0xFF00FF00) == 0 ||
                ((Opcode & 0xFF00FF) != 0 && (Opnd2->Flag == 9 || (Opnd2->Flag == 2 && Gruse[Evalreg] == 9 &&
                                                                   Grinf1[Evalreg] == Opnd2->Xtra && Opnd2->Xtra > 0))))
              *Choice = 2;
          }
          void Load(Rd * Opnd, int Reg, int Mode) {
            int K;
            int Kk;
            static int Sw_sw;
            static void *Sw[10 /*0:9*/] = {
                &&Sw_0, &&Sw_1, &&Sw_2, &&Sw_3, &&Sw_4, &&Sw_5, &&Sw_6, &&Sw_7, &&Sw_8, &&Sw_9,
            };
            K = Opnd.Flag;
            if (Mode != 2 && K != 2 && (K > 3 || Mode != 1)) return;
            Ptype = Opnd.Ptype;
            Type = Ptype & 15;
            Prec = (unsigned)Ptype >> 4;
            if (K < 0 || K > 9) Abort();
            goto *Sw[Sw_sw = K];
          Sw_0:
          Litconst:;
            Area = 0;
            Access = 0;
            if (Prec <= 5)
              Disp = Opnd.D;
            else {
              Disp = Opnd.Xtra;
              if ((Disp < 0 || Opnd.D != 0) && (Disp >= 0 || Opnd.D != -1)) Abort();
            }
            if (Mode == 2) {
              if ((Gruse[Reg] & 255) == 5 && 5 == Prec && Grinf1[Reg] == Disp) {
                if (Register[Reg]) Bootout(Reg);
              } else
                Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
              if (Prec <= 5) {
                Gruse[Reg] = 5;
                Grinf1[Reg] = Disp;
              }
              goto Lded;
            }
            if (Prec == 3) Opnd.Ptype = 0x51;
            Opnd.Flag = 7;
            Opnd.Xb = Area << 4 | Access;
            Opnd.D = Disp;
            return;
          Sw_1:;
            if (Opnd.D == 0 && 0 == Opnd.Xtra && Prec <= 6) goto Litconst;
          Sw_3:;
            if (Prec == 7)
              Kk = Opnd.Xtra;
            else
              Kk = Addr(Opnd.D);
            Storeconst(Disp, Bytes[Prec], Kk);
            if (Mode != 2) {
              Opnd.Flag = 7;
              Opnd.Xb = Pc << 4;
              Opnd.D = Disp;
              return;
            }
            if ((Gruse[Reg] & 255) == 6 && Grinf1[Reg] == Disp) {
              if (Register[Reg]) Bootout(Reg);
            } else
              Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, 0, Pc, Disp);
            Gruse[Reg] = 6;
            Grinf1[Reg] = Disp;
            goto Lded;
          Sw_2:;
            P = Opnd.D;
            if (Mode == 2 || Opnd.Xb != 0) goto Load;
            Cname(5, Reg);
            if (Nest >= 0) goto Lded;
            Area = -1;
            Area = Areacode();
            Opnd.Ptype = Ptype;
            Opnd.Flag = 7;
            Opnd.Xb = Area << 4 | Access;
            Opnd.D = Disp;
            return;
          Load:
            Cname(2, Reg);
          Lded:
            Register[Reg] = 1;
            Olink[Reg] = Addr(*Opnd);
            if (Prec < 5) Opnd.Ptype = Opnd.Ptype & 15 | 0x50;
            Opnd.Flag = 9;
            Opnd.D = 0;
            Opnd.Xb = Reg << 4;
            if (Reg == Breg && (Register[Accr] & 1) != 0) Register[Breg] = 2;
            return;
          Sw_4:;
          Sw_5:;
          Sw_6:;
            Abort();
          Sw_7:;
            Area = (unsigned)Opnd.Xb >> 4;
            Access = Opnd.Xb & 15;
            Disp = Opnd.D;
          Pickup:
            Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
            goto Lded;
          Sw_8:;
            Area = Tos;
            Access = 0;
            Disp = 0;
            goto Pickup;
          Sw_9:;
            if ((unsigned)Opnd.Xb >> 4 == Reg) goto Lded;
            if (Reg) {
              if (Register[Breg]) Bootout(Breg);
              Pf1(St, 0, Breg, 0);
            } else
              Getinacc(Accr, 1, 0, Breg, 0);
            Register[(unsigned)Opnd.Xb >> 4] = 0;
            Opnd.Xb = Reg << 4;
            Gruse[Reg] = 0;
            Register[Reg] = 1;
            Olink[Reg] = Addr(*Opnd);
          }
          void Put(void) {
            int Code;
            int Ocode;
            Code = Opcode;
            if (Comm == 1) Code = (unsigned)Code >> 8;
            Code = Code & 255;
            Ocode = Code;
            if (Evalreg == Breg) Code -= 0xC0;
            if (Opnd1->Flag != 9) Abort();
            Psorlf1(Code, Opnd2->Xb & 15, (unsigned)Opnd2->Xb >> 4, Opnd2->D);
            if (Ocode == Iad && Gruse[Evalreg] == 9 && Opnd2->Xb == 0 && Opnd2->D < 4095 &&
                (unsigned)Grinf1[Evalreg] >> 16 == 0) {
              Gruse[Evalreg] = 10;
              Grinf1[Evalreg] = Grinf1[Evalreg] & 0xFFFF | Opnd2->D << 16;
            } else if (31 > Jj || Jj > 32)
              Gruse[Evalreg] = 0;
            Olink[Evalreg] = Operand[Comm];
          }
          void Float(Rd * Opnd, int Otherptype) {
            if (Opnd.Flag <= 1) {
              Cvalue = Opnd.D;
              Opnd.D = *Integer(Addr(Cvalue));
              Opnd.Xtra = *Integer(Addr(Cvalue) + 4);
              Opnd.Flag = 1;
            } else {
              Load(*Opnd, Accr, 2);
              if ((Otherptype & 0xF0) == 0x70 && (Opnd.Ptype & 0xF0) <= 0x50) {
                Psf1(Imyd, 0, 1);
                Opnd.Ptype = Opnd.Ptype & 15 | 0x60;
              }
              Psf1(Flt, 0, 0);
              Gruse[Accr] = 0;
            }
            Opnd.Ptype = Opnd.Ptype + 0x11;
            Type = 2;
          }
          void Coercet(Rd * Opnd1, Rd * Opnd2, int Mode) {
            int Pt1;
            int Pt2;
            Pt1 = Opnd1.Ptype & 7;
            Pt2 = Opnd2.Ptype & 7;
            if ((Mode == 1 || Mode == 15) && Pt1 == 1 && 1 == Pt2) return;
            if (Mode == 1) {
              Fault(24, 0);
              return;
            }
            if (Pt1 == 1) Float(*Opnd1, Opnd2.Ptype);
            if (Pt2 == 1) Float(*Opnd2, Opnd1.Ptype);
          }
          void Coercep(Rd * Opnd1, Rd * Opnd2) {
            int Prec1;
            int Prec2;
            Prec1 = (unsigned)Opnd1.Ptype >> 4;
            Prec2 = (unsigned)Opnd2.Ptype >> 4;
            while (Prec1 < Prec2) {
              Lengthen(*Opnd1);
              Prec1 = (unsigned)Opnd1.Ptype >> 4;
            }
            while (Prec2 < Prec1) {
              Lengthen(*Opnd2);
              Prec2 = (unsigned)Opnd2.Ptype >> 4;
            }
          }
          void Lengthen(Rd * Opnd) {
            int Tp;
            int Pr;
            Tp = Opnd.Ptype & 7;
            Pr = (unsigned)Opnd.Ptype >> 4;
            if (Opnd.Flag <= 1 && Pr <= 4 + Tp)
              if (Tp == 1 && Opnd.Flag <= 1) {
                Opnd.Xtra = Opnd.D;
                if (Opnd.Xtra < 0)
                  Opnd.D = -1;
                else
                  Opnd.D = 0;
              } else if (Pr == 6) {
                Toar8(R, *Longreal(Addr(Opnd.D)));
                Toar8(R + 8, 0);
                Opnd.Xtra = Addr(A[R]);
                Opnd.Flag = 3;
                R += 16;
              } else
                Opnd.Xtra = 0;
            else {
              Load(*Opnd, Accr, 2);
              if (Tp == 1)
                Psf1(Imyd, 0, 1);
              else
                Pf1(Rmyd, 0, Pc, Specialconsts(1));
              Gruse[Accr] = 0;
            }
            Opnd.Ptype = ((Pr + 1) << 4) + Tp;
          }
          void Shorten(Rd * Opnd) {
            int Ty;
            int Pr;
            int F;
            int I;
            int J;
            Ty = Opnd.Ptype & 7;
            Pr = (unsigned)Opnd.Ptype >> 4;
            F = Opnd.Flag;
            if (F == 3) {
              for (I = 0; I <= 3; I++) *Byteinteger(Addr(J) + I) = *Byteinteger(Opnd.Xtra + 4 + I);
              Opnd.Xtra = J;
              Opnd.Flag = 1;
              goto Wayout;
            }
            if (F <= 1) {
              if (Ty == 2) goto Wayout;
              if ((Opnd.D == 0 && Opnd.Xtra >= 0) || (Opnd.D == -1 && Opnd.Xtra < 0)) {
                Opnd.D = Opnd.Xtra;
                goto Wayout;
              }
            }
            Load(*Opnd, Accr, 2);
            if (Pr == 7)
              Pf1(Rddv, 0, Pc, Specialconsts(1));
            else {
              if (Type == 1 && 1 == Parmarr) Psf1(Ish, 0, 32);
              if (Parmarr == 1 || Type != 1) Psf1(Ush, 0, -32);
              if (!Register[Breg]) {
                Pf1(Stuh, 0, Breg, 0);
                Gruse[Breg] = 0;
              } else
                Psf1(Mpsr, 0, 17);
            }
            Gruse[Accr] = 0;
          Wayout:;
            Opnd.Ptype = ((Pr - 1) << 4) + Ty;
          }
          void Extract(Rd * Opnd, long long int *Val, double *Rval) {
            int Type;
            int Prec;
            int S;
            int I;
            int Ad;
            Type = Opnd.Ptype;
            Prec = (unsigned)Type >> 4;
            Type = Type & 15;
            if (Type == 1) {
              if (Prec <= 5)
                *Val = Opnd.D;
              else {
                *Integer(Addr(*Val)) = Opnd.D;
                *Integer(Addr(*Val) + 4) = Opnd.Xtra;
              }
              *Rval = *Val;
            } else {
              *Rval = 0;
              if (Prec == 7) {
                S = 15;
                Ad = Opnd.Xtra;
              } else {
                S = 7;
                Ad = Addr(Opnd.D);
              }
              for (I = 0; I <= S; I++) *Byteinteger(Addr(*Rval) + I) = *Byteinteger(Ad + I);
            }
          }
          void Vmy1(void) {
            int Opname;
            int Vuse;
            int Dvpos;
            int Dvname;
            int X;
            int Y;
            int Dtype;
            int Dprec;
            int Dacc;
            int Dptype;
            Dptype = (unsigned)Xtra >> 16;
            Dvname = Xtra & 0xFFFF;
            Dvpos = Opnd2->D & 0xFFFF;
            if (Dvpos > 0 && Opnd1->Flag <= 1) {
              X = Opnd1->D;
              X -= Ctable->Val;
              X = X * Ctable->Val;
              if (X < 0 || X >= Ctable->Val) Fault2(50, X, Dvname);
              if (Parmarr == 0 && 0 == Parmchk && (Dptype & 0xC0F) <= 3) X += Ctable->Val * Ctable->Val;
              Opnd1->D = X;
              return;
            }
            Opname = -1;
            if (Opnd1->Flag == 2) Opname = Opnd1->Xtra;
            Vuse = Dvname | Opname << 16;
            if (Opname >= 0 && Gruse[Breg] == 14 && Grinf1[Breg] == Vuse) goto Done;
            if (Parmarr == 0 && 0 == Parmchk && Dvpos > 0) {
              Load(*Opnd1, Breg, 2);
              X = Ctable->Val;
              if (X != 1) {
                Psf1(Myb, 0, X);
                Gruse[Breg] = 0;
              }
              Y = X * Ctable->Val;
              if ((Dptype & 0xC0F) <= 3) {
                if (X != 1) goto Done;
                goto Out;
              }
              if (Y) {
                Psf1(Sbb, 0, Y);
                Gruse[Breg] = 0;
              }
              goto Done;
            }
            if (Parmarr == 0 && 0 == Parmchk && ((Dptype & 0x300) == 0x200 || (Dptype & 0xC0F) <= 3 || Compiler != 0)) {
              Dtype = Dptype & 15;
              Dprec = (unsigned)Dptype >> 4 & 7;
              if (Opnd1->Flag > 1) Load(*Opnd1, Breg, 2);
              if (Dtype >= 3 || Dprec == 4) {
                Dacc = List->S3;
                if (Opnd1->Flag <= 1) {
                  Opnd1->D = Opnd1->D * Dacc;
                  return;
                }
                if (Dacc != 1) Psf1(Myb, 0, Dacc);
                Gruse[Breg] = 0;
                goto Done;
              }
              if (Opnd1->Flag <= 1) return;
              Loadreg = Breg;
              goto Out;
            }
            if (Opnd1->Flag == 9 && (unsigned)Opnd1->Xb >> 4 == Accr) {
              Pf1(St, 0, Tos, 0);
              Changerd(Accr);
              Register[Accr] = 0;
            }
            Base = (unsigned)Opnd2->Xtra >> 18;
            Area = -1;
            Getinacc(Dr, 2, 0, Areacode(), (Opnd2->Xtra & 0x1FFFF) + 8);
            Load(*Opnd1, Evalreg, 0);
            if ((unsigned)Opnd1->Ptype >> 4 >= 6) Fault(24, 0);
            if (Register[Breg] >= 1 && (Opnd1->Flag != 9 || (unsigned)Opnd1->Xb >> 4 != Breg)) {
              Opnd = Record(Olink[Breg]);
              Opnd->D = 0;
              Register[Breg] = 2;
              Bootout(Breg);
            }
            Area = (unsigned)Opnd1->Xb >> 4;
            Access = Opnd1->Xb & 15;
            Psorlf1((unsigned)Opcode >> 8, Access, Area, Opnd1->D);
            Gruse[Breg] = 0;
          Done:;
            if (Opname >= 0) {
              Gruse[Breg] = 14;
              Grinf1[Breg] = Vuse;
              Grinf2[Breg] = 0;
            }
          Out:;
            Loadreg = Breg;
            Register[Loadreg] = 1;
            Opnd1->Flag = 9;
            Opnd1->Xb = Loadreg << 4;
          }
          void Vmy(void) {
            if (Opnd1->Flag == 9 && (unsigned)Opnd1->Xb >> 4 == Accr) {
              Pf1(St, 0, Tos, 0);
              Changerd(Accr);
              Register[Accr] = 0;
            }
            if (C == D) {
              Base = (unsigned)Opnd2->Xtra >> 18;
              Area = -1;
              Getinacc(Dr, 2, 0, Areacode(), (Opnd2->Xtra & 0x1FFFF) + 8);
            }
            Load(*Opnd1, Evalreg, 0);
            if ((unsigned)Opnd1->Ptype >> 4 >= 6) Fault(24, 0);
            if (C == D && Register[Breg] >= 1 && (Opnd1->Flag != 9 || (unsigned)Opnd1->Xb >> 4 != Breg)) {
              Opnd = Record(Olink[Breg]);
              Opnd->D = 0;
              Register[Breg] = 2;
              Bootout(Breg);
            }
            Area = (unsigned)Opnd1->Xb >> 4;
            Access = Opnd1->Xb & 15;
            Psorlf1((unsigned)Opcode >> 8, Access, Area, Opnd1->D);
            Gruse[Breg] = 0;
            Loadreg = Accr;
            if (C == D)
              Getinacc(Accr, 1, 0, 7, 0);
            else
              Pf1(Iad, 0, Breg, 0);
            if (C == 1) {
              Pf1(St, 0, Breg, 0);
              Register[Accr] = 0;
              Loadreg = Breg;
            }
            Register[Loadreg] = 1;
            Opnd1->Flag = 9;
            Opnd1->Xb = Loadreg << 4;
          }
          void Ctop(int *Flag) {
            static const int Truncmask = 0x01300800;
            int K;
            int Typep;
            int Precp;
            int Op;
            int Typepp;
            int Val;
            int Sval1;
            int Sval2;
            long long int Val1;
            long long int Val2;
            double Rval1;
            double Rval2;
            static int Isw_sw;
            static void *Isw[23 /*10:32*/] = {
                &&Isw_10,      &&Isw_11,      &&Isw_12, &&Isw_13, &&Isw_14, &&Isw_default, &&Isw_default, &&Isw_default,
                &&Isw_default, &&Isw_default, &&Isw_20, &&Isw_21, &&Isw_22, &&Isw_23,      &&Isw_24,      &&Isw_25,
                &&Isw_26,      &&Isw_27,      &&Isw_28, &&Isw_29, &&Isw_30, &&Isw_31,      &&Isw_32,
            };
            static int Rsw_sw;
            static void *Rsw[23 /*10:32*/] = {
                &&Rsw_default, &&Rsw_11,      &&Rsw_12,      &&Rsw_13,      &&Rsw_14, &&Rsw_default,
                &&Rsw_default, &&Rsw_default, &&Rsw_default, &&Rsw_default, &&Rsw_20, &&Rsw_21,
                &&Rsw_22,      &&Rsw_23,      &&Rsw_24,      &&Rsw_25,      &&Rsw_26, &&Rsw_27,
                &&Rsw_28,      &&Rsw_29,      &&Rsw_default, &&Rsw_31,      &&Rsw_32,
            };
            if (_imp_on_event(1, 2)) return;
            Typep = Type;
            Precp = (unsigned)Ptype >> 4 & 15;
            Op = *Flag;
            Extract(*Opnd1, Val1, Rval1);
            Extract(*Opnd2, Val2, Rval2);
            Sval1 = Val1;
            Sval2 = Val2;
            if (Typep == 1 && Op == 37) goto Isw37;
            if (Op > 32) return;
            if (Typep == 2)
              goto *Rsw[Rsw_sw = (Op)-10];
            else
              goto *Isw[Isw_sw = (Op)-10];
          Isw_10:;
            Val1 = ~Val1;
          Intend:;
            if (Precp == 6) {
              Opnd1->D = (unsigned)Val1 >> 32;
              Opnd1->Xtra = Val1;
              *Flag = 0;
            } else {
              Val = Val1;
              if (Val == Val1 || (1 << Op & Truncmask) == 0) {
                *Flag = 0;
                Opnd1->D = Val;
              }
            }
            if (!*Flag) {
              Opnd1->Ptype = Precp << 4 | 1;
              if (0xFFFE0000 <= Val1 && Val1 <= 0x1FFFF)
                Opnd1->*Flag = 0;
              else
                Opnd1->*Flag = 1;
            }
            return;
          Isw_11:;
            Val1 = -Val1;
            goto Intend;
          Isw_13:;
            Val1 = Imod(Val1);
            goto Intend;
          Isw_12:;
            Rval1 = Val1;
            Precp = 5 + Xtra;
            goto Realend;
          Rsw_14:;
            Precp++;
          Realend:
            Opnd1->*Flag = 1;
            Opnd1->D = *Integer(Addr(Rval1));
            Opnd1->Xtra = *Integer(Addr(Rval1) + 4);
            if (Precp == 7) {
              Opnd1->*Flag = 3;
              Opnd1->Xtra = Addr(A[R]);
              for (K = 0; K <= 15; K++) {
                A[R] = *Byteinteger(Addr(Rval1) + K);
                R++;
              }
            }
            *Flag = 0;
            Opnd1->Ptype = 16 * Precp + 2;
            return;
          Isw_14:;
          Rsw_12:;
            Abort();
          Isw_20:;
            Val1 += Val2;
            goto Intend;
          Isw_21:;
            Val1 -= Val2;
            goto Intend;
          Isw_22:;
            Val1 = Val1 ^ Val2;
            goto Intend;
          Isw_23:;
            Val1 = Val1 | Val2;
            goto Intend;
          Isw_24:;
            Val1 = Val1 * Val2;
            goto Intend;
          Isw_26:
            return;
          Isw_25:
            if (!Val2) return;
            Val1 = Val1 / Val2;
            goto Intend;
          Isw_27:;
            Val1 = Val1 & Val2;
            goto Intend;
          Isw_29:;
            if (Precp == 6)
              Val1 = Val1 << Sval2;
            else
              Val1 = Sval1 << Sval2;
            goto Intend;
          Isw_28:;
            if (Precp == 6)
              Val1 = (unsigned)Val1 >> Sval2;
            else
              Val1 = (unsigned)Sval1 >> Sval2;
            goto Intend;
          Isw_31:
          Isw_32:;
          Rsw_31:
          Rsw_32:;
            Bfflag = Comm - 1;
            Mask = Fcomp[Xtra + 7 * Bfflag];
            Comm = 2;
            *Flag = 0;
            if (Type == 2) goto Rcomp;
            if (((Mask & 8) != 0 && Val1 == Val2) || ((Mask & 4) != 0 && Val1 < Val2) ||
                ((Mask & 2) != 0 && Val1 > Val2))
              Mask = 15;
            else
              Mask = 0;
            return;
          Rcomp:;
            if (((Mask & 8) != 0 && Rval1 == Rval2) || ((Mask & 4) != 0 && Rval1 < Rval2) ||
                ((Mask & 2) != 0 && Rval1 > Rval2))
              Mask = 15;
            else
              Mask = 0;
            return;
          Rsw_11:;
            Rval1 = -Rval1;
            goto Realend;
          Rsw_13:;
            Rval1 = Mod(Rval1);
            goto Realend;
          Rsw_20:;
            Rval1 += Rval2;
            goto Realend;
          Rsw_21:;
            Rval1 -= Rval2;
            goto Realend;
          Rsw_24:;
            Rval1 = Rval1 * Rval2;
            goto Realend;
          Rsw_26:;
            if (!Rval2) return;
            Rval1 = Rval1 / Rval2;
            goto Realend;
          Isw_30:;
          Isw37:;
            if (0 > Val2 || Val2 > 63) return;
            Val2 = 1;
            while (Sval2 > 0) {
              Val2 = Val2 * Val1;
              Sval2--;
              if (Val2 != *Integer(Addr(Val2) + 4)) return;
            }
            Val1 = Val2;
            goto Intend;
          Rsw_22:
          Rsw_23:;
          Rsw_25:
          Rsw_27:
          Rsw_28:
          Rsw_29:;
            goto Rsw_skip;
          Rsw_default:
            fprintf(stderr, "\nSwitch label 'Rsw(%d):' not set in %s\n", Rsw_sw + 10, __PRETTY_FUNCTION__);
            fflush(stderr);
            abort();
          Rsw_skip:;
            goto Isw_skip;
          Isw_default:
            fprintf(stderr, "\nSwitch label 'Isw(%d):' not set in %s\n", Isw_sw + 10, __PRETTY_FUNCTION__);
            fflush(stderr);
            abort();
          Isw_skip:;
          }
          void Rexp(void) {
            int I;
            int Pr;
            Rd *Opnd;
            if (Register[Breg] > 0) Bootout(Breg);
            for (I = 1; I <= 2; I++) {
              Opnd = Record(Operand[I]);
              if (I != 1 || Opnd->Flag != 8) Load(*Opnd, Accr, 2);
              Pr = (unsigned)Opnd->Ptype >> 4;
              if (Pr < 6) Lengthen(*Opnd);
              if (Pr > 6) Shorten(*Opnd);
            }
            Ppj(0, 17);
          }
          void Starstar(void) {
            int Typep;
            int Precp;
            int Work;
            int C;
            int Expwork;
            int Value;
            Ptype = Opnd1->Ptype;
            Unpack();
            Typep = Type;
            Precp = Prec;
            if (Typep == 2)
              Opcode = 0xFA;
            else
              Opcode = 0xEA;
            Value = 0;
            if (Opnd2->Flag == 0 && 1 <= Opnd2->D && Opnd2->D <= 63 * Type) Value = Opnd2->D;
            Load(*Opnd1, Accr, 2);
            if (Typep == 2 && Precp == 5) {
              Lengthen(*Opnd1);
              Precp = 6;
            }
            if (2 <= Value && Value <= 4) {
              Pf1(St, 0, Tos, 0);
              if (Value == 3) Pf1(St, 0, Tos, 0);
              Pf1(Opcode, 0, Tos, 0);
              if (Value == 4) Pf1(St, 0, Tos, 0);
              if (Value > 2) Pf1(Opcode, 0, Tos, 0);
              Gruse[Accr] = 0;
              return;
            }
            Getwsp(Work, (unsigned)Bytes[Precp] >> 2);
            if (Typep == 2) Getwsp(Expwork, 1);
            Psf1(St, 1, Work);
            Register[Accr] = 0;
            Plabel--;
            if ((unsigned)Opnd2->Ptype >> 4 == 6) Shorten(*Opnd2);
            Load(*Opnd2, Breg, 2);
            if (Typep == 2) Psf1(Stb, 1, Expwork);
            Getinacc(Accr, (unsigned)Bytes[Precp + 1 - Typep] >> 2, 0, 0, 1);
            if (Typep == 2) Psf1(Flt, 0, 0);
            if (!Value) {
              Enterjump(28, Plabel, 0b11);
              if (Typep == 2) {
                Pf3(Jat, 13, 0, 4);
                Psf1(Slb, 0, 0);
                Pf1(Sbb, 0, Tos, 0);
              }
              if (Parmopt == 1) {
                if (Typep == 1) Ppj(30, 7);
                Psf1(Cpb, 0, 64 * Typep * Typep - 1);
                Ppj(2, 7);
              }
            }
            C = Ca;
            Psf1(Opcode, 1, Work);
            Psf1(Debj, 0, (C - Ca) / 2);
            if (Value == 0 && Typep == 2) {
              Psf1(Lb, 1, Expwork);
              Enterjump(46, Plabel, 0b11);
              if (Precp < 7)
                Pf1(Rrdv, 0, Pc, Specialconsts(1));
              else {
                Psf1(Slsd, 0, 1);
                Psf1(Flt, 0, 0);
                Pf1(Rdv, 0, Tos, 0);
              }
            }
            Type = Typep;
            Prec = Precp;
            Register[Breg] = 0;
            Gruse[Accr] = 0;
            Gruse[Breg] = 0;
            Register[Accr] = 1;
            Opnd1->Ptype = 16 * Prec + Type;
            Opnd1->Xb = 0;
            Opnd1->D = Accr;
            C = Enterlab(Plabel, 0b11);
          }
          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 Reduceenv(int *Head) {
          int Newhead;
          int I;
          int J;
          int K;
          int Reg;
          int Use;
          Newhead = 0;
          while (*Head) {
            Pop(*Head, I, J, K);
            Reg = (unsigned)K >> 8;
            Use = K & 255;
            if (Use == (Gruse[Reg] & 255) && I == Grinf1[Reg]) Push(Newhead, I, J, K);
          }
          *Head = Newhead;
        }
        int Ccond(int Cto, int Iu, int Farlab) {
          auto void Writecondlist(void);
          auto void Skipsc(int Reversed);
          auto void Skipcond(int Reversed);
          auto int Ccomp(void);
          auto void Jump(int Mask, int Lab, int Flags);
          auto void Labunused(int Lab);
          auto void Omitto(int Lab);
          static const unsigned char Fcomp[21 /*1:21*/] = {8,  13, 5, 7,  10, 2, 7,  8, 10, 2, 7,
                                                           13, 5,  7, 27, 0,  0, 43, 0, 0,  43};
          int Pin;
          int Pp;
          int Ii;
          int L;
          int Cptr;
          int Cmax;
          int Ll;
          int Bitmask;
          int La;
          typedef struct Cf {
            unsigned char Tf;
            unsigned char Cmp1;
            unsigned char Cmp2;
            unsigned char Labu;
            unsigned char Lvl;
            unsigned char Jmp;
            unsigned char Rev;
            unsigned char Sp;
            int Labno;
            int Sp1;
            int Sp2;
          } Cf;
          Cf Clist[30 /*1:30*/];
          Cf *C1;
          Cf *C2;
          Pin = P;
          Cptr = 1;
          L = 3;
          C1 = &Clist[Cptr];
          *C1 = 0;
          Skipsc(0);
          Skipcond(0);
          C1->Lvl = 2;
          C1->Tf = Iu;
          Cmax = Cptr + 1;
          C1 = &Clist[Cmax];
          *C1 = 0;
          C1->Lvl = 1;
          C1->Tf = 3 - Iu;
          C1->Labno = Farlab;
          Pp = P;
          if (Cmax > 29) Fault(209, 0);
          for (Cptr = 1; Cptr <= Cmax - 1; Cptr++) {
            C1 = &Clist[Cptr];
            L = C1->Lvl;
            Ll = L;
            for (Ii = Cptr + 1; Ii <= Cmax + 1; Ii++) {
              C2 = &Clist[Ii];
              if (C1->Tf != C2->Tf && C2->Lvl < Ll) break;
              if (C2->Lvl < Ll) Ll = C2->Lvl;
            }
            C1->Jmp = Ii;
            C2->Labu = C2->Labu + 1;
            if (C1->Cmp2 != 0 || C1->Cmp1 == 8) {
              C1->Labu = C1->Labu + 1;
            }
            if (C1->Labu != 0 && C1->Labno <= 0) {
              Plabel--;
              C1->Labno = Plabel;
            }
          }
          if (Dcomp == 1) Writecondlist();
          Bitmask = 0;
          Cptr = 1;
          for (;;) {
            C1 = &Clist[Cptr];
            La = Ccomp();
            if (La) {
              Omitto(La);
              if (Cptr >= Cmax) {
                if (!Cto) Enterjump(15, La, 0b11);
                return (2);
              }
              C1 = &Clist[Cptr];
            }
            if (C1->Labno > 0) Ii = Enterlab(C1->Labno, 0b11);
            Cptr++;
            if (Cptr >= Cmax) break;
          }
          P = Pp;
          if (!(Bitmask & 1)) return (1);
          return (0);
          void Labunused(int Lab) {
            int I;
            Cf *C1;
            for (I = Cptr; I <= Cmax - 1; I++) {
              C1 = &Clist[I];
              if (C1->Labno == Lab) {
                C1->Labu = C1->Labu - 1;
                if (!C1->Labu) C1->Labno = 0;
                return;
              }
            }
          }
          void Omitto(int Lab) {
            Cf *C1;
            for (;;) {
              C1 = &Clist[Cptr];
              if (C1->Labno > 0) {
                if (C1->Labno == Lab) return;
                Jump(15, Lab, 0b11);
                return;
              }
              Cptr++;
              if (Cptr >= Cmax) break;
            }
          }
          void Skipsc(int Reversed) {
            static int Scalt_sw;
            static void *Scalt[3 /*1:3*/] = {
                &&Scalt_1,
                &&Scalt_2,
                &&Scalt_3,
            };
            int Alt;
            Alt = A[P];
            P++;
            goto *Scalt[Scalt_sw = (Alt)-1];
          Scalt_1:;
            C1->Sp1 = P - Pin;
            Skipexp();
            C1->Cmp1 = A[P];
            C1->Rev = 3 * Reversed;
            P++;
            C1->Sp2 = P - Pin;
            Skipexp();
            if (A[P] == 2)
              P++;
            else {
              C1->Cmp2 = A[P + 1];
              P += 2;
              Skipexp();
            }
            return;
          Scalt_2:;
            L++;
            Skipsc(Reversed);
            Skipcond(Reversed);
            L--;
            return;
          Scalt_3:;
            Skipsc(Reversed ^ 1);
          }
          void Skipcond(int Reversed) {
            int Alt;
            int Altp;
            Alt = A[P];
            P++;
            if (Alt != 3) {
              do {
                C1->Lvl = L;
                C1->Tf = Alt;
                C1->Tf = C1->Tf ^ (3 * Reversed);
                Cptr++;
                C1 = &Clist[Cptr];
                *C1 = 0;
                Skipsc(Reversed);
                Altp = A[P];
                P++;
              } while (Altp != 2);
            }
          }
          void Writecondlist(void) {
            static const _imp_string Cm[11 /*0:10*/] = {
                _imp_str_literal("     "), _imp_str_literal("    ="),  _imp_str_literal("   >="),
                _imp_str_literal("    >"), _imp_str_literal("    #"),  _imp_str_literal("   <="),
                _imp_str_literal("    <"), _imp_str_literal("   \\="), _imp_str_literal("   ->"),
                _imp_str_literal("   =="), _imp_str_literal("  \\==")};
            Printstring(_imp_str_literal("\n NO   TF   C1   C2   LABU   LVL  JMP  REV   LABNO\n"));
            for (Cptr = 1; Cptr <= Cmax; Cptr++) {
              C1 = &Clist[Cptr];
              Write(Cptr, 2);
              Write(C1->Tf, 4);
              Printstring(Cm[C1->Cmp1]);
              Printstring(Cm[C1->Cmp2]);
              Write(C1->Labu, 6);
              Write(C1->Lvl, 5);
              Write(C1->Jmp, 4);
              Write(C1->Rev, 4);
              Write(C1->Labno, 7);
              Newline();
            }
          }
          int Ccomp(void) {
            auto void Acomp(int Tf, int Ds);
            auto void Adcomp(int Tf);
            auto void Scomp(int Ds, int Tf, int Lab, int *Wa);
            int Head1;
            int Head2;
            int Nops;
            int Te1;
            int Te2;
            int Tex1;
            int Tex2;
            int P1;
            int P2;
            int Fexit;
            int Iexit;
            int Cmp;
            int Wa1;
            int Wa2;
            int Wa3;
            int Bot1;
            int Bot2;
            Head1 = 0;
            Head2 = 0;
            Nops = 0;
            Bot1 = 0;
            Bot2 = 0;
            Fexit = Clist[C1->Jmp].Labno;
            Iexit = Fexit;
            if ((C1->Rev ^ C1->Tf) == 2 && (C1->Cmp1 == 8 || C1->Cmp2 != 0)) Iexit = C1->Labno;
            P = Pin + C1->Sp2;
            P2 = P;
            P1 = Pin + C1->Sp1;
            if (C1->Cmp1 == 8) {
              P = P1;
              if (A[P + 3] == 4 && A[P + 4] == 1) {
                P += 5;
                Cname(2, Dr);
                if (A[P] == 2) {
                  if (Type != 5) {
                    Fault2(71, 0, Fromar2(P1 + 5));
                    return (0);
                  }
                  P = P2;
                  Cres(Iexit);
                  if (Iexit == Farlab)
                    Bitmask = Bitmask | 1;
                  else
                    Bitmask = Bitmask | 2;
                  if ((C1->Rev ^ C1->Tf) == 2) Jump(15, Fexit, 0b11);
                  return (0);
                }
              }
              Fault2(74, 0, 0);
              return (0);
            }
            if (C1->Cmp1 > 8) goto Adrcomp;
            Mask = Fcomp[C1->Cmp1];
            Te2 = Tsexp(Tex2);
            if (Type == 5) goto Str;
            if (Te2 != 1) goto Arith;
            P = P1;
            Te1 = Tsexp(Tex1);
            if (Type == 5) goto Str;
          Arith:;
            P = P1 + 3;
            Torp(Head1, Bot1, Nops);
            Cmp = C1->Cmp1;
            P = P2 + 3;
            if (C1->Cmp2) {
              Acomp(1, 1);
              if (Mask == 15) return (Iexit);
              Jump(Mask, Iexit, 0b11);
              P += 5;
              Cmp = C1->Cmp2;
            }
            Acomp(C1->Rev ^ C1->Tf, 0);
            if (Mask == 15) return (Fexit);
            Jump(Mask, Fexit, 0b11);
            return (0);
          Str:;
            P = P1;
            Wa1 = 0;
            Wa2 = 0;
            Wa3 = 0;
            if (C1->Cmp2 == 0 && 7 <= Fcomp[C1->Cmp1] && Fcomp[C1->Cmp1] <= 8 && A[P2 + 3] == 4 && A[P2 + 4] == 2 &&
                A[P2 + 5] == 0x35 && A[P2 + 10] == 0 && A[P2 + 11] == 2) {
              Cstrexp(0, Dr);
              Mask = Fcomp[C1->Cmp1 + 14];
              if ((C1->Rev ^ C1->Tf) == 1) Mask = Reverse(Mask);
              Jump(Mask, Fexit, 0b11);
              return (0);
            }
            Cstrexp(16, Accr);
            Wa1 = Value;
            Cmp = C1->Cmp1;
            P = P2;
            if (C1->Cmp2) {
              Scomp(1, 1, Iexit, Wa2);
              P += 2;
              Cmp = C1->Cmp2;
              if (Wa1) {
                Returnwsp(Wa1, 256);
                Wa1 = 0;
              }
            }
            Scomp(0, C1->Rev ^ C1->Tf, Fexit, Wa3);
            for (Cmp = Addr(Wa1); Cmp <= Addr(Wa3); Cmp += 4)
              if (*Integer(Cmp)) Returnwsp(*Integer(Cmp), 256);
            return (0);
          Adrcomp:;
            Adcomp(C1->Rev ^ C1->Tf);
            Jump(Mask, Fexit, 0b11);
            return (0);
            void Adcomp(int Tf) {
              int Typep;
              int Precp;
              int Lhname;
              int Rhname;
              int Fname;
              Rd R;
              Lhname = A[P1 + 5] << 8 | A[P1 + 6];
              Fname = Rhname;
              Rhname = A[P2 + 5] << 8 | A[P2 + 6];
              if (A[P1 + 3] != 4 || A[P1 + 4] != 1) goto Flt;
              P = P1 + 5;
              Cname(4, Accr);
              if (A[P] != 2) goto Flt;
              Typep = Type;
              Precp = Prec;
              Register[Accr] = 1;
              Olink[Accr] = Addr(R);
              R.Ptype = 1;
              R.Xb = Accr << 4;
              R.Flag = 9;
              Fname = Lhname;
              if (A[P2 + 3] != 4 || A[P2 + 4] != 1) goto Flt;
              P = P2 + 5;
              Cname(4, Accr);
              if (A[P] != 2) goto Flt;
              if (Typep != Type || Precp != Prec) Fault2(83, Lhname, Rhname);
              Pf1(Icp, 0, Tos, 0);
              if (C1->Cmp1 == 10)
                Mask = 7;
              else
                Mask = 8;
              if (Tf == 1) Mask = Reverse(Mask);
              return;
            Flt:
              Register[Accr] = 0;
              Fault2(80, 0, Fname);
              Mask = 7;
            }
            void Acomp(int Tf, int Ds) {
              int Precp;
              int Typep;
              int Reg;
              Precp = (unsigned)Ptype >> 4 & 15;
              Typep = Type;
              Push(Head2, 31 + Ds, Cmp, 0);
              Bot2 = Head2;
              Nops = (Nops + 1) | 1 << 31;
              Torp(Head2, Bot2, Nops);
              if (Typep > Type) Type = Typep;
              Aslist[Bot1].Link = Head2;
              Bot1 = Bot2;
              Bot2 = 0;
              Head2 = 0;
              Expop(Head1, -1, Nops, 256 + 16 * Precp + Type);
              Aslist[Bot1].Link = Asl;
              Asl = Head1;
              Head1 = 0;
              if (Ds) {
                Push(Head1, *Integer(Addr(Expopnd)), Expopnd.D, Expopnd.Xtra);
                Bot1 = Head1;
                if (Expopnd.Flag == 9) {
                  Reg = (unsigned)Expopnd.D >> 4;
                  Register[Reg] = 1;
                  Olink[Reg] = Addr(Aslist[Head1]);
                }
              }
              if (Tf == 1) Mask = Reverse(Mask);
            }
            void Scomp(int Ds, int Tf, int Lab, int *Wa) {
              int Mask;
              Rd R;
              Register[Accr] = 1;
              Olink[Accr] = Addr(R);
              R.Ptype = 1;
              R.Xb = Accr << 4;
              R.Flag = 9;
              Mask = Fcomp[Cmp];
              if (Tf == 1) Mask = Reverse(Mask);
              Cstrexp(16, Dr);
              *Wa = Value;
              Register[Accr] = 0;
              if (R.Flag != 9) Pf1(Lsd, 0, Tos, 0);
              if (Ds) Pf1(Std, 0, Tos, 0);
              Psf1(Inca, 0, 1);
              Psf1(Iad, 0, 1);
              Pf2(Cps, 1, 1, 0, 0, 0);
              Gruse[Accr] = 0;
              Gruse[Dr] = 0;
              if (0 != (Mask & 0xC) && (Mask & 0xC) != 0xC) {
                Pf3(Jcc, 7, 0, 4);
                Psf1(Ush, 0, -32);
                Psf1(Ish, 0, -24);
              }
              if (Ds) Pf1(Lsd, 0, Tos, 0);
              Jump(Mask, Lab, 0b11);
            }
          }
          void Jump(int Mask, int Lab, int Flags) {
            if (!Mask) {
              Labunused(Lab);
              return;
            }
            Enterjump(Mask, Lab, Flags);
            if (Lab == Farlab)
              Bitmask = Bitmask | 1;
            else
              Bitmask = Bitmask | 2;
          }
        }
        int Reverse(int Mask) {
          if (Mask > 15)
            Mask = Mask ^ 0x30;
          else
            Mask = Mask ^ 15;
          return (Mask);
        }
        int Enterlab(int Lab, int Flags) {
          int Cell;
          int At;
          int Envhead;
          int Jumphead;
          int Instrn;
          int Oldcell;
          int Work;
          Listf *Lcell;
          int *Lhead;
          Cell = Label[Level];
          Oldcell = 0;
          while (Cell > 0) {
            Lcell = &Aslist[Cell];
            if (Lcell->S3 == Lab) break;
            Oldcell = Cell;
            Cell = Lcell->Link;
          }
          if (Cell <= 0) {
            if (!(Flags & 1)) {
              Push(Label[Level], Ca, 0, Lab);
              Forget(-1);
              return (1);
            }
            return (0);
          }
          if (Lcell->S1 & 0xFFFFFF) {
            Fault(2, Lab);
          } else
            Lcell->S1 = 0x1000000 | Ca;
          Jumphead = Lcell->S2;
          Envhead = (unsigned)Jumphead >> 16;
          Jumphead = Jumphead & 0xFFFF;
          if (!(Flags & 2)) {
            Forget(-1);
            Clearlist(Envhead);
          } else {
            if (!(Flags & 4)) Remember();
            Restore(Envhead);
            Envhead = 0;
            if (!(Flags & 4)) Mergeinfo();
          }
          while (Jumphead) {
            Pop(Jumphead, At, Instrn, Work);
            Plug(1, At, Instrn | (Ca - At) / 2, 4);
          }
          Lcell->S2 = 0;
          if (Lab > Maxulab) {
            if (!Oldcell)
              Lhead = &Label[Level];
            else
              Lhead = &Aslist[Oldcell].Link;
            Pop(*Lhead, At, At, At);
          }
          return (1);
        }
        void Enterjump(int Mask, int Lab, int Flags) {
          int At;
          int Cell;
          int J;
          int Jj;
          int Labaddr;
          int I;
          int Envhead;
          int Oldenv;
          int Jcode;
          int Instrn;
          Listf *Lcell;
          Envhead = 0;
          At = Ca;
          if (Lab < Maxulab) Flags = Flags & 0xFD;
          if (Lab < 21000) Flags = Flags & 0xFE;
          Cell = Label[Level];
          while (Cell > 0) {
            Lcell = &Aslist[Cell];
            if (Lab == Lcell->S3) break;
            Cell = Lcell->Link;
          }
          Instrn = Mask;
          if (!((unsigned)Instrn >> 8)) {
            Jcode = Jcc;
            if (Mask >= 16) Jcode = Jat;
            if (Mask >= 32) Jcode = Jaf;
            Instrn = Jcode << 24 | (Mask & 15) << 21;
            if (Mask == 15) Instrn = Junc << 24 | 3 << 23;
          }
          if (Cell <= 0) goto Firstref;
          Labaddr = Lcell->S1 & 0xFFFFFF;
          if (!Labaddr) goto Notyetset;
          Lcell->S1 = Labaddr | 0x1000000;
          I = (Labaddr - Ca) / 2;
          if (Mask == 15)
            Psf1(Junc, 0, I);
          else
            Pconst(Instrn | (I & 0x3FFFF));
          return;
        Firstref:;
          if (Lab > Maxulab && (Flags & 2) != 0) Getenv(Envhead);
          Push(Label[Level], 0x1000000, Envhead << 16, Lab);
          Cell = Label[Level];
          Lcell = &Aslist[Cell];
          goto Code;
        Notyetset:;
          if (Lab > Maxulab && (Flags & 2) != 0) {
            I = Lcell->S2;
            Oldenv = (unsigned)I >> 16;
            Reduceenv(Oldenv);
            Lcell->S2 = Oldenv << 16 | I & 0xFFFF;
          }
        Code:;
          J = Lcell->S2;
          Jj = J & 0xFFFF;
          Push(Jj, Ca, Instrn, Line);
          Lcell->S2 = J & 0xFFFF0000 | Jj;
          Pconst(Instrn);
        }
        void Removelab(int Lab) {
          Listf *Lcell;
          int *Lhead;
          int Cell;
          int At;
          Lhead = &Label[Level];
          Cell = *Lhead;
          while (Cell > 0) {
            Lcell = &Aslist[Cell];
            if (Lcell->S3 == Lab) break;
            Lhead = &Lcell->Link;
            Cell = *Lhead;
          }
          if (Cell > 0) Pop(*Lhead, At, At, At);
        }
        void Mergeinfo(void) {
          int I;
          for (I = 0; I <= 7; I++)
            if (Sgruse[I] != (Gruse[I] & 255) || Sgrinf[I] != Grinf1[I]) Gruse[I] = 0;
        }
        void Remember(void) {
          int I;
          for (I = 0; I <= 7; I++) {
            Sgruse[I] = Gruse[I] & 255;
            Sgrinf[I] = Grinf1[I];
          }
        }
        void Createah(int Mode) {
          int Wk;
          Getwsp(Wk, 4);
          Area = Areacode();
          if (!Mode) {
            if (Compiler == 1 && 1 == J && Type <= 2) {
              Pf1(Slss, 2, Area, Disp + 8);
              if (Prec != 3) Psf1(Imy, 0, -Bytes[Prec]);
              Pf1(Iad, 0, Tos, 0);
              Gruse[Dr] = 0;
            }
            Psorlf1(Luh, Access, Area, Disp);
          } else {
            Psf1(Luh, 0, 0);
            Psorlf1(Iad, Access, Area, Disp);
          }
          Psf1(St, 1, Wk);
          Psorlf1(Lsd, Access, Area, Disp + 8);
          Psf1(St, 1, Wk + 8);
          Gruse[Accr] = 0;
          Access = 0;
          Area = Lnb;
          Disp = Wk;
        }
        void Csname(int Z, int Reg) {
          auto int Optmap(void);
          static int Adhoc_sw;
          static void *Adhoc[15 /*1:15*/] = {
              &&Adhoc_1, &&Adhoc_2,  &&Adhoc_3,  &&Adhoc_4,  &&Adhoc_5,  &&Adhoc_6,  &&Adhoc_7,  &&Adhoc_8,
              &&Adhoc_9, &&Adhoc_10, &&Adhoc_11, &&Adhoc_12, &&Adhoc_13, &&Adhoc_14, &&Adhoc_15,
          };
          static const int Sninfo[63 /*0:62*/] = {0x41080001,
                                                  0x41090001,
                                                  0x408A0001,
                                                  0x40A00001,
                                                  0x40010001,
                                                  0x800D0000,
                                                  0x11010001,
                                                  0x11010001,
                                                  0x10020024,
                                                  0x41030001,
                                                  0x19030001,
                                                  0x80130001,
                                                  0x801B0014,
                                                  0x408C0001,
                                                  0x19050024,
                                                  0x80010002,
                                                  0x11040024,
                                                  0x11040024,
                                                  0x80010005,
                                                  0x80090006,
                                                  0x80060007,
                                                  0x2100003E,
                                                  0x2100003E,
                                                  0x11060024,
                                                  0x80010008,
                                                  0x80010009,
                                                  0x8001000A,
                                                  0x8001000B,
                                                  0x8001000C,
                                                  0x8001000D,
                                                  0x8001000E,
                                                  0x8015000F,
                                                  0x2100003E,
                                                  0x100D0024,
                                                  0x80030010,
                                                  0x80030011,
                                                  0x1907003E,
                                                  0x41070001,
                                                  0x10080024,
                                                  0x2100003E,
                                                  0x41050001,
                                                  0x19030001,
                                                  0x2100003E,
                                                  0x19030001,
                                                  0x10020024,
                                                  0x1A07003E,
                                                  0x11090024,
                                                  0x800F0012,
                                                  0x110A8018,
                                                  0x120B1000,
                                                  0x80170013,
                                                  0x11060024,
                                                  0x100C0024,
                                                  0x100D0024,
                                                  [54 ... 55] = 0x2100003E,
                                                  [56 ... 59] = 0x110E0024,
                                                  0x10020024,
                                                  0x2100003E,
                                                  0x100F0001};
          static const _imp_string Snxrefs[21 /*0:20*/] = {
              _imp_str_literal("READSTRING"),  _imp_str_literal("S#READ"),     _imp_str_literal("S#IARCSIN"),
              _imp_str_literal("S#INT"),       _imp_str_literal("S#INTPT"),    _imp_str_literal("S#FRACPT"),
              _imp_str_literal("S#PRINT"),     _imp_str_literal("S#PRINTFL"),  _imp_str_literal("S#IARCCOS"),
              _imp_str_literal("S#ISQRT"),     _imp_str_literal("S#ILOG"),     _imp_str_literal("S#ISIN"),
              _imp_str_literal("S#ICOS"),      _imp_str_literal("S#ITAN"),     _imp_str_literal("S#IEXP"),
              _imp_str_literal("CLOSESTREAM"), _imp_str_literal("S#IRADIUS"),  _imp_str_literal("S#IARCTAN"),
              _imp_str_literal("FROMSTRING"),  _imp_str_literal("SETMARGINS"), _imp_str_literal("S#WRITE")};
          static const int Snparams[30 /*0:29*/] = {0,     1,    0x62, 2, 0x62,  0x62, 2,    0x62, 0x51, 3,
                                                    0x62,  0x51, 0x51, 1, 0x435, 3,    0x35, 0x51, 0x51, 1,
                                                    0x400, 1,    0x51, 3, 0x51,  0x51, 0x51, 2,    0x51, 0x51};
          auto void Rtos(int Reg);
          Rd R;
          int Errno;
          int Flag;
          int Pointer;
          int Wreg;
          int Pin;
          int Snno;
          int Snname;
          int Naps;
          int Snptype;
          int Jj;
          int Xtra;
          int Iocpep;
          int B;
          int D;
          int Sninf;
          int P0;
          int Ophead;
          Snname = Fromar2(P);
          Snno = K;
          Testapp(Naps);
          Pin = P;
          P += 2;
          Snptype = Tsname[Snno];
          Sninf = Sninfo[Snno];
          Xtra = Sninf & 0xFFFF;
          Pointer = ((unsigned)Sninf >> 16) & 255;
          Flag = (unsigned)Sninf >> 24;
          if (Flag & 0x80) {
            Cxref(Snxrefs[Xtra], Parmdynamic, 2, Jj);
            if (Snno == 26) Logepdisp = Jj;
            if (Snno == 31) Expepdisp = Jj;
            Ophead = 0;
            P0 = Snparams[Pointer];
            K = Ophead;
            D = 1;
            while (D <= P0) {
              Ptype = Snparams[Pointer + D];
              Unpack();
              if (!Nam)
                Acc = Bytes[Prec];
              else
                Acc = 8;
              if (Ptype == 0x35) Acc = 256;
              Insertatend(Ophead, Ptype << 16, Acc << 16, 0);
              D++;
            }
            I = 1;
            J = 14;
            Oldi = 0;
            Ptype = Snptype;
            K = Ophead;
            Kform = P0;
            Replacetag(Snname);
            Replace2(Tags[Snname], Jj);
            P = Pin;
            Cname(Z, Reg);
            Nest = Reg;
            P--;
            return;
          }
          if (Naps != (Flag & 3)) {
            Errno = 19;
            goto Errexit;
          }
          Jj = 1 << Z;
          if (!(Jj & Xtra)) {
            Errno = 23;
            if (!Z) Errno = 17;
            if (Z == 1 || 3 <= Z && Z <= 4) Errno = 29;
            if (Xtra & 0xF000) Errno = 84;
            goto Errexit;
          }
          if (Flag & 0x40) {
            Iocpep = Pointer;
            B = Accr;
            if (Flag & 3) {
              P++;
              if (Snno == 37) {
                Cstrexp(0, Dr);
                B = Dr;
              } else
                Csexp(Accr, 0x51);
            }
            if (Iocpep > 127) {
              Psf1(Lss, 0, Iocpep & 127);
              Iocpep = 5;
            }
            if (Snno == 4) Psf1(Lss, 0, 0);
            Ciocp(Iocpep, B);
            P++;
            goto Okexit;
          }
          if (Flag & 0x20) {
            Snptype += 0x1C00;
            if (Parmopt == 0 && Optmap() != 0) goto Okexit;
            if (Z == 1) Bimstr = 1;
            P++;
            Csexp(Breg, 0x51);
            P++;
            if (Z == 1) Bimstr = 0;
            Jj = (unsigned)Snptype >> 4 & 15;
            Disp = Mapdes(Jj);
            Area = Pc;
            Access = 3;
            Oldi = 0;
            goto Okexit;
          }
          P++;
          if ((Flag & 8) != 0 && (A[P + 3] != 4 || A[P + 4] != 1 || A[P + Fromar2(P + 1) + 1] != 2)) {
            Errno = 22;
            goto Errexit;
          }
          goto *Adhoc[Adhoc_sw = (Pointer)-1];
        Adhoc_1:;
          Csexp(Accr, 0x51);
          if (Snno == 6)
            Jj = 10;
          else
            Jj = 32;
          Psf1(Ush, 0, 8);
          Psf1(Or, 0, Jj);
          Ciocp(17, Accr);
          P++;
          goto Okexit;
        Adhoc_2:;
          Getinacc(Accr, 1, 0, 0, 0);
          if (Snno == 60)
            Jj = 18;
          else
            Jj = 2;
          Ciocp(Jj, Accr);
          if (Snno == 44) {
            Rtos(Breg);
            Snptype = 0x1435;
            Area = Pc;
            Access = 3;
            Disp = Mapdes(3);
          }
          Nest = Accr;
          goto Okexit;
        Adhoc_3:;
          if (Snno == 41)
            Jj = 4;
          else
            Jj = 1;
          Psf1(Lss, 0, 0);
          Ciocp(Jj, Accr);
          P += 5;
          if (Snno == 43) {
            Type = 5;
            Rtos(Accr);
            Pf1(Luh, 0, Pc, Paramdes(3));
          } else {
            Register[Accr] = 1;
            Type = 1;
          }
          Jj = Type;
          Assign(6, P);
          P = Pin + 6 + Fromar2(Pin + 4);
          goto Okexit;
        Adhoc_4:;
          Csexp(Accr, 0x62);
          if (Snno == 16) Pf1(Rad, 0, Pc, Specialconsts(0));
          if (!Parmopt) {
            Psf1(Rsc, 0, 55);
            Psf1(Rsc, 0, -55);
          }
          if (Register[Breg]) Bootout(Breg);
          Pf1(Fix, 0, Breg, 0);
          Psf1(Myb, 0, 4);
          Psf1(Cpb, 0, -64);
          Pf3(Jcc, 10, 0, 3);
          Psf1(Lb, 0, -64);
          Pf1(Ish, 0, Breg, 0);
          Pf1(Stuh, 0, Breg, 0);
          Gruse[Accr] = 0;
          Gruse[Breg] = 0;
          Nest = Accr;
          P++;
          goto Okexit;
        Adhoc_5:;
          P += 5;
          Cname(4, Reg);
          Nest = Reg;
          P += 2;
          goto Okexit;
        Adhoc_6:;
          if (Snno == 51) {
            Jj = 0x51;
            B = 5;
            D = Irsb;
            Xtra = 3;
            Wreg = Accr;
            if (Reg == Breg) {
              B = 13;
              D = Slb;
              Xtra = 4;
              Wreg = Breg;
            }
          } else {
            Jj = 0x62;
            B = 1;
            D = Rrsb;
            Xtra = 3;
            Wreg = Accr;
          }
          Csexp(Wreg, Jj);
          Pf3(Jat, B, 0, Xtra);
          Psf1(D, 0, 0);
          if (Wreg == Breg) Pf1(Sbb, 0, Tos, 0);
          Gruse[Wreg] = 0;
          Nest = Wreg;
          P++;
          goto Okexit;
        Adhoc_7:;
          P += 5;
          if (Parmarr != 0 && Snno == 45)
            Cname(Z, Dr);
          else
            Cname(4, Breg);
          Errno = 22;
          if (Type != 5 || Rout != 0) goto Errexit;
          P += 2;
          if (Snno != 36) {
            if (Parmarr == 0 && 0 == Parmchk) {
              Pf1(Stb, 0, Tos, 0);
              Csexp(Breg, 0x51);
              Pf1(Adb, 0, Tos, 0);
            } else {
              Getwsp(Jj, 2);
              if (Z == 2 || Z == 5)
                B = Inca;
              else
                B = Modd;
              Psf1(B, 0, 1);
              Psf1(Std, 1, Jj);
              Csexp(Breg, 0x51);
              Psf1(Ld, 1, Jj);
              Psf1(Sbb, 0, 1);
              Pf1(Modd, 0, Breg, 0);
              Gruse[Dr] = 0;
              Psf1(Adb, 1, Jj + 4);
            }
            P++;
            Gruse[Breg] = 0;
          }
          Disp = Mapdes(3);
          Area = Pc;
          Access = 3;
          if (Z == 1) Stname = -1;
          Snptype += 0x1C00;
          goto Okexit;
        Adhoc_12:;
        Adhoc_8:;
          Nest = 0;
          P++;
          goto Okexit;
        Adhoc_9:;
          Csexp(Accr, 0x51);
          P++;
          Rtos(Breg);
          Disp = Mapdes(3);
          Area = Pc;
          Access = 3;
          Snptype += 0x1C00;
          goto Okexit;
        Adhoc_10:;
          if (!Rectb) {
            Jj = 0x1800FFFF;
            Storeconst(Rectb, 4, Addr(Jj));
          }
          if (!Reg) {
            Csexp(Accr, 0x51);
            Pf1(Luh, 0, Pc, Rectb);
          } else {
            Csexp(Breg, 0x51);
            Pf1(Ldtb, 0, Pc, Rectb);
            Pf1(Lda, 0, Breg, 0);
          }
          P++;
          Gruse[Reg] = 0;
          Oldi = 0;
          Acc = 0xFFFF;
          Snptype += 0x1C00;
          goto Okexit;
        Adhoc_11:;
          Csexp(Accr, 0x51);
          Errno = 22;
          if (A[P + 4] != 4 || A[P + 5] != 1) goto Errexit;
          Register[Accr] = 1;
          Olink[Accr] = Addr(R);
          R = 0;
          R.Ptype = 0x51;
          R.Flag = 9;
          R.Xb = Accr;
          P += 6;
          Cname(12, 0);
          if (R.Flag != 9) Pf1(Lss, 0, Tos, 0);
          Register[Accr] = 0;
          if (A[P] != 2 || Arr <= 0) goto Errexit;
          P += 2;
          Createah(0);
          return;
        Adhoc_13:;
          D = Oninf[Level];
          if (!D) Fault(16, Snname);
          if (Snno != 33) D += 4;
          Getinacc(Accr, 1, 0, Lnb, D);
          Gruse[Accr] = 0;
          Nest = Accr;
          goto Okexit;
        Adhoc_14:;
          D = (Snno & 3) * 8;
          Csexp(Accr, (unsigned)0x62517261 >> D & 255);
          P++;
          Nest = Accr;
          goto Okexit;
        Adhoc_15:;
          if (Parmprof) Ppj(0, 22);
        Okexit:;
          Ptype = Snptype;
          Unpack();
          return;
        Errexit:;
          Fault(Errno, Snname);
          Base = 0;
          Disp = 0;
          Access = 0;
          Area = 0;
          P = Pin + 2;
          Skipapp();
          P--;
          return;
          int Optmap(void) {
            int Varname;
            int Rexp;
            int Pp;
            int Cval;
            int Op;
            int Xynb;
            if (3 <= Z && Z <= 4 || Snno == 42 || Snno == 32 || Snno == 61) return (0);
            Pp = P + 2;
            Rexp = Fromar2(Pp) + Pp;
            Varname = Fromar2(Pp + 4);
            if (A[Pp + 2] != 4 || A[Pp + 3] != 1) return (0);
            Copytag(Varname);
            if (Ptype == Snpt && K == 14 && A[Pp + 6] == 1) goto Wasadr;
            if ((Ptype & 0xFBFF) == 0x51 && A[Pp + 6] == 2 && 2 == A[Pp + 7]) goto Wasloc;
            return (0);
          Wasadr:
            Pp += 10;
            if (A[Pp] != 4 || A[Pp + 1] != 1 || A[Pp + 4] != 2 || 2 != A[Pp + 5] || A[Pp + 6] != 2 || 2 != A[Pp + 7] ||
                A[Pp + 8] != 2)
              return (0);
            Varname = Fromar2(Pp + 2);
            Copytag(Varname);
            if (Ptype & 0xFF0C) return (0);
            if (A[Rexp] == 2)
              P = Rexp + 2;
            else {
              Op = A[Rexp + 1];
              if (1 > Op || Op > 2 || A[Rexp + 2] != 2 || A[Rexp + 3] != 0x41 || A[Rexp + 6] != 2) return (0);
              Cval = Fromar2(Rexp + 4);
              if (Op == 1)
                K += Cval;
              else
                K -= Cval;
              if (K < 0) return (0);
              P = Rexp + 8;
            }
            Base = I;
            Disp = K;
            Area = -1;
            Access = 0;
            Area = Areacode();
            return (1);
          Wasloc:;
            Cval = 0;
            if (A[Rexp] == 2) {
              Pp = Rexp + 2;
              goto Fetch;
            }
            if (A[Rexp + 1] != 1 || A[Rexp + 2] != 2) return (0);
            if (A[Rexp + 3] == 0x41 && A[Rexp + 6] == 2) {
              Cval = Fromar2(Rexp + 4);
              Pp = Rexp + 8;
              goto Fetch;
            }
            if (A[Rexp + 3] == 0x51 && A[Rexp + 8] == 2) {
              Cval = Fromar4(Rexp + 4);
              Pp = Rexp + 10;
              goto Fetch;
            }
            return (0);
          Fetch:
            if ((Cval & 3) != 0 || (unsigned)Cval >> 20 != 0) return (0);
            Xynb = Xorynb(9, Varname);
            if (Gruse[Xynb] != 9 || Grinf1[Xynb] != Varname) {
              Area = -1;
              Base = I;
              Psorlf1(Ldcode[Xynb], 2 * Nam, Areacode(), K);
              Gruse[Xynb] = 9;
              Grinf1[Xynb] = Varname;
            }
            P = Pp;
            Area = Xynb;
            Access = 0;
            Disp = Cval;
            return (1);
          }
          void Rtos(int Reg) {
            int Kk;
            Getwsp(Kk, 1);
            Stringl = 1;
            Disp = Kk + 2;
            Pf1(Or, 0, 0, 256);
            Psf1(St, 1, Kk);
            Getinacc(Reg, 1, 0, Lnb, Ptroffset(Rbase));
            if (Reg == Breg)
              Kk = Adb;
            else
              Kk = Iad;
            Psf1(Kk, 0, Disp);
            Gruse[Breg] = 0;
          }
        }
        void Caname(int Arrp, int Bs, int Dp) {
          int Head1;
          int Head2;
          int Head3;
          int Nops;
          int Ptypep;
          int Kk;
          int Pp;
          int Jj;
          int Soldi;
          int Typep;
          int Arrname;
          int Q;
          int Precp;
          int Elsize;
          int Naminf;
          int Bot1;
          int Bot2;
          int Bot3;
          int Dvd;
          int Vmyop;
          Pp = P;
          Typep = Type;
          Jj = J;
          Ptypep = Ptype;
          Precp = Prec;
          Soldi = Oldi;
          if (Type <= 2)
            Elsize = Bytes[Precp];
          else
            Elsize = Acc;
          Dvd = Sndisp;
          Arrname = Fromar2(P);
          Naminf = Tags[Arrname];
          if (Arr == 3) Fault(29, Arrname);
          if (Arrp > 2) {
            Naminf = -2;
            Dvd = 0;
          }
          Testapp(Q);
          if (!Jj) {
            Replace1(Tcell, From1(Tcell) | Q);
            Jj = Q;
          }
          if (Jj == Q && Q != 0) {
            Nops = 0;
            Head1 = 0;
            Head2 = 0;
            Head3 = 0;
            Bot1 = 0;
            Bot3 = 0;
            P = Pp + 3;
            for (Kk = 1; Kk <= Jj; Kk++) {
              P += 3;
              Bot2 = 0;
              Torp(Head2, Bot2, Nops);
              P++;
              Nops = (Nops + 1) | 1 << 24;
              Push(Head3, 33, Ptypep << 16 | Arrname, Elsize);
              if (!Bot3) Bot3 = Head3;
              Vmyop = Kk << 24 | Jj << 16 | Dvd;
              Push(Head3, 1 << 16, Vmyop, Bs << 18 | Dp);
              if (!Head1)
                Head1 = Head2;
              else
                Aslist[Bot1].Link = Head2;
              Bot1 = Bot2;
              Head2 = 0;
            }
            Aslist[Bot1].Link = Head3;
            Bot1 = Bot3;
            Expop(Head1, Breg, Nops, 0x251);
            Aslist[Bot1].Link = Asl;
            Asl = Head1;
            Base = Bs;
            Disp = Dp;
            Access = 3;
            Area = -1;
            if (Expopnd.Flag <= 1) {
              Nummod = Expopnd.D;
              if (Nummod < 0)
                Getinacc(Breg, 1, 0, 0, Nummod);
              else
                Access = 1;
            }
          } else {
            if (Jj > Q)
              Fault2(20, Jj - Q, Arrname);
            else
              Fault2(21, Q - Jj, Arrname);
            P += 2;
            Skipapp();
            Base = Bs;
            Disp = 0;
            Access = 3;
            Area = -1;
          }
          Acc = Elsize;
          Ptype = Ptypep;
          Unpack();
          J = Jj;
          Oldi = Soldi;
        }
        void Cname(int Z, int Reg) {
          int Jj;
          int Jjj;
          int Kk;
          int Rr;
          int Levelp;
          int Dispp;
          int Namep;
          int Pp;
          int Savesl;
          int Fname;
          static int S_sw;
          static void *S[2 /*12:13*/] = {
              &&S_12,
              &&S_default,
          };
          static int Funny_sw;
          static void *Funny[2 /*12:13*/] = {
              &&Funny_12,
              &&Funny_13,
          };
          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_default,
          };
          static int Map_sw;
          static void *Map[4 /*0:3*/] = {
              &&Map_0,
              &&Map_1,
              &&Map_2,
              &&Map_3,
          };
          Pp = P;
          Fname = (A[P] << 8) + A[P + 1];
          if (Z == 1 || Z == 6) Stname = Fname;
          Copytag(Fname);
          if (I == -1) {
            Fault(16, Fname);
            I = Rlevel;
            J = 0;
            K = Fname;
            Kform = 0;
            Sndisp = 0;
            Acc = 4;
            Ptype = 7;
            Storetag(K, N);
            K = N;
            N += 4;
            Copytag(Fname);
          }
          Savesl = Acc;
          Jj = J;
          if (Jj == 15) Jj = 0;
          Namep = Fname;
          Levelp = I;
          Dispp = K;
          if (Litl == 1 && Rout == 0 && 0 == Nam && (Z == 1 || Z == 3 || (Z == 4 && Type < 5 && Arr == 0)))
            Fault(29, Fname);
          if (Type == 7) goto Notset;
          if ((Z == 0 && (Rout != 1 || 0 != Type && Type != 6)) || (Z == 13 && Rout == 0)) {
            Fault2(27, 0, Fname);
            goto Notset;
          }
          if (Z >= 10) goto *Funny[Funny_sw = (Z)-12];
          if (Rout == 1) goto Rtcall;
          goto *Sw[Sw_sw = Type];
        Sw_6:;
        Sw_4:;
          Fault2(5, 0, Fname);
        Sw_7:;
        Notset:;
          Nest = 0;
          Base = I;
          Disp = K;
          Access = 0;
          Area = Lnb;
          Ptype = 1;
          Unpack();
          P += 2;
          Skipapp();
          goto Chken;
        Funny_12:;
          if (Type == 3 && (Arr == 0 || A[P + 2] == 1)) goto *Sw[Sw_sw = 3];
          if (Ptype == Snpt) {
            Csname(12, Reg);
            goto Chken;
          }
          if (A[P + 2] == 2)
            P += 3;
          else
            Noapp();
          Access = 0;
          Base = I;
          Disp = K;
          Area = -1;
        Adjusthead:;
          if (Arr == 1 && 1 == J && Parmarr == 0 && 0 == Nam && Parmchk == 0 && Type <= 3) {
            Getwsp(Jj, 4);
            Getinacc(Accr, 4, Access, Areacode(), Disp);
            Psf1(St, 1, Jj);
            Getinacc(Breg, 1, 2, Lnb, Jj + 8);
            if (Type == 3)
              Kk = Acc;
            else
              Kk = Bytes[Prec];
            if (Kk != 1) Psf1(Myb, 0, Kk);
            Psf1(Ld, 1, Jj);
            Pf1(Inca, 0, Breg, 0);
            Psf1(Std, 1, Jj);
            Gruse[Dr] = 0;
            Gruse[Accr] = 0;
            Gruse[Breg] = 0;
            Area = Lnb;
            Disp = Jj;
          }
          goto Chken;
        S_12:;
          Nameop(1, Accr, 16, Namep);
          goto Adjusthead;
        Funny_13:;
          if (Ptype == Snpt) {
            Csname(Z, Reg);
            P++;
            goto Chken;
          }
          Disp = Midcell;
          Base = I;
          if (Nam & 1) {
            Area = -1;
            Getinacc(Reg, 4, 0, Areacode(), Disp);
          } else {
            if (J == 14) {
              Getinacc(Reg, 2, 0, 0, 0);
              Getinacc(Dr, 2, 0, Setxorynb(-1, -1), Disp);
            } else if (Base == 0 && Cprmode == 2) {
              Psf1(Ld, 1, 12);
              if (Disp) Psf1(Inca, 0, Disp);
              Getinacc(Accr, 2, 0, 0, 0);
            } else {
              Psf1(Jlk, 0, 1);
              Rtjump(Lda, Aslist[Tags[Fname]].S2);
              Pf1(Inca, 0, Tos, 0);
              Jj = 0xE0000001;
              Storeconst(Jjj, 4, Addr(Jj));
              Pf1(Ldtb, 0, Pc, Jjj);
              Getinacc(Accr, 1, 0, Lnb, Ptroffset(Base));
              Jj = 'IMP';
              Storeconst(Jjj, 4, Addr(Jj));
              Pf1(Luh, 0, Pc, Jjj);
            }
            Pf1(Std, 0, Tos, 0);
            Pf1(Luh, 0, Tos, 0);
            Gruse[Dr] = 0;
          }
          if (A[P + 2] == 2)
            P += 3;
          else
            Noapp();
          goto Chken;
        Sw_3:;
          Crname(Z, Reg, 2 * Nam, I, -1, K, Namep);
          if (Z >= 10) goto *S[S_sw = (Z)-12];
          if (Z == 1 || Z == 6) Stname = Namep;
          if (Type == 5 && Z != 6) goto Strinrec;
          if (Type == 7) goto Notset;
          Nameop(Z, Reg, Bytes[Prec], Namep);
          goto Chken;
        Sw_5:;
          if (Z == 6) goto *Sw[Sw_sw = 1];
          if (Arr >= 1) goto Strarr;
          if (A[P + 2] == 2)
            P += 3;
          else
            Noapp();
          Base = I;
          Access = 2;
          Area = -1;
          Disp = K;
        Sninrec:
          if (Z == 1) Z = 3;
          if (Z == 3 || Z == 4) {
            Nameop(Z, Reg, 8, -1);
            goto Chken;
          }
          if (Access == 2 && Parmchk == 0 && Register[Dr] == 0) {
            Psorlf1(Ldb, 2, Areacode(), Disp);
            Gruse[Dr] = 0;
            if (!Reg) Copydr();
            goto Chken;
          }
          Nameop(3, Dr, 8, -1);
        Mbnd:
          if (Parmchk == 1) Testass(Dr, 5, 8);
          Pf1(Ldb, 2, 7, 0);
          if (!Reg) Copydr();
          goto Chken;
        Strarr:;
          Caname(Arr, I, K);
          Namep = -1;
          if (Z == 1 || Z == 6) Stname = Namep;
        Sainrec:;
          if (Z == 1 || Z == 3) {
            if (Nam == 1) {
              Getinacc(Dr, 2, 0, Areacode(), Disp + 8);
              Pf1(Slb, 1, 0, 1 + 3 * (J - 1));
            }
            if (Area != 7) Getinacc(Dr, 2, 0, Areacode(), Disp);
            if (Nam == 1) {
              Pf1(Modd, 0, Tos, 0);
              Pf1(Ldb, 0, Breg, 0);
            } else {
              if (Access == 1) {
                if (Nummod) Psf1(Modd, 0, Nummod);
              } else if (Access == 3)
                Pf1(Modd, 0, Breg, 0);
              Psf1(Ldb, 0, Acc);
            }
            if (!Reg) Copydr();
            goto Chken;
          }
          if (Z == 4) {
            Nameop(Z, Reg, 4, -1);
            goto Chken;
          }
          if (Area != 7) Getinacc(Dr, 2, 0, Areacode(), Disp);
          if (Access == 1) {
            if (Nummod) Psf1(Modd, 0, Nummod);
          } else if (Access == 3)
            Pf1(Modd, 0, Breg, 0);
          goto Mbnd;
        Strinrec:;
          if (Arr) goto Sainrec;
          if (Nam != 0 || Z == 4) goto Sninrec;
          Nameop(4, Breg, 4, -1);
          Pf1(Ldtb, 0, Pc, Paramdes(3));
          Pf1(Lda, 0, Breg, 0);
          if (Z != 2 || Parmchk != 0) Psf1(Ldb, 0, Acc);
          Gruse[Dr] = 0;
          if (Z == 2) goto Mbnd;
          if (!Reg) Copydr();
          goto Chken;
        Rtcall:;
          if (Type == 0 && Z != 0) {
            Fault(23, Fname);
            goto Notset;
          }
          if (Ptype == Snpt) {
            Csname(Z, Reg);
            if (Rout == 1 && Nam >= 1 && Z != 0) goto Bim;
            if (Type != 0 && Nest == Accr) goto Mvfnres;
            goto Chken;
          }
          Crcall(Fname);
          P++;
          if (!(Ptype & 15)) goto Chken;
          if (Nam > 1) goto Udm;
          if (Z != 2 && Z != 5) {
            Fault(29, Fname);
            Base = 0;
            Access = 0;
            Disp = 0;
          }
        Mvfnres:
          if (Type == 5) {
            if (Reg == Dr) {
              Pf1(St, 0, Tos, 0);
              Pf1(Ld, 0, Tos, 0);
            }
          } else if (Reg == Breg) {
            if (Register[Breg]) Bootout(Breg);
            Pf1(St, 0, Breg, 0);
          }
          Nest = Reg;
          goto Chken;
        Udm:;
          Pf1(St, 0, Breg, 0);
          Disp = Mapdes(Prec);
          Access = 3;
          Area = Pc;
          Namep = -1;
          Stname = -1;
        Bim:;
          if (Area != Pc || Access != 3) {
            Namep = -1;
            Stname = -1;
          }
          if (Type == 3) goto Chken;
          if (Z == 3 || (Type == 5 && Z != 4)) {
            Pf1(Ldtb, 0, Pc, Disp);
            if (Type == 5 && (Parmchk != 0 || Z != 2)) Psf1(Ldb, 0, 255);
            Pf1(Lda, 0, Breg, 0);
            Gruse[Dr] = 0;
          } else {
            if (Gruse[Dr] == 7 && Namep > 0 && Grinf1[Dr] == (Namep & 0xFFFF) && 1 <= Z && Z <= 2) Area = 7;
          }
          Kk = Z;
          if (Z == 5) Kk = 2;
          goto *Map[Map_sw = Kk & 3];
        Map_0:;
          if (Reg != Breg) Getinacc(Accr, 1, 0, Breg, 0);
          goto Chken;
        Map_1:;
          if (Type != 5) goto Chken;
          goto *Map[Map_sw = 3];
        Map_2:;
          if (Type == 5) goto Mbnd;
          Getinacc(Reg, (unsigned)Bytes[Prec] >> 2, Access, Area, Disp);
          if (Namep > 0) {
            Gruse[Dr] = 7;
            Grinf1[Dr] = Namep;
          }
          if (Parmchk == 1 && Prec >= 5) Testass(Reg, 1, Bytes[Prec]);
          goto Chken;
        Map_3:;
          if (Type == 5) Pf1(Ldb, 0, 0, 256);
          if (Reg != Dr) Copydr();
          goto Chken;
        Sw_0:;
          if (3 > Z || Z > 4) {
            Fault2(90, 0, Fname);
            Type = 1;
          }
        Sw_1:;
        Sw_2:;
          if (Arr == 0 || (Z == 6 && A[P + 2] == 2)) {
            Base = I;
            Access = 2 * Nam;
            Disp = K;
            Area = -1;
            if (A[P + 2] == 2)
              P += 3;
            else
              Noapp();
          } else {
            Caname(Arr, I, K);
            Nam = 0;
          }
          Nameop(Z, Reg, Bytes[Prec], Namep);
          goto Chken;
        Chken:
          while (A[P] == 1) {
            Fault(69, Fname);
            P += 3;
            Skipapp();
          }
          P++;
          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:;
          goto S_skip;
        S_default:
          fprintf(stderr, "\nSwitch label 'S(%d):' not set in %s\n", S_sw + 12, __PRETTY_FUNCTION__);
          fflush(stderr);
          abort();
        S_skip:;
        }
        void Nameop(int Z, int Reg, int Size, int Namep) {
          static int Mod_sw;
          static void *Mod[48 /*0:47*/] = {
              &&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, &&Mod_32, &&Mod_33, &&Mod_34, &&Mod_35, &&Mod_36, &&Mod_37, &&Mod_38, &&Mod_39,
              &&Mod_40, &&Mod_41, &&Mod_42, &&Mod_43, &&Mod_44, &&Mod_45, &&Mod_46, &&Mod_47,
          };
          auto int Basereg(int Gruseval, int Grinfval);
          int Kk;
          int Jjj;
          int Tother;
          int Xynb;
          int Jj;
          int Op1;
          int Op2;
          Kk = Z;
          if (Z == 5) Kk = 2;
          if (Z == 6) {
            if (Nam != 1 || Rout != 0 || (Access < 8 && Access != 2)) Fault2(82, 0, Namep);
            Kk = 1;
            Size = 8;
            if (Access >= 8)
              Access -= 4;
            else
              Access = 0;
          }
          Kk = Kk & 3;
          goto *Mod[Mod_sw = Access << 2 | Kk];
        Mod_0:;
          if (Type == 3) {
            Getinacc(Reg, 1, 0, Areacode(), Disp - 4);
            return;
          }
          Getinacc(Reg, 1, 0, Lnb, Ptroffset(Base));
          if (Reg == Breg)
            Jjj = Adb;
          else
            Jjj = Iad;
          Psf1(Jjj, 0, Disp);
          if (Bimstr == 1) Noteassment(Reg, 3, Namep);
          return;
        Mod_1:;
          if (1 <= Size && Size <= 2) {
            if (Gruse[Dr] != Size + 11) Pf1(Ldtb, 0, Pc, Mapdes(Size + 2));
            if (12 > Gruse[Dr] || Gruse[Dr] > 13 || Grinf1[Dr] != Base) Psf1(Lda, 1, Ptroffset(Base));
            Gruse[Dr] = Size + 11;
            Grinf1[Dr] = Base;
            Access = 1;
            Area = 0;
          } else
            Area = Areacode();
          return;
        Mod_2:;
          if (Size > 2 && Z == 5 && Parmchk == 0) {
            Nest = -1;
            return;
          }
        Mod_10:;
          if (Gruse[Reg] >= 9 && Namep > 0)
            if ((Grinf1[Reg] == Namep && (Gruse[Reg] & 255) == 9) ||
                (Grinf2[Reg] == Namep && (unsigned)Gruse[Reg] >> 16 == 9)) {
              if (Register[Reg]) Bootout(Reg);
              Nest = Reg;
              return;
            }
          Tother = Reg ^ 7;
          if (Gruse[Tother] >= 9 && Namep > 0) {
            Kk = Grinf1[Tother];
            if ((Kk == Namep && (Gruse[Tother] & 255) == 9) ||
                (Grinf2[Tother] == Namep && (unsigned)Gruse[Tother] >> 16 == 9)) {
              if (Reg == Breg && Register[Breg] == 0) {
                Pf1(St, 0, Breg, 0);
                Gruse[Reg] = Gruse[Tother];
                Grinf1[Reg] = Grinf1[Tother];
                Grinf2[Reg] = Grinf2[Tother];
                Nest = Reg;
                return;
              }
              if (Reg == Accr && Z == 2) {
                Access = 0;
                Area = 7;
                Size = 4;
                Disp = 0;
              }
            }
          }
          if (1 <= Size && Size <= 2 && Access == 0) {
            if (Gruse[Dr] != Size + 11) Pf1(Ldtb, 0, Pc, Mapdes(Size + 2));
            if (12 > Gruse[Dr] || Gruse[Dr] > 13 || Grinf1[Dr] != Base) Psf1(Lda, 1, Ptroffset(Base));
            Gruse[Dr] = Size + 11;
            Grinf1[Dr] = Base;
            if (Z == 5 && Parmchk == 0) {
              Access = 1;
              Area = 0;
              Nest = -1;
              return;
            }
            Getinacc(Reg, 1, 1, 0, Disp);
            if (Parmchk != 0 && Size == 2) Testass(Reg, Type, Size);
            Nest = Reg;
            return;
          }
        Mod_14:;
          if (Access >= 2 && (Area == 7 || (Gruse[Dr] == 7 && Namep > 0 && Grinf1[Dr] == (Namep & 0xFFFF)))) {
            Area = 7;
            Disp = 0;
          } else
            Area = Areacode();
        Drfetch:;
          Getinacc(Reg, (unsigned)Size >> 2, Access, Area, Disp);
          if (Parmchk == 1 && Size != 1) Testass(Reg, Type, Size);
          if ((Access == 0 || Access == 2) && Namep > 0) {
            Gruse[Reg] = 9;
            Grinf1[Reg] = Namep;
          }
          if (Access >= 2 && Namep > 0) {
            Gruse[Dr] = 7;
            Grinf1[Dr] = Namep & 0xFFFF;
          }
          Nest = Reg;
          return;
        Mod_3:;
          if (Reg != Accr && Reg != Dr) Abort();
          if (Type == 3) {
            Getinacc(Reg, 2, 0, Areacode(), Disp - 8);
            return;
          } else
            Jjj = Paramdes(Prec);
          if (!Reg) {
            Getinacc(Reg, 1, 0, Lnb, Ptroffset(Base));
            Op1 = Iad;
            Op2 = Luh;
          } else {
            Psf1(Lda, 1, Ptroffset(Base));
            Op1 = Inca;
            Op2 = Ldtb;
          }
          Psf1(Op1, 0, Disp);
          Pf1(Op2, 0, Pc, Jjj);
          Gruse[Reg] = 0;
          return;
        Mod_4:;
          Jj = Nummod;
          if (Prec > 4) Jj = Jj * Bytes[Prec];
          goto Md20;
        Mod_20:;
          Jj = Nummod + Xdisp;
        Md20:
          Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
          if (!Reg)
            Op1 = Iad;
          else
            Op1 = Adb;
          if (Jj) Psf1(Op1, 0, Jj);
          return;
        Mod_7:;
          Jj = Nummod;
          if (Prec > 4) Jj = Jj * Bytes[Prec];
          Getinacc(Reg, 2, 0, Areacode(), Disp);
          if (!Reg)
            Op1 = Iad;
          else
            Op1 = Inca;
          if (Jj) Psf1(Op1, 0, Jj);
          return;
        Mod_5:;
        Mod_6:;
          if (!Nummod) {
            Access = 2;
            goto *Mod[Mod_sw = Kk + 8];
          }
          if (Gruse[Dr] != 7 || Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF)) Getinacc(Dr, 2, 0, Areacode(), Disp);
          if (Namep > 0) {
            Gruse[Dr] = 7;
            Grinf1[Dr] = Namep & 0xFFFF;
          }
          Area = 0;
          Disp = Nummod;
          if (Z == 2) goto Drfetch;
          return;
        Mod_12:;
          Jjj = Bytes[Prec];
          if (Jjj != 1 && Prec != 4) {
            Psf1(Myb, 0, Jjj);
            Gruse[Breg] = 0;
          }
        Md12:
          if (Reg == Breg) {
            if (Area == 7) {
              Pf1(Inca, 0, Breg, 0);
              Gruse[Dr] = 0;
              Pf1(Lb, 2, 0, 11);
            } else
              Pf1(Adb, 0, Areacode(), Disp + 4);
            Gruse[Breg] = 0;
            return;
          }
        Mod_8:;
          if (Area == 7)
            Getinacc(Reg, 1, 2, 0, 11);
          else
            Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
          if ((Access & 3) == 3) Pf1(Iad, 0, Breg, 0);
          return;
        Mod_9:;
        Mod_13:;
          if (Area == 7) {
            Disp = 0;
            return;
          }
          if (Gruse[Dr] == 7 && Namep > 0 && Grinf1[Dr] == (Namep & 0xFFFF)) {
            Area = 7;
            Disp = 0;
          } else
            Area = Areacode();
          return;
        Mod_11:;
          if (Area == 7) {
            if (Reg != Dr) Copydr();
            return;
          }
          Getinacc(Reg, 2, 0, Areacode(), Disp);
          return;
        Mod_15:;
          if (Area != 7) Getinacc(Dr, 2, 0, Areacode(), Disp);
          if (Prec == 4 || (Type == 3 && Parmarr == 0))
            Jj = Inca;
          else
            Jj = Modd;
          Pf1(Jj, 0, Breg, 0);
          if (Reg != Dr) Copydr();
          Gruse[Dr] = 0;
          return;
        Mod_17:;
        Mod_18:;
          if (Size == 1) {
            Disp -= 8;
            goto Md2526;
          }
          Disp += Xdisp;
          Access = 0;
          goto *Mod[Mod_sw = Kk];
        Mod_36:;
        Mod_37:;
        Mod_38:;
        Mod_39:;
          Xynb = Basereg(8, Namep & 0xFFFF);
          Disp = Nummod + Xdisp;
          Area = Xynb;
          Access = 3;
          Namep = 0;
          goto *Mod[Mod_sw = Kk + 8];
        Mod_16:;
          Disp -= 8;
        Mod_24:;
          Getinacc(Reg, 1, 0, Areacode(), Disp + 4);
          if (Reg == Breg)
            Kk = Adb;
          else
            Kk = Iad;
          if (Xdisp) Psf1(Kk, 0, Xdisp);
          return;
        Md2526:;
        Mod_25:;
        Mod_26:;
          if (Size > 2) {
            Xynb = Basereg(8, Namep & 0xFFFF);
            Area = Xynb;
            Access = 0;
            Disp = Xdisp;
            goto *Mod[Mod_sw = Kk];
          }
          if (Size == 1) {
            if (Gruse[Dr] != 7 || Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF)) Psorlf1(Ld, 0, Areacode(), Disp);
          } else {
            if (Gruse[Dr] != 13 && Gruse[Dr] != 15) Pf1(Ldtb, 0, Pc, Mapdes(4));
            if (Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF) || (Gruse[Dr] != 7 && Gruse[Dr] != 15))
              Psorlf1(Lda, 0, Areacode(), Disp + 4);
          }
          Gruse[Dr] = 0;
          if (Namep > 0) {
            Gruse[Dr] = 8 * Size - 1;
            Grinf1[Dr] = Namep & 0xFFFF;
          }
          Access = 1;
          Area = 0;
          Disp = Xdisp;
          if (Disp == 0 && Access == 1) {
            Area = 7;
            Access = 2;
          }
          if (Z == 2) goto Drfetch;
          return;
        Mod_23:;
          Xdisp += Nummod;
          goto Md31;
        Mod_19:;
          Disp -= 8;
        Mod_27:;
        Mod_31:;
        Md31:
          Getinacc(Dr, 2, 0, Areacode(), Disp);
          if (Xdisp) Psf1(Inca, 0, Xdisp);
          if (Access == 7) Pf1(Inca, 0, Breg, 0);
          if (Type == 3 || Type == 5)
            Psorlf1(Ldb, 0, 0, Acc);
          else
            Pf1(Ldtb, 0, Pc, Paramdes(Prec));
          if (Reg != Dr) Copydr();
          return;
        Mod_28:;
          if (Xdisp) {
            Psf1(Adb, 0, Xdisp);
            Gruse[Breg] = 0;
          }
          Access = 3;
          goto Md12;
        Mod_29:;
        Mod_30:;
        Mod_21:;
        Mod_22:;
          if (1 <= Size && Size <= 2) {
            if (Size == 1) {
              if (Gruse[Dr] != 7 || Namep <= 0 || Grinf1[Dr] != (Namep & 0xFFFF)) Psorlf1(Ld, 0, Areacode(), Disp);
            } else {
              if (Namep < 0 || Grinf1[Dr] != (Namep & 0xFFFF) || (Gruse[Dr] != 7 && Gruse[Dr] != 15))
                Psorlf1(Lda, 0, Areacode(), Disp + 4);
              if (Gruse[Dr] != 13 && Gruse[Dr] != 15) Pf1(Ldtb, 0, Pc, Mapdes(4));
            }
            Gruse[Dr] = 0;
            if (Namep > 0) {
              Gruse[Dr] = 8 * Size - 1;
              Grinf1[Dr] = Namep & 0xFFFF;
            }
            if (Access == 7) {
              if (Xdisp) Psf1(Adb, 0, Xdisp);
              Access = 3;
              Area = 7;
              Disp = 0;
              Gruse[Breg] = 0;
            } else {
              Disp = Xdisp + Nummod;
              Access = 1;
              Area = 0;
            }
            Namep = 0;
            if (Z == 2) goto Drfetch;
            return;
          }
          if (Access == 7) {
            Psorlf1(Adb, 0, Areacode(), Disp + 4);
            Gruse[Breg] = 0;
            Xynb = Xorynb(0, 0);
            Pf1(Ldcode[Xynb], 0, Breg, 0);
            Gruse[Xynb] = 0;
            Disp = Xdisp;
          } else {
            Xynb = Basereg(8, Namep & 0xFFFF);
            Disp = Nummod + Xdisp;
          }
          Area = Xynb;
          Access = 0;
          Namep = 0;
          goto *Mod[Mod_sw = Kk];
        Mod_32:;
        Mod_33:;
        Mod_34:;
        Mod_35:;
          Disp += Xdisp;
          Namep = 0;
          Access = 2;
          goto *Mod[Mod_sw = Kk + 8];
        Mod_40:;
        Mod_41:;
        Mod_42:;
        Mod_43:;
          Xynb = Basereg(8, Namep & 0xFFFF);
          Area = Xynb;
          Access = 2;
          Disp = Xdisp;
          Namep = 0;
          goto *Mod[Mod_sw = Kk + 8];
        Mod_44:;
        Mod_45:;
        Mod_46:;
        Mod_47:;
          Psorlf1(Adb, 0, Areacode(), Disp + 4);
          Gruse[Breg] = 0;
          Xynb = Xorynb(0, 0);
          Pf1(Ldcode[Xynb], 0, Breg, 0);
          Gruse[Xynb] = 0;
          Namep = 0;
          Area = Xynb;
          Access = 2;
          Disp = Xdisp;
          goto *Mod[Mod_sw = Kk + 8];
          int Basereg(int Gruseval, int Grinfval) {
            int Xynb;
            if (Namep <= 0) {
              Gruseval = 0;
              Grinfval = 0;
            }
            Xynb = Xorynb(Gruseval, Grinfval);
            if (Gruse[Xynb] != Gruseval || Gruseval <= 0 || Grinf1[Xynb] != Grinfval)
              Psorlf1(Ldcode[Xynb], 0, Areacode(), Disp + 4);
            Gruse[Xynb] = Gruseval;
            Grinf1[Xynb] = Grinfval;
            Grat[Xynb] = Ca;
            return (Xynb);
          }
        }
        void Crcall(int Rtname) {
          static int Fpd_sw;
          static void *Fpd[4 /*0:3*/] = {
              &&Fpd_0,
              &&Fpd_1,
              &&Fpd_2,
              &&Fpd_3,
          };
          int Ii;
          int Iii;
          int Qqq;
          int Dlink;
          int Jj;
          int Jjj;
          int Nparms;
          int Pt;
          int Lp;
          int Psize;
          int Twsp;
          int Fptr;
          int Typep;
          int Precp;
          int Namp;
          int Tl;
          int Moveptr;
          int Clink;
          int Rdisp;
          Listf *Lcell;
          Pt = Ptype;
          Jjj = J;
          Tl = Oldi;
          Twsp = 0;
          Lp = I;
          Clink = K;
          Typep = Type;
          Precp = Prec;
          Namp = Nam;
          Rdisp = Midcell;
          Testapp(Nparms);
          P += 2;
          if (Kform != Nparms) {
            Fault(19, Rtname);
            Skipapp();
            P--;
            return;
          }
          Saveirs();
          Psf1(Prcl, 0, 4);
          Fptr = 20;
          goto Firstparm;
        Nextparm:
          Clink = Lcell->Link;
        Firstparm:
          if (!Clink) goto Entryseq;
          Lcell = &Aslist[Clink];
          Psize = (unsigned)Lcell->S2 >> 16;
          P++;
          Ptype = (unsigned)Lcell->S1 >> 16;
          Unpack();
          Ii = Type;
          Iii = Prec;
          Jj = (Nam << 1 | Arr) & 3;
          if ((Jj != 0 || Rout != 0) && (A[P + 3] != 4 || A[P + 4] != 1 || A[P + Fromar2(P + 1) + 1] != 2)) {
            Fault(22, 0);
            Skipexp();
            goto Nextparm;
          }
          if (Rout == 1) {
            Ii = Ptype;
            P += 5;
            Cname(13, Accr);
            if ((Ii & 255) != (Ptype & 255)) Fault(22, 0);
            P++;
            Moveptr = 16;
            goto Stuff;
          }
          goto *Fpd[Fpd_sw = Jj];
        Fpd_0:;
          if (Type == 5) {
            Cstrexp(17, Dr);
            Psf1(Ldb, 0, Psize);
            if (Register[Accr] == 3) {
              Pf1(St, 0, Tos, 0);
              Register[Accr] = 0;
            }
            Pf1(Std, 0, Tos, 0);
            Push(Twsp, Value, 268, 0);
            Fptr += 8;
            goto Nextparm;
          } else {
            if (Prec == 6)
              Jj = 3;
            else
              Jj = Type;
            Csexp(Accr, Iii << 4 | Ii);
            Moveptr = ((Bytes[Iii] + 3) & (-4));
          }
          goto Stuff;
        Fpd_2:;
          P += 5;
          Fname = Fromar2(P);
          Copytag(Fname);
          if (Ii != 0 || Type == 0) {
            Cname(3, Accr);
            if (Ii != Type || Iii != Prec) Fault(22, Fname);
          } else {
            Cname(4, Accr);
            if (Type <= 2)
              Jj = Prec << 27 | Type;
            else
              Jj = (0x1A << 24) + Acc;
            Storeconst(Iii, 4, Addr(Jj));
            Pf1(Luh, 0, Pc, Iii);
          }
          P++;
          Moveptr = 8;
          goto Stuff;
        Fpd_1:
        Fpd_3:;
          P += 5;
          Cname(12, Accr);
          Getinacc(Accr, 4, 0, Areacode(), Disp);
          P++;
          Moveptr = 16;
          if (1 > Arr || Arr > 2 || Ii != Type || Iii != Prec) {
            Fault(22, 0);
            goto Stuff;
          }
          Qqq = From1(Tcell) & 15;
          Jj = Lcell->S1 & 15;
          if (!Jj) {
            Jj = Qqq;
            Lcell->S1 = Lcell->S1 | Jj;
          }
          if (!Qqq) {
            Qqq = Jj;
            Replace1(Tcell, From1(Tcell) | Jj);
          }
          if (Jj != Qqq) Fault(22, 0);
        Stuff:
          Register[Accr] = 3;
          Fptr += Moveptr;
          goto Nextparm;
        Entryseq:;
          if (Register[Accr] == 3) {
            Pf1(St, 0, Tos, 0);
            Register[Accr] = 0;
          }
          J = Jjj;
          while (Twsp) {
            Pop(Twsp, Qqq, Jj, Iii);
            Returnwsp(Qqq, 268);
          }
          if (Typep == 5 && Namp <= 1) {
            Getwsp(Qqq, 268);
            Strfnres = Qqq;
            Iii = 0x18000100;
            Qqq += 8;
            Storeconst(Jj, 8, Addr(Iii));
            Pf1(Ld, 0, Pc, Jj);
            Psf1(Inca, 1, Ptroffset(Rbase));
            Pf1(Std, 0, Tos, 0);
            Fptr += 8;
          }
          if (Jjj == 14) {
            Nmdecs[Level] = Nmdecs[Level] | 2;
            Ii = Setxorynb(-1, -1);
            Psf1(Raln, 0, (unsigned)Fptr >> 2);
            Pf1(Call, 2, Ii, Rdisp);
          } else if (!(Namp & 1))
            if (!Lp) {
              Psf1(Ld, 1, 12);
              if (Rdisp) Psf1(Inca, 0, Rdisp);
              Psf1(Raln, 0, (unsigned)Fptr >> 2);
              Pf1(Call, 2, 7, 0);
            } else {
              Ii = Setxorynb(Xnb, Lp);
              Psf1(Raln, 0, (unsigned)Fptr >> 2);
              Rtjump(Call, Aslist[Tags[Rtname]].S2);
            }
          else {
            Area = -1;
            Base = Lp;
            Area = Areacode();
            Getinacc(Dr, 2, 0, Area, Rdisp);
            Psorlf1(Lxn, 0, Area, Rdisp + 12);
            Psf1(Raln, 0, (unsigned)Fptr >> 2);
            Pf1(Call, 2, 7, 0);
          }
          Forget(-1);
          Rout = 1;
          Type = Typep;
          Nam = Namp;
          Prec = Precp;
          Ptype = Pt;
        }
        void Rtjump(int Code, int *Link) {
          int Dp;
          if (J == 15) {
            Push(*Link, Code << 24 | 3 << 23, Ca, 0);
            Pf1(Code, 0, 0, 0);
          } else {
            Dp = *Link - Ca;
            if (Code == Call) Dp = Dp / 2;
            Psf1(Code, 0, Dp);
          }
        }
        int Tsexp(int *Value) {
          static int Sw_sw;
          static void *Sw[3 /*1:3*/] = {
              &&Sw_1,
              &&Sw_2,
              &&Sw_3,
          };
          int Pp;
          int Rexp;
          int Kk;
          int Sign;
          int Ct;
          Type = 1;
          Pp = P;
          Rexp = 2 - A[P + 1 + Fromar2(P + 1)];
          P += 3;
          Sign = A[P];
          if (Sign != 4 && A[P + 1] != 2) goto Typed;
          goto *Sw[Sw_sw = (A[P + 1]) - 1];
        Sw_1:;
          P += 2;
          Reducetag();
          goto Typed;
        Sw_2:;
          Ct = A[P + 2];
          Type = Ct & 7;
          if (Ct != 0x41 || Sign == 3) goto Typed;
          Kk = Fromar2(P + 3);
          if (Rexp != 0 && A[P + 6] == Concop) {
            Type = 5;
            goto Typed;
          }
          if (Rexp != 0 || 0 > Kk || Kk > 255) goto Typed;
          *Value = Kk;
          P += 6;
          if (Sign != 2) return (1);
          *Value = -*Value;
          return (-1);
        Sw_3:;
        Typed:
          P = Pp;
          return (0);
        }
        void Skipexp(void) {
          int Optype;
          int Pin;
          int J;
          Pin = P;
          P += 3;
          for (;;) {
            Optype = A[P + 1];
            P += 2;
            if (Optype == 0 || Optype > 3) Abort();
            if (Optype == 3) Skipexp();
            if (Optype == 2) {
              J = A[P] & 7;
              if (J == 5)
                P = P + A[P + 5] + 6;
              else
                P = P + 1 + Bytes[(unsigned)A[P] >> 4];
            }
            if (Optype == 1) {
              P--;
              do {
                P += 3;
                Skipapp();
              } while (A[P] != 2);
              P++;
            }
            P++;
            if (A[P - 1] == 2) break;
          }
        }
        void Skipapp(void) {
          int Pin;
          Pin = P;
          while (A[P] == 1) {
            P++;
            Skipexp();
          }
          P++;
        }
        void Noapp(void) {
          P += 2;
          if (A[P] == 1) {
            Fault2(17, 0, Fromar2(P - 2));
            Skipapp();
          } else
            P++;
        }
        void Testapp(int *Num) {
          int Pp;
          int Q;
          Q = 0;
          Pp = P;
          P += 2;
          while (A[P] == 1) {
            P++;
            Q++;
            Skipexp();
          }
          P = Pp;
          *Num = Q;
        }
        void Testass(int Reg, int Type, int Size) {
          int Opcode;
          int A;
          int D;
          if (Type == 5) {
            if (Reg != Dr) return;
            Pf1(Std, 0, Tos, 0);
            Pf2(Sweq, 1, 1, 0, 0, Unasspat & 255);
          } else {
            if (Reg == Breg)
              Opcode = Cpb;
            else
              Opcode = Ucp;
            if (Size == 16) Pf1(Stuh, 0, Tos, 0);
            if (Size == 2) {
              A = 0;
              D = (unsigned)Unasspat >> 16;
            } else {
              A = Pc;
              D = Plabs[1];
            }
            Pf1(Opcode, 0, A, D);
            if (Size == 16) Pf1(Luh, 0, Tos, 0);
          }
          Ppj(8, 5);
          if (Type == 5) Pf1(Ld, 0, Tos, 0);
        }
        void Getwsp(int *Place, int Size) {
          int J;
          int K;
          int L;
          if (Size > 4) Size = 0;
          Pop(Avlwsp[Size][Level], J, K, L);
          if (K <= 0) {
            if (Size > 1) Oddalign();
            K = N;
            if (!Size)
              N += 268;
            else
              N += Size << 2;
          }
          *Place = K;
          if (Size) Push(Twsphead, K, Size, 0);
        }
        void Returnwsp(int Place, int Size) {
          if (Size > 4) Size = 0;
          if (Place < 511)
            Push(Avlwsp[Size][Level], 0, Place, 0);
          else
            Insertatend(Avlwsp[Size][Level], 0, Place, 0);
        }
        void Setline(void) {
          int Xynb;
          int I;
          int Ldi;
          int Sti;
          int Reg;
          Ldi = Lss;
          Sti = St;
          Reg = Accr;
          if ((Parmdbug | Parmprof) == 0 && Gruse[Accr] != 0 && (Gruse[Breg] == 0 || Gruse[Breg] == 5)) {
            Ldi = Lb;
            Sti = Stb;
            Reg = Breg;
          }
          if (Parmline | Parmdbug) Psf1(Ldi, 0, Line);
          if (Parmline == 1) {
            Psf1(Sti, 1, Diaginf[Level]);
            Gruse[Reg] = 5;
            Grinf1[Reg] = Line;
          }
          if (Parmdbug) Ppj(0, 3);
          if (Parmprof) {
            Xynb = Setxorynb(-1, 0);
            Psf1(Lss, 0, 1);
            I = Parmprof + 8 + 4 * Line;
            Pf1(Iad, 0, Xynb, I);
            Pf1(St, 0, Xynb, I);
            Gruse[Accr] = 0;
          }
        }
        void Forget(int Reg) {
          int L;
          int U;
          L = Reg;
          U = L;
          if (L < 0) {
            L = 0;
            U = 7;
          }
          for (Reg = L; Reg <= U; Reg++)
            if (Register[Reg] >= 0) {
              Gruse[Reg] = 0;
              Grinf1[Reg] = 0;
            }
        }
        void Saveirs(void) {
          if (Register[Accr] == 1 && 1 == Register[Breg]) Abort();
          if (Register[Accr] >= 1) Bootout(Accr);
          if (Register[Breg] >= 1) Bootout(Breg);
          if (Register[Dr] >= 1) Bootout(Dr);
        }
        void Bootout(int Reg) {
          static const unsigned char Bootcode[8 /*0:7*/] = {0x48, 0x58, 0x5C, [3 ... 6] = 0, 0x5A};
          int Code;
          Rd *R;
          Code = Bootcode[Reg];
          if (1 > Register[Reg] || Register[Reg] > 3 || Code == 0) Abort();
          R = Record(Olink[Reg]);
          if (Register[Reg] == 2) {
            if (!R->D) Getwsp(R->D, (unsigned)Bytes[(unsigned)R->Ptype >> 4] >> 2);
            Psf1(Code, 1, R->D);
          } else {
            if (Reg != Accr && (Register[Accr] == 1 || Register[Accr] == 3)) Bootout(Accr);
            Pf1(Code, 0, Tos, 0);
          }
          Changerd(Reg);
          Register[Reg] = 0;
        }
        void Copydr(void) {
          if (Register[Accr]) Bootout(Accr);
          Psf1(Cyd, 0, 0);
          Gruse[Accr] = 0;
        }
        void Changerd(int Reg) {
          Rd *Opnd;
          if (1 > Register[Reg] || Register[Reg] > 3) Abort();
          Opnd = Record(Olink[Reg]);
          if (Register[Reg] == 1) {
            if (Opnd->Flag != 9 || (unsigned)Opnd->Xb >> 4 != Reg) Abort();
            Opnd->Flag = 8;
            Opnd->Xb = Tos << 4;
          }
          if (Register[Reg] == 2) {
            Opnd->Flag = 7;
            Opnd->Xb = Lnb << 4;
          }
        }
        void Storetag(int Kk, int Slink) {
          int Q;
          int Qq;
          int Qqq;
          int I;
          int Tcell;
          Listf *Lcell;
          Tcell = Tags[Kk];
          Q = Ptype << 16 | Level << 8 | Rbase << 4 | J;
          Qqq = Slink << 16 | Kform;
          Qq = Sndisp << 16 | Acc;
          if (((unsigned)From1(Tcell) >> 8 & 63) == Level) {
            Fault(7, Kk);
            Q = From1(Tcell) & 0xC000 | Q;
            Replace123(Tcell, Q, Qq, Qqq);
          } else {
            I = Asl;
            if (!I) I = Morespace();
            Lcell = &Aslist[I];
            Asl = Lcell->Link;
            Lcell->Link = Tags[Kk] | Names[Level] << 18;
            Lcell->S1 = Q;
            Lcell->S2 = Qq;
            Lcell->S3 = Qqq;
            Tags[Kk] = I;
            Names[Level] = Kk;
          }
        }
        void Copytag(int Kk) {
          int Qqq;
          Listf *Lcell;
          Tcell = Tags[Kk];
          if (!Tcell) {
            Type = 7;
            Ptype = 0x57;
            Prec = 5;
            Rout = 0;
            Nam = 0;
            Arr = 0;
            Litl = 0;
            Acc = 4;
            I = -1;
            J = -1;
            K = -1;
            Oldi = -1;
          } else {
            Lcell = &Aslist[Tcell];
            Kk = Lcell->S1;
            Lcell->S1 = Kk | 0x8000;
            Midcell = Lcell->S2;
            Qqq = Lcell->S3;
            Ptype = (unsigned)Kk >> 16;
            Usebits = (unsigned)Kk >> 14 & 3;
            Oldi = (unsigned)Kk >> 8 & 63;
            I = (unsigned)Kk >> 4 & 15;
            J = Kk & 15;
            Sndisp = (Midcell & 0xFFFF0000) / 0x10000;
            Acc = Midcell & 0xFFFF;
            K = (unsigned)Qqq >> 16;
            Kform = Qqq & 0xFFFF;
            Litl = (unsigned)Ptype >> 14;
            Rout = (unsigned)Ptype >> 12 & 3;
            Nam = (unsigned)Ptype >> 10 & 3;
            Arr = (unsigned)Ptype >> 8 & 3;
            Prec = (unsigned)Ptype >> 4 & 15;
            Type = Ptype & 15;
          }
        }
        void Reducetag(void) {
          int Subs;
          int Qq;
          int Pp;
          Copytag(Fromar2(P));
          if (Ptype == Snpt) {
            Ptype = Tsname[K];
            Unpack();
            Rout = 1;
          }
          if (Type == 3) {
            Pp = P;
            Qq = Copyrecordtag(Subs);
            P = Pp;
          }
        }
        void Replacetag(int Kk) {
          int P;
          int Q;
          P = Tags[Kk];
          Q = Ptype << 16 | Usebits << 14 | Oldi << 8 | I << 4 | J;
          Replace1(P, Q);
          Replace3(P, K << 16 | Kform);
        }
        void Unpack(void) {
          Litl = (unsigned)Ptype >> 14;
          Rout = (unsigned)Ptype >> 12 & 3;
          Nam = (unsigned)Ptype >> 10 & 3;
          Arr = (unsigned)Ptype >> 8 & 3;
          Prec = (unsigned)Ptype >> 4 & 15;
          Type = Ptype & 15;
        }
        void Pack(int *Ptype) { *Ptype = ((((Litl << 2 | Rout) << 2 | Nam) << 2 | Arr) << 4 | Prec) << 4 | Type; }
        void Ppj(int Mask, int N) {
          int Val;
          int Instrn;
          int Code;
          int J;
          Listf *Lcell;
          if (!Mask)
            Code = Jlk;
          else
            Code = Call;
          if (Mask > 0) Code = Jcc;
          if (Mask >= 16) Code = Jat;
          if (Mask >= 32) Code = Jaf;
          Val = Plabs[N];
          if (Mask <= 0)
            Instrn = Code << 24 | 3 << 23;
          else
            Instrn = Code << 24 | (Mask & 15) << 21;
          if (Val > 0)
            Instrn = Instrn | ((Val - Ca) / 2) & 0x3FFFF;
          else {
            Lcell = &Aslist[Plink[N]];
            J = Instrn | Ca;
            if (Lcell->S3)
              Push(Plink[N], J, 0, 0);
            else if (!Lcell->S2)
              Lcell->S2 = J;
            else
              Lcell->S3 = J;
          }
          Pconst(Instrn);
          if (Mask <= 0) Forget(-1);
        }
        int Setxorynb(int Which, int Rlev) {
          int Use;
          int Inf;
          int Offset;
          if (-1 > Rlev || Rlev > Rlevel) Abort();
          if (Rlev <= 0) {
            Use = 3;
            Inf = 0;
          } else {
            Use = 4;
            Inf = Rlev;
          }
          if (Which <= 0) Which = Xorynb(Use, Inf);
          if (Gruse[Which] == Use && Grinf1[Which] == Inf) {
            Grat[Which] = Ca;
            return (Which);
          }
          Offset = Ptroffset(Rlev);
          Psf1(Ldcode[Which], 1, Offset);
          Gruse[Which] = Use;
          Grinf1[Which] = Inf;
          Grat[Which] = Ca;
          return (Which);
        }
        int Xorynb(int Use, int Inf) {
          if (Gruse[Xnb] == Use && Grinf1[Xnb] == Inf) {
            Grat[Xnb] = Ca;
            return (Xnb);
          }
          if (Gruse[Ctb] == Use && Grinf1[Ctb] == Inf) {
            Grat[Ctb] = Ca;
            return (Ctb);
          }
          if (!(Gruse[Xnb] | Gruse[Ctb])) {
            if (Use == 3) return (Ctb);
            return (Xnb);
          }
          if (!Gruse[Xnb]) return (Xnb);
          if (!Gruse[Ctb]) return (Ctb);
          if (Grat[Xnb] < Grat[Ctb]) return (Xnb);
          return (Ctb);
        }
        void Oddalign(void) {
          if (!(N & 7)) {
            Returnwsp(N, 1);
            N += 4;
          }
        }
        int Ptroffset(int Rlev) {
          if (Rlev <= 0) return (16);
          return (Display[Rlevel] + ((Rlev - 1) << 2));
        }
        int Areacode(void) {
          if (Area < 0) {
            if (Base == Rbase) {
              Area = Lnb;
              return (Lnb);
            }
            Area = Setxorynb(-1, Base);
          }
          return (Area);
        }
        int Areacode2(int Bs) {
          if (Bs == Rbase) return (Lnb);
          return (Setxorynb(-1, Bs));
        }
        void Getinacc(int Reg, int Size, int Access, int Area, int Disp) {
          int Opcode;
          if (!Size) Size = 1;
          if (Reg == Dr)
            Opcode = Ld;
          else if (Reg == Breg)
            Opcode = Lb;
          else
            Opcode = Lss + (Size & 6);
          if (Register[Reg] >= 1)
            if (Register[Reg] == 2 || (Access == 2 && Area == 0))
              Bootout(Reg);
            else {
              if (Reg != Accr && (Register[Accr] == 1 || Register[Accr] == 3)) Bootout(Accr);
              Changerd(Reg);
              Register[Reg] = 0;
              if (!Reg)
                Opcode -= 32;
              else
                Opcode -= 40;
            }
          Psorlf1(Opcode, Access, Area, Disp);
          if (Access >= 2 && 0 != Area && Area != 7) Gruse[Dr] = 0;
          Gruse[Reg] = 0;
        }
        void Noteassment(int Reg, int Assop, int Var) {
          static const int Eemask = 0b100011110000000;
          static const int Emask = 0b100011000000000;
          static const int Nregs = 5;
          static const int Regs = 16 * 16 * 16 * 16 * Ctb + 16 * 16 * 16 * Xnb + 16 * 16 * Accr + 16 * Breg + Dr;
          int I;
          int Use1;
          int Use2;
          int Ii;
          if (Var <= 0) return;
          if (Assop == 1) {
            for (I = 0; I <= 7; I++) {
              Use1 = Gruse[I];
              Use2 = (unsigned)Use1 >> 16;
              Use1 = Use1 & 255;
              if ((Eemask & 1 << Use2) != 0 && ((Grinf2[I] & 0xFFFF) == Var || (unsigned)Grinf2[I] >> 16 == Var)) {
                Gruse[I] = Use1;
                Use2 = 0;
              }
              if ((Eemask & 1 << Use1) != 0 && ((Grinf1[I] & 0xFFFF) == Var || (unsigned)Grinf1[I] >> 16 == Var)) {
                Gruse[I] = Use2;
                Grinf1[I] = Grinf2[I];
              }
            }
            Gruse[Reg] = 7;
            Grinf1[Reg] = Var;
          } else {
            for (Ii = 0; Ii <= 4 * (Nregs - 1); Ii += 4) {
              I = (unsigned)Regs >> Ii & 15;
              Use1 = Gruse[I];
              Use2 = (unsigned)Use1 >> 16;
              Use1 = Use1 & 255;
              if ((Emask & 1 << Use2) != 0 &&
                  ((Grinf2[I] & 0xFFFF) == Var || (unsigned)Grinf2[I] >> 16 == Var || Grinf2[I] == Var)) {
                Gruse[I] = Use1;
                Use2 = 0;
              }
              if ((Emask & 1 << Use1) != 0 &&
                  ((Grinf1[I] & 0xFFFF) == Var || (unsigned)Grinf1[I] >> 16 == Var || Grinf1[I] == Var)) {
                Gruse[I] = Use2;
                Grinf1[I] = Grinf2[I];
              }
            }
            if (Assop == 2 && Var > 0) {
              Use1 = Gruse[Reg];
              if (5 <= (Use1 & 255) && (Use1 & 255) <= 6) {
                Gruse[Reg] = Use1 & 255 | (9 << 16);
                Grinf2[Reg] = Var;
              } else {
                Gruse[Reg] = Use1 << 16 | 9;
                Grinf2[Reg] = Grinf1[Reg];
                Grinf1[Reg] = Var;
              }
            }
          }
        }
      }
      void Printuse(void) {
        static const _imp_string Regs[8 /*0:7*/] = {
            _imp_str_literal("ACC"), _imp_str_literal(" DR"), _imp_str_literal("LNB"), _imp_str_literal("XNB"),
            _imp_str_literal(" PC"), _imp_str_literal("CTB"), _imp_str_literal("TOS"), _imp_str_literal("  B")};
        static const _imp_string Uses[16 /*0:15*/] = {
            _imp_str_literal(" NOT KNOWN "), _imp_str_literal(" I-RESULT  "), _imp_str_literal(" TEMPORARY "),
            _imp_str_literal("  PLTBASE  "), _imp_str_literal(" NAMEBASE  "), _imp_str_literal(" LIT CONST "),
            _imp_str_literal(" TAB CONST "), _imp_str_literal(" DESC FOR  "), _imp_str_literal(" RECD BASE "),
            _imp_str_literal(" LOCAL VAR "), _imp_str_literal(" NAME+CNST "), _imp_str_literal(" AUXSTPTR- "),
            _imp_str_literal(" BYTE DES  "), _imp_str_literal(" HALF DES  "), _imp_str_literal("  VMY RES  "),
            _imp_str_literal(" REC HDES  ")};
        static const _imp_string State[5 /*-1:3*/] = {_imp_str_literal("  LOCKED   "), _imp_str_literal("   FREE    "),
                                                      _imp_str_literal(" I-RESULT  "), _imp_str_literal(" TEMPORARY "),
                                                      _imp_str_literal(" RT-PARAM  ")};
        auto void Out(int Use, int Inf);
        int I;
        int Use;
        int Inf;
        for (I = 0; I <= 7; I++)
          if (Register[I] | Gruse[I]) {
            Use = Gruse[I];
            Printstring(_imp_join(Regs[I], State[Register[I]]));
            Out(Use & 255, Grinf1[I]);
            if ((unsigned)Use >> 16) {
              Printstring(_imp_str_literal(" ALSO "));
              Out((unsigned)Use >> 16, Grinf2[I]);
            }
            Newline();
          }
        return;
        void Out(int Use, int Inf) {
          static const int Lnmask = 0b1100011110000000;
          static const int Unmask = 0b0100001110000000;
          Printstring(_imp_join(_imp_str_literal(" USE = "), Uses[Use]));
          if (Lnmask & 1 << Use)
            Printstring(Printname(Inf & 0xFFFF));
          else
            Write(Inf, 1);
          if (Use == 10) {
            Printsymbol('+');
            Write((unsigned)Inf >> 16, 1);
          }
          if ((Unmask & 1 << Use) != 0 && (unsigned)Inf >> 16 != 0) {
            Printstring(_imp_str_literal(" MODBY"));
            Printstring(Printname((unsigned)Inf >> 16));
          }
        }
      }
      void Abort(void) {
        Printstring(_imp_str_literal("\n****************      ABORT********************    ABORT    *******"));
        if (Ca != Cabuf) Ncode(Addr(Code[0]), Addr(Code[Ppcurr]), Cabuf);
        Printuse();
        _imp_monitor();
        exit(0);
      }
      void Epilogue(void) {
        int D;
        int J;
        auto void Fill(int Lab);
        if (!Plink[15]) goto P16;
        Abort();
      P16:;
        if (!Plink[16]) goto P17;
        Fill(16);
        Psf1(Lxn, 1, 0);
        Pf1(Ld, 0, Xnb, 12);
        Psf1(Ldb, 0, 0);
        Psf1(Std, 1, 12);
        Psf1(Asf, 0, 4);
        Psf1(Ld, 1, 20);
        Psf1(Sld, 1, 36);
        Psf1(Lb, 0, 0);
        Pf3(Jat, 11, 0, 0x24);
        Psf1(Inca, 0, 1);
        Pf1(Lb, 2, 7, 0);
        Psf1(Std, 1, 44);
        Psf1(Lss, 1, 20);
        Pf1(And, 0, 0, 0x1FF);
        Pf3(Jat, 4, 0, 0x27);
        Psf1(Ld, 1, 23);
        Pf2(Swne, 1, 0, 0, 0, 0);
        Pf3(Jcc, 8, 0, 0x23);
        Psf1(Std, 1, 52);
        Psf1(Cyd, 0, 0);
        Psf1(Ld, 1, 44);
        Pf2(Cps, 1, 1, 0, 0, 0xFF);
        Pf3(Jcc, 8, 0, 5);
        Psf1(Ld, 1, 52);
        Pf2(Sweq, 0, 0, 0, 0, 0);
        Psf1(Junc, 0, -12);
        Psf1(Slss, 1, 20);
        Psf1(Isb, 1, 52);
        Pf1(St, 0, Breg, 0);
        Psf1(Lss, 1, 28);
        Pf3(Jaf, 4, 0, 3);
        Psf1(Lss, 0, 1);
        Pf1(And, 0, 0, 0x1FF);
        Pf1(Icp, 0, Breg, 0);
        Pf3(Jcc, 12, 0, 13);
        Psf1(Ld, 1, 28);
        Pf3(Jat, 11, 0, 7);
        Psf1(Lsd, 1, 20);
        Pf2(Mvl, 0, 0, 0, 0, 0);
        Pf1(Ldb, 0, Breg, 0);
        Pf2(Mv, 1, 1, 0, 0, Unasspat & 255);
        Pf1(Ld, 0, Tos, 0);
        Psf1(Cyd, 0, 0);
        Psf1(Exit, 0, -0x40);
        Psf1(Mpsr, 0, 0x24);
        Psf1(Exit, 0, -0x40);
      P17:;
        if (!Plink[17]) goto P18;
        Fill(17);
        if (!Logepdisp) Cxref(_imp_str_literal("S#ILOG"), Parmdynamic, 2, Logepdisp);
        if (!Expepdisp) Cxref(_imp_str_literal("S#IEXP"), Parmdynamic, 2, Expepdisp);
        Pf1(Lb, 0, Tos, 0);
        Pf1(Ld, 0, Tos, 0);
        Pf1(Stb, 0, Tos, 0);
        Pf1(Std, 0, Tos, 0);
        Pf1(Slsd, 0, Tos, 0);
        Pf3(Jat, 2, 0, 0x35);
        Pf3(Jaf, 0, 0, 7);
        Pf1(Slsd, 0, Tos, 0);
        Pf3(Jaf, 1, 0, 0x30);
        Pf1(Lsd, 0, Tos, 0);
        Pf1(Junc, 0, Tos, 0);
        Pf1(Slsd, 0, Tos, 0);
        Pf1(St, 0, Tos, 0);
        Pf3(Jat, 2, 0, 26);
        Psf1(Rsc, 0, 55);
        Psf1(Rsc, 0, -55);
        Pf1(Fix, 0, Breg, 0);
        Psf1(Myb, 0, 4);
        Psf1(Cpb, 0, -64);
        Pf3(Jcc, 10, 0, 3);
        Psf1(Lb, 0, -64);
        Pf1(Ish, 0, Breg, 0);
        Pf1(Stuh, 0, Breg, 0);
        Pf3(Jcc, 7, 0, 14);
        Psf1(Asf, 0, -2);
        Pf1(St, 0, Breg, 0);
        Psf1(Lss, 0, 1);
        Psf1(Flt, 0, 0);
        Pf3(Jaf, 12, 0, 5);
        Psf1(Asf, 0, -2);
        Pf1(Junc, 0, Tos, 0);
        Pf1(Std, 0, Tos, 0);
        Pf1(Rmy, 0, Tos, 0);
        Psf1(Debj, 0, -2);
        Pf1(Junc, 0, Tos, 0);
        Pf1(Lsd, 0, Tos, 0);
        Pf1(Slsd, 0, Tos, 0);
        Psf1(Prcl, 0, 4);
        Pf1(St, 0, Tos, 0);
        Psf1(Lxn, 1, 16);
        Psf1(Raln, 0, 7);
        Pf1(Call, 2, Xnb, Logepdisp);
        Pf1(Rmy, 0, Tos, 0);
        Psf1(Prcl, 0, 4);
        Pf1(St, 0, Tos, 0);
        Psf1(Lxn, 1, 16);
        Psf1(Raln, 0, 7);
        Pf1(Call, 2, Xnb, Expepdisp);
        Pf1(Junc, 0, Tos, 0);
        Pf1(Junc, 0, 0, (Plabs[7] - Ca) / 2);
      P18:;
        if (!Plink[18]) goto P19;
        Cnop(0, 8);
        D = Ca;
        Pconst(511);
        Pconst(0);
        Fill(18);
        Pf1(St, 0, Tos, 0);
        Pf1(And, 0, Pc, D);
        Pf1(Stuh, 0, Breg, 0);
        Pf1(Lsd, 0, Tos, 0);
        Pf1(Std, 0, Tos, 0);
        Psf1(Sbb, 0, 1);
        Pf3(Jaf, 13, 0, 3);
        Pf1(Modd, 0, Breg, 0);
        Psf1(Adb, 0, 1);
        Pf1(Ld, 0, Tos, 0);
        Pf1(Ldb, 0, Breg, 0);
        Pf1(Junc, 0, Tos, 0);
      P19:;
        if (!(Plink[19] | Plink[20])) goto P21;
        Cnop(0, 8);
        D = Ca;
        Pconst(0x180000FF);
        Pconst(12);
        Fill(19);
        Pf1(Stln, 0, Tos, 0);
        Pf1(Adb, 0, Tos, 0);
        Pf1(Lxn, 0, Breg, 0);
        Pf1(Slb, 2, 7, 0);
        Pf1(Stb, 0, Xnb, 8);
        Psf1(Inca, 0, 1);
        Psf1(Cyd, 0, 0);
        Pf1(Ld, 0, Pc, D);
        Pf1(Inca, 0, Tos, 0);
        Pf1(Std, 0, Xnb, 0);
        Pf1(Ldb, 0, Breg, 0);
        Pf2(Mv, 1, 0, 0, 0, 0);
        Pf1(Ld, 0, Xnb, 0);
        Pf1(Ldb, 0, Breg, 0);
        Psf1(Inca, 0, -1);
        Psf1(Cyd, 0, 0);
        Pf1(Junc, 0, Tos, 0);
        if (!Plink[20]) goto P21;
        Fill(20);
        Pf1(Stln, 0, Tos, 0);
        Pf1(Adb, 0, Tos, 0);
        Pf1(Lxn, 0, Breg, 0);
        Pf1(Lb, 2, 7, 0);
        Pf1(Stb, 0, Tos, 0);
        Pf1(Adb, 0, Xnb, 8);
        Psf1(Inca, 0, 1);
        Psf1(Cyd, 0, 0);
        Pf1(Ld, 0, Xnb, 0);
        Pf1(Modd, 0, Xnb, 8);
        Pf1(Ldb, 0, Tos, 0);
        Pf2(Mv, 1, 0, 0, 0, 0);
        Pf1(Stb, 0, Xnb, 8);
        Pf1(Cpb, 0, 0, 255);
        Pf3(Jcc, 2, 0, (Plabs[9] - Ca) / 2);
        Pf1(Ld, 0, Xnb, 0);
        Pf1(Ldb, 0, Breg, 0);
        Psf1(Inca, 0, -1);
        Psf1(Cyd, 0, 0);
        Pf1(Junc, 0, Tos, 0);
      P21:;
        if (!Plink[21]) goto P22;
        Fill(21);
        Cxref(_imp_str_literal("S#STOP"), Parmdynamic, 2, J);
        Psf1(Prcl, 0, 4);
        Psf1(Lxn, 1, 16);
        Psf1(Raln, 0, 5);
        Pf1(Call, 2, Xnb, J);
        Pf1(0x4E, 0, 0, 0xB00B);
      P22:;
        if (!Plink[22]) goto P23;
        Fill(22);
        Cxref(_imp_str_literal("S#PPROFILE"), Parmdynamic, 2, J);
        Psf1(Prcl, 0, 4);
        Psf1(Lxn, 1, 16);
        Pf1(Ldrl, 0, Xnb, Parmprof);
        Pf1(Std, 0, Tos, 0);
        Psf1(Raln, 0, 7);
        Pf1(Call, 2, Xnb, J);
        Pf1(Junc, 0, Tos, 0);
      P23:;
        return;
        void Fill(int Lab) {
          int At;
          int Instrn;
          int I;
          int J;
          int A[3 /*0:2*/];
          while (Plink[Lab]) {
            Pop(Plink[Lab], A[0], A[1], A[2]);
            for (I = 0; I <= 2; I++) {
              Instrn = A[I];
              if (Instrn) {
                At = Instrn & 0x3FFFF;
                Instrn = Instrn & 0xFFC00000;
                Instrn = Instrn | (unsigned)(Ca - At) >> 1;
                Plug(1, At, Instrn, 4);
              }
            }
          }
          Plabs[Lab] = Ca;
        }
      }
      void Dumpconsts(void) {
        auto void Doit(int Val);
        auto void Fill(int Crefhead);
        int I;
        int J;
        int K;
        int Disp;
        int Size;
        int Base;
        Base = 0;
        Size = Constptr - Base;
        if (Size <= 0) return;
        if (Ca & 7) Cnop(0, 8);
        Codeout();
        Lput(1, Size * 4, Ca, Addr(Ctable->Val));
        if (Dcomp) {
          Printstring(_imp_str_literal("\nCONSTANT TABLE"));
          I = Base;
          for (;;) {
            Newline();
            Prhex(Ca + 4 * (I - Base), 5);
            for (J = 0; J <= 7; J++) {
              Spaces(2);
              Prhex(Ctable->Val, 8);
            }
            Space();
            for (J = 0; J <= 31; J++) {
              K = *Byteinteger(Addr(Ctable->Val) + J);
              if (K < 31 || K > 95) K = 32;
              Printsymbol(K);
            }
            I += 8;
            if (I >= Constptr) break;
          }
        }
        Fill(Crefhead);
        Size = (Size + 1) & (-2);
        Ca += 4 * Size;
        Cabuf = Ca;
        return;
        void Fill(int Crefhead) {
          Disp = (Ca - 4 * Base) / 2;
          while (Crefhead) {
            Pop(Crefhead, I, J, K);
            Doit(I);
            if (J) Doit(J);
            if (K) Doit(K);
          }
        }
        void Doit(int Val) {
          int I;
          int J;
          if (Val > 0)
            Lput(18, 0, Val, Disp);
          else {
            I = ((unsigned)Val >> 16 & 0x7FFF) << 2;
            J = 4 * (Val & 0xFFFF) + Ca;
            Plug(2, I, J, 4);
          }
        }
      }
    }
    _imp_string Message(int N) {
      static const unsigned char Outtt[64 /*0:63*/] = {'?', 'A', 'B', 'C',  'D', 'E', 'F', 'G', 'H',
                                                       'I', 'J', 'K', 'L',  'M', 'N', 'O', 'P', 'Q',
                                                       'R', 'S', 'T', 'U',  'V', 'W', 'X', 'Y', 'Z',
                                                       '&', '-', '/', '\'', '(', ')', 'a', 'b', 'c',
                                                       'd', 'e', 'f', 'g',  'h', 'i', 'j', 'k', 'l',
                                                       'm', 'n', 'o', 'p',  'q', 'r', 's', 't', 'u',
                                                       'v', 'w', 'x', 'y',  'z', '.', '%', '#', [62 ... 63] = '?'};
      static const int Wordmax = 584;
      static const int Default = 580;
      static int Word[585 /*0:584*/] = {
          0,     1,     32769, 32771, 32772, 32773, 2,     32775, 32776, 32777, 32778, 32780, 32781, 32782, 32783,
          32784, 4,     32785, 32776, 32777, 32772, 32780, 32787, 5,     32785, 32789, 32776, 32782, 32790, 32792,
          32793, 6,     32785, 32795, 32796, 32781, 32797, 32798, 32800, 7,     32801, 32776, 32777, 32778, 32780,
          32787, 8,     32802, 32792, 32804, 32776, 32777, 32805, 32806, 32808, 32809, 9,     32811, 32813, 32814,
          32776, 32815, 32782, 32817, 32818, 32819, 10,    32802, 32792, 32804, 32776, 32777, 32822, 32806, 32808,
          32809, 11,    32775, 32776, 32823, 32825, 32826, 32813, 32777, 32772, 32780, 32781, 12,    32827, 32825,
          32826, 32813, 32777, 32829, 32830, 32832, 13,    32769, 32834, 32827, 32825, 32826, 32813, 32771, 32835,
          14,    32837, 32838, 32839, 15,    32840, 32839, 16,    32801, 32776, 32777, 32772, 32780, 32787, 17,
          32801, 32776, 32842, 32772, 32843, 32806, 32792, 32845, 19,    32847, 32848, 32849, 32850, 20,    32813,
          32852, 32853, 32845, 32854, 32834, 32856, 32776, 21,    32813, 32852, 32857, 32845, 32854, 32834, 32856,
          32776, 22,    32858, 32850, 32860, 32861, 32862, 23,    32863, 32865, 32866, 32867, 24,    32869, 32866,
          32870, 32867, 26,    32813, 32771, 32772, 32797, 32872, 32873, 32875, 27,    32776, 32771, 32772, 32797,
          32877, 32789, 28,    32802, 32792, 32804, 32776, 32777, 32819, 32879, 32880, 32881, 29,    32882, 32860,
          32883, 30,    32885, 32887, 32877, 32881, 31,    32889, 32887, 32804, 32792, 32891, 32881, 32,    32892,
          32894, 33,    32892, 32865, 32866, 32894, 34,    32837, 32838, 32896, 37,    32837, 32838, 32898, 38,
          32900, 32776, 32777, 32901, 32902, 32813, 32903, 32808, 32904, 32902, 40,    32905, 32906, 41,    32908,
          32910, 32912, 32913, 32825, 32915, 32800, 44,    32917, 32919, 45,    32847, 32848, 32849, 32919, 46,
          32776, 32771, 32787, 32920, 32921, 32817, 32923, 32925, 47,    32926, 32778, 32927, 32825, 32826, 32813,
          48,    32926, 32921, 32928, 32929, 32873, 49,    32930, 32932, 32933, 32923, 32792, 32935, 32776, 50,
          32937, 32814, 32813, 32771, 32887, 32939, 32940, 32814, 32776, 51,    32942, 32771, 32772, 32773, 52,
          32769, 32944, 32814, 32942, 32834, 32946, 32825, 32826, 32813, 53,    32942, 32834, 32946, 32825, 32826,
          32813, 32771, 32835, 54,    32948, 32887, 32827, 32769, 32881, 55,    32949, 32887, 32827, 32769, 32881,
          56,    32951, 32953, 32849, 32954, 57,    32956, 32840, 58,    32957, 32959, 32906, 59,    32942, 32944,
          32814, 32769, 32834, 32827, 32825, 32826, 32813, 61,    32801, 32776, 32777, 32778, 32780, 32960, 32782,
          32783, 32935, 62,    32860, 32961, 32865, 63,    32963, 32862, 32965, 64,    32966, 32840, 65,    32966,
          32860, 32866, 32961, 66,    32968, 32970, 32932, 32972, 32776, 67,    32974, 32976, 32977, 32776, 32978,
          32979, 32981, 69,    32966, 32953, 32849, 32954, 70,    32917, 32983, 32905, 71,    32776, 32771, 32772,
          32797, 32985, 32987, 72,    32989, 32991, 32782, 32797, 32985, 32790, 73,    32989, 32993, 32782, 32797,
          32985, 32790, 74,    32995, 32771, 32772, 32939, 32997, 32999, 75,    32985, 32790, 33001, 32797, 33003,
          32790, 76,    32985, 33004, 32776, 32782, 33006, 32790, 77,    32985, 32993, 32782, 33006, 32790, 78,
          32985, 32991, 33008, 32782, 33006, 32790, 80,    33009, 33004, 32776, 33011, 33013, 32790, 81,    33009,
          33004, 32776, 33014, 32932, 32790, 82,    32776, 32771, 32772, 32797, 33017, 32789, 83,    32976, 32977,
          32776, 33019, 32772, 33020, 32782, 32817, 84,    32963, 32953, 32849, 32954, 86,    33022, 33017, 32976,
          33014, 32932, 33024, 32776, 91,    33025, 32830, 33004, 32776, 32772, 33026, 92,    33025, 33028, 32777,
          33030, 33031, 93,    33025, 33028, 32777, 33032, 32875, 32814, 33034, 90,    33036, 32789, 32776, 32960,
          32920, 33004, 8,     33038, 101,   33041, 33043, 32837, 33044, 102,   33045, 32837, 33047, 103,   33048,
          32837, 33044, 104,   32837, 32838, 33048, 105,   32837, 32838, 32896, 106,   32983, 32919, 32837, 33044,
          107,   33049, 33051, 33053, 202,   32801, 32776, 32772, 32960, 203,   32775, 32776, 32772, 32960, 204,
          33022, 33025, 32830, 33004, 32776, 205,   32801, 32776, 32772, 33054, 255,   33057, 33058, 33059, 0};
      static const int Lett[293 /*0:292*/] = {
          0,          0x7890A80B, 0x02A00000, 0x53980000, 0x5D7E8000, 0x652E3AD3, 0x652C8000, 0x190C52D8, 0x36000000,
          0x510E6000, 0x436652C3, 0x49C80000, 0x452CB700, 0x672E8000, 0x53700000, 0x69453980, 0x4565F1D6, 0x27BD3A47,
          0x50000000, 0x492C7643, 0x652C8000, 0x5D0DB280, 0x4BC6194B, 0x679D37DC, 0x5F900000, 0x439E74CF, 0x5D6CB768,
          0x590C52D8, 0x36FFB000, 0x42000000, 0x672C77DD, 0x48000000, 0x694DB280, 0x1D0DB280, 0x257EBA53, 0x5D280000,
          0x4D700000, 0x5B7E5280, 0x610E50DB, 0x4BA4B966, 0x69443700, 0x6784B1D3, 0x4D4CB200, 0x210E50DB, 0x4BA4B900,
          0x7A000000, 0x5F300000, 0x494CD34B, 0x65980000, 0x69CE1280, 0x4D95F680, 0x6784B1D3, 0x4D4C70E9, 0x537DC000,
          0x4D2EF2E4, 0x652CD2E5, 0x4B7472C8, 0x43A00000, 0x594DD280, 0x781B2199, 0x0A000000, 0x69BDE000, 0x477DDA65,
          0x5F600000, 0x47643AE7, 0x4B980000, 0x4D7E4000, 0x5B4E79D3, 0x5D380000, 0x2879E000, 0x1A09CC80, 0x0A708980,
          0x1A4A6993, 0x1C380000, 0x497CB980, 0x652E3AD3, 0x65280000, 0x67AC59C7, 0x654E1A66, 0x2E91E70E, 0x1C780000,
          0x1E300000, 0x200A409B, 0x0AA0A926, 0x697DE000, 0x4D2EE000, 0x6195FB53, 0x492C8000, 0x439650F2, 0x5B0DDC80,
          0x021A8A83, 0x18000000, 0x1C7A8000, 0x02980000, 0x2680A180, 0x247AAA13, 0x1C280000, 0x1C09A280, 0x12700000,
          0x0AC20927, 0x26700000, 0x24282600, 0x1272828F, 0x0A900000, 0x6D0D94C8, 0x782AC29D, 0x28000000, 0x5DADB14B,
          0x64000000, 0x657EBA53, 0x5D280000, 0x45AE8000, 0x5D780000, 0x457C9C80, 0x18426000, 0x082A6A1D, 0x28700000,
          0x7890AA2B, 0x24700000, 0x5FAE9BD3, 0x69400000, 0x7890A9AB, 0x18A00000, 0x5B0E0000, 0x1272C099, 0x12200000,
          0x029A629B, 0x0460A900, 0x182AC299, 0x26000000, 0x0849A29D, 0x2649E726, 0x039650F2, 0x6B8612E4, 0x457EB748,
          0x592E7980, 0x597EF2E4, 0x0828661C, 0x1A4A6819, 0x0218A200, 0x077DD9E9, 0x43768000, 0x470DD75F, 0x68000000,
          0x45280000, 0x4BB4366B, 0x43A4B200, 0x477DB853, 0x59280000, 0x1261828F, 0x02600000, 0x0679C9A8, 0x43980000,
          0x5376D0D9, 0x53200000, 0x782B0A25, 0x12726486, 0x7870268A, 0x7829898A, 0x4F4ED2DC, 0x433692E4, 0x7879C000,
          0x03A692DB, 0x61A00000, 0x69780000, 0x53753A53, 0x436539CA, 0x7831E91B, 0x02A00000, 0x27AC59C7, 0x654E1A00,
          0x6944A000, 0x457EB749, 0x66000000, 0x78312713, 0x26400000, 0x53767A4B, 0x43200000, 0x789A80A5, 0x28000000,
          0x782B04A8, 0x7819E729, 0x1272A280, 0x0A70878D, 0x0C498280, 0x1EAA8000, 0x0679CA0B, 0x30A00000, 0x0428E49C,
          0x0679CA25, 0x1E600000, 0x26A1A728, 0x6B9CB200, 0x0C7A4683, 0x28000000, 0x242867A5, 0x08000000, 0x0A9247A4,
          0x26A84703, 0x1A280000, 0x0BC6194B, 0x679D37DC, 0x439E74CF, 0x5D2C8000, 0x652C77E5, 0x48000000, 0x252C77E5,
          0x49980000, 0x36D80000, 0x43748000, 0x510ED280, 0x494CD34B, 0x652DDA00, 0x4D7E56C3, 0x69980000, 0x26A2449D,
          0x0E000000, 0x27A654DD, 0x4E000000, 0x6D0E50D3, 0x4564A000, 0x03953A51, 0x5B2E94C6, 0x5F84B943, 0x697E4000,
          0x477DD9E9, 0x43768000, 0x252E77D9, 0x6BA537DC, 0x477E594B, 0x47A00000, 0x4D7E56C3, 0x68000000, 0x477DDA43,
          0x53766000, 0x67AC4000, 0x6D0E54C3, 0x4564A000, 0x43953A51, 0x5B2E94C6, 0x3DDBC000, 0x217D3769, 0x4B900000,
          0x477DB843, 0x652C8000, 0x6F4E9400, 0x4B8EB4ED, 0x4364B747, 0x4B200000, 0x617D3769, 0x4B900000, 0x4394A000,
          0x4B8EB4ED, 0x4364B768, 0x0F65F143, 0x58000000, 0x597C70D8, 0x7831E900, 0x537692CF, 0x4B900000, 0x47643AE7,
          0x4A000000, 0x752E5780, 0x67A4B800, 0x5D7DD4DD, 0x692CF2E4, 0x69943B4B, 0x659CB980, 0x2B769CE1, 0x4B200000,
          0x0220890B, 0x26982113, 0x184A8C80, 0x267AA907, 0x0A000000, 0x1849C280, 0x1879C380, 0x2E7A458D, 0x1260A000,
          0x26682618, 0x1C09A2A6, 0x0679A813, 0x182A4000, 0x2808460B, 0x26000000, 0x0CA98600, 0x4324994B, 0x679C3159,
          0x4A000000, 0x2628A000, 0x126A0000, 0x1A09CA83, 0x18000000};
      int I;
      int J;
      int K;
      int M;
      int Q;
      int S;
      _imp_string Omess;
      Omess = _imp_str_literal(" ");
      for (I = 1; I <= Wordmax - 1; I++)
        if (N == Word[I]) goto Found;
      I = Default;
    Found:;
      J = 1;
      for (;;) {
        K = Word[I + J];
        if (!(K & 0x8000)) break;
        K = K ^ 0x8000;
        if (J != 1) Omess = _imp_join(Omess, _imp_str_literal(" "));
        do {
          M = Lett[K];
          S = 25;
          do {
            Q = (unsigned)M >> S & 63;
            if (Q) Omess = _imp_join(Omess, Tostring(Outtt[Q]));
            S -= 6;
          } while (S >= 0);
          K++;
        } while (M & 1);
        J++;
      }
      return (Omess);
    }
    _imp_string Swrite(int Value, int Places) { return (Itos(Value, Places)); }
    void Fault2(int N, int Data, int Ident) {
      int I;
      int J;
      int T;
      _imp_string Mess1;
      _imp_string Mess2;
      _imp_string Wk1;
      _imp_string Wk2;
      if (Faulty <= 1 && (Smap != 0 || Dcomp != 0)) _imp_monitor();
      Mess1 = _imp_str_literal("");
      Mess2 = _imp_str_literal("");
      Faulty++;
      if (N == 100) {
        Mess1 = _imp_join(Snl, _imp_join(_imp_str_literal("*    Failed to analyse line "),
                                         _imp_join(Swrite(Line, 2), _imp_join(Snl, _imp_str_literal("     ")))));
        if (Line != Oldline)
          Mess1 = _imp_join(Mess1,
                            _imp_join(_imp_str_literal("Text mode failure - erroneos source line not available"), Snl));
        else {
          J = 0;
          S = 0;
          T = 0;
          do {
            I = J;
            J = *Byteinteger(Data + Q);
            if (J > 128 && I < 128) {
              Mess2 = _imp_join(Mess2, _imp_str_literal(" %"));
              T += 2;
            }
            if (I > 128 && J < 128) {
              Mess2 = _imp_join(Mess2, _imp_str_literal(" "));
              T++;
            }
            Mess2 = _imp_join(Mess2, Tostring(J));
            T++;
            if (Q == Qmax) S = T;
            Q++;
            if (T >= 250) break;
          } while ((J != ';' || Q <= Qmax) && Q != Length);
          if (Q == Qmax) S = T;
        }
      } else {
        Mess1 = _imp_join(_imp_str_literal("\n*"), _imp_join(Swrite(Line, 4), _imp_str_literal("   ")));
        Parmopt = 1;
        if (!Parmlet) Inhcode = 1;
        Mess1 = _imp_join(Mess1, _imp_join(_imp_str_literal("FAULT"), Swrite(N, 2)));
        Mess2 = Message(N);
        if (_imp_resolve(Mess2, Wk1, _imp_str_literal("##"), Wk2))
          Mess2 = _imp_join(Wk1, _imp_join(Swrite(Ident, 1), Wk2));
        if (_imp_resolve(Mess2, Wk1, _imp_str_literal("#"), Wk2))
          Mess2 = _imp_join(Wk1, _imp_join(Swrite(Data, 1), Wk2));
        if (_imp_resolve(Mess2, Wk1, _imp_str_literal("&&"), Wk2))
          Mess2 = _imp_join(Wk1, _imp_join(Printname(Data), Wk2));
        if (_imp_resolve(Mess2, Wk1, _imp_str_literal("&"), Wk2))
          Mess2 = _imp_join(Wk1, _imp_join(Printname(Ident), Wk2));
        if (N > 100) Mess2 = _imp_join(Mess2, _imp_str_literal(" Disaster"));
      }
      for (I = 2; I >= 1; I--) {
        if (I == 1) Selectoutput(Ttoput);
        Printstring(Mess1);
        if (*Length(Mess2) != 0) Printstring(Mess2);
        if (N == 100 && S < 115) {
          Newline();
          Spaces(S + 4);
          Printsymbol('!');
        }
        Newline();
        if (I == 1) Selectoutput(82);
        if (Ttoput <= 0) break;
      }
      if (N > 100) {
        _imp_monitor();
        exit(0);
      }
    }
    void Fault(int N, int Fname) { Fault2(N, Fname, Fname); }
    void Warn(int N, int V) {
      _imp_string T;
      _imp_string S;
      S = Message(N + 200);
      if (_imp_resolve(S, S, _imp_str_literal("&"), T)) S = _imp_join(S, _imp_join(Printname(V), T));
      Printstring(_imp_join(_imp_str_literal("\n?  Warning :- "),
                            _imp_join(S, _imp_join(_imp_str_literal(" at line No"), Swrite(Line, 1)))));
      Newline();
    }
    void Toar2(int Ptr, int Value) {
      A[Ptr + 1] = Value;
      A[Ptr] = (unsigned)Value >> 8;
    }
    void Toar4(int Ptr, int Value) {
      int I;
      for (I = 0; I <= 3; I++) A[Ptr + I] = *Byteinteger(Addr(Value) + I);
    }
    void Toar8(int Ptr, double Value) {
      int I;
      for (I = 0; I <= 7; I++) A[Ptr + I] = *Byteinteger(Addr(Value) + I);
    }
    int Fromar2(int Ptr) { return (A[Ptr] << 8 | A[Ptr + 1]); }
    int Fromar4(int Ptr) { return (A[Ptr] << 24 | A[Ptr + 1] << 16 | A[Ptr + 2] << 8 | A[Ptr + 3]); }
    _imp_string Printname(int N) {
      int V;
      int K;
      _imp_string S;
      V = Word[N];
      K = *Byteinteger(Dictbase + V);
      if (!K)
        S = _imp_str_literal("???");
      else
        S = *String(Dictbase + V);
      return (S);
    }
    void Prhex(int Value, int Places) {
      static const 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 Printlist(int Head) {
      int I;
      int J;
      int K;
      Printstring(_imp_str_literal("\nPRINT OF LIST "));
      Write(Head, 2);
      Newline();
      while (Head) {
        From123(Head, I, J, K);
        Write(Head, 3);
        Spaces(3);
        Prhex(I, 8);
        Spaces(3);
        Prhex(J, 8);
        Spaces(3);
        Prhex(K, 8);
        Newline();
        Mlink(Head);
        Head = Head & 0xFFFF;
      }
    }
    void Checkasl(void) {
      int N;
      int Q;
      Q = Asl;
      N = 0;
      while (Q) {
        N++;
        Q = Aslist[Q].Link;
      }
      Newline();
      Printstring(_imp_str_literal("FREE CELLS AFTER LINE "));
      Write(Line, 3);
      Printsymbol('=');
      Write(N, 3);
    }
    int Morespace(void) {
      int I;
      int N;
      int Cl;
      int Amount;
      N = Aslcurbtm - 1;
      Amount = (unsigned)(Nnames + 1) >> 3;
      I = Aslcurbtm - ((unsigned)(Constptr + 8) >> 2);
      if ((unsigned)I >> 1 < Amount) {
        Amount = (unsigned)I >> 1;
        Aslwarn = 1;
      }
      if (Amount < 20) Amount = 0;
      Aslcurbtm -= Amount;
      if (Aslcurbtm <= 1) Aslcurbtm = 1;
      Cl = 4 * Aslcurbtm - 8;
      if (Aslcurbtm >= N || Constptr > Cl) {
        Aslcurbtm = N + 1;
        for (I = 12; I >= 1; I--)
          if (Dvheads[I]) Clearlist(Dvheads[I]);
        if (Asl) return (Asl);
        Fault(107, 0);
      } else
        Constlimit = Cl;
      for (I = Aslcurbtm; I <= N - 1; I++) Aslist[I + 1].Link = I;
      Aslist[Aslcurbtm].Link = 0;
      Asl = N;
      return (N);
    }
    void Push(int *Cell, int S1, int S2, int S3) {
      Listf *Lcell;
      int I;
      I = Asl;
      if (!I) I = Morespace();
      Lcell = &Aslist[I];
      Asl = Lcell->Link;
      Lcell->Link = *Cell;
      *Cell = I;
      Lcell->S1 = S1;
      Lcell->S2 = S2;
      Lcell->S3 = S3;
    }
    void Pop(int *Cell, int *S1, int *S2, int *S3) {
      Listf *Lcell;
      int I;
      I = *Cell;
      Lcell = &Aslist[I];
      *S1 = Lcell->* S1;
      *S2 = Lcell->* S2;
      *S3 = Lcell->* S3;
      if (I) {
        *Cell = Lcell->Link;
        Lcell->Link = Asl;
        Asl = I;
      }
    }
    void Replace1(int Cell, int S1) { Aslist[Cell].S1 = S1; }
    void Replace2(int Cell, int S2) { Aslist[Cell].S2 = S2; }
    void Replace3(int Cell, int S3) { Aslist[Cell].S3 = S3; }
    void Binsert(int *Top, int *Bot, int S1, int S2, int S3) {
      int I;
      int J;
      Listf *Lcell;
      I = Asl;
      if (!I) I = Morespace();
      Lcell = &Aslist[I];
      Asl = Lcell->Link;
      Lcell->S1 = S1;
      Lcell->S2 = S2;
      Lcell->S3 = S3;
      Lcell->Link = 0;
      J = *Bot;
      if (!J) {
        *Bot = I;
        *Top = *Bot;
      } else {
        Aslist[J].Link = I;
        *Bot = I;
      }
    }
    void Insertatend(int *Cell, int S1, int S2, int S3) {
      int I;
      int J;
      int N;
      Listf *Lcell;
      I = *Cell;
      J = I;
      while (I) {
        J = I;
        I = Aslist[J].Link;
      }
      N = Asl;
      if (!N) N = Morespace();
      Lcell = &Aslist[N];
      Asl = Lcell->Link;
      if (!J)
        *Cell = N;
      else
        Aslist[J].Link = N;
      Lcell->S1 = S1;
      Lcell->S2 = S2;
      Lcell->S3 = S3;
      Lcell->Link = 0;
    }
    void Replace123(int Cell, int S1, int S2, int S3) {
      Aslist[Cell].S1 = S1;
      Aslist[Cell].S2 = S2;
      Aslist[Cell].S3 = S3;
    }
    void Mlink(int *Cell) { *Cell = Aslist[*Cell].Link; }
    int Find(int Lab, int List) {
      while (List) {
        if (Lab == Aslist[List].S2) return (List);
        List = Aslist[List].Link;
      }
      return (-1);
    }
    void From123(int Cell, int *S1, int *S2, int *S3) {
      Listf *Lcell;
      Lcell = &Aslist[Cell];
      *S1 = Lcell->* S1;
      *S2 = Lcell->* S2;
      *S3 = Lcell->* S3;
    }
    void From12(int Cell, int *S1, int *S2) {
      Listf *Lcell;
      Lcell = &Aslist[Cell];
      *S1 = Lcell->* S1;
      *S2 = Lcell->* S2;
    }
    int From1(int Cell) { return (Aslist[Cell].S1); }
    int From2(int Cell) { return (Aslist[Cell].S2); }
    int From3(int Cell) { return (Aslist[Cell].S3); }
    void Clearlist(int *Ophead) {
      int I;
      int J;
      I = *Ophead;
      J = I;
      while (I) {
        J = I;
        I = Aslist[J].Link;
      }
      if (J) {
        Aslist[J].Link = Asl;
        Asl = *Ophead;
        *Ophead = 0;
      }
    }
  }
  exit(0);
  return (1);
}
