#line 1
#include <perms.h>
// Edinburgh IMP77 Compiler - Version 8.4
//
// 1 {%MAINEP ICL9CEZIMP
// 2 {%TRUSTEDPROGRAM
// 3 %BEGIN
#line 3 "test-new/nrimp10s-77.imp"
int main(int argc, char **argv) { /*%begin*/
#line 3 "test-new/nrimp10s-77.imp"
_imp_initialise(argc, argv);
// 4 %string(127)%fn ITOS(%integer v,p)
#line 4 "test-new/nrimp10s-77.imp"
_imp_string127 ITOS(int V, int P) {
// 5 %integer vv,q,pos
#line 5 "test-new/nrimp10s-77.imp"
int VV;
#line 5 "test-new/nrimp10s-77.imp"
int Q;
#line 5 "test-new/nrimp10s-77.imp"
int POS;
// 6 %byteintegerarray store(0:127)
#line 6 "test-new/nrimp10s-77.imp"
unsigned char STORE[128];
// 7
// 8 vv = v; vv = -vv %if vv > 0
#line 8 "test-new/nrimp10s-77.imp"
VV = V;
#line 8 "test-new/nrimp10s-77.imp"
if (VV <= 0) goto L_0001;
#line 8 "test-new/nrimp10s-77.imp"
VV = -VV;
#line 8 "test-new/nrimp10s-77.imp"
L_0001:;
// 9 pos = 127
#line 9 "test-new/nrimp10s-77.imp"
POS = 127;
// 10 %while vv <= -10 %cycle
#line 10 "test-new/nrimp10s-77.imp"
L_0002:;
#line 10 "test-new/nrimp10s-77.imp"
if (VV > -10) goto L_0003;
// 11 q = vv//10
#line 11 "test-new/nrimp10s-77.imp"
Q = ((long)VV / (long)10);
// 12 store(pos) = q*10-vv+'0'; pos = pos-1
#line 12 "test-new/nrimp10s-77.imp"
STORE[POS] = Q * 10 - VV + 48;
#line 12 "test-new/nrimp10s-77.imp"
POS = POS - 1;
// 13 vv = q
#line 13 "test-new/nrimp10s-77.imp"
VV = Q;
// 14 %repeat
#line 14 "test-new/nrimp10s-77.imp"
goto L_0002;
#line 14 "test-new/nrimp10s-77.imp"
L_0003:;
// 15 store(pos) = '0'-vv
#line 15 "test-new/nrimp10s-77.imp"
STORE[POS] = 48 - VV;
// 16 %if p <= 0 %start
#line 16 "test-new/nrimp10s-77.imp"
if (P > 0) goto L_0004;
// 17 p = 128+p
#line 17 "test-new/nrimp10s-77.imp"
P = 128 + P;
// 18 %else
#line 18 "test-new/nrimp10s-77.imp"
goto L_0005;
#line 18 "test-new/nrimp10s-77.imp"
L_0004:;
// 19 p = 128-p
#line 19 "test-new/nrimp10s-77.imp"
P = 128 - P;
// 20 p = pos %if p > pos
#line 20 "test-new/nrimp10s-77.imp"
if (P <= POS) goto L_0006;
#line 20 "test-new/nrimp10s-77.imp"
P = POS;
#line 20 "test-new/nrimp10s-77.imp"
L_0006:;
// 21 p = p-1
#line 21 "test-new/nrimp10s-77.imp"
P = P - 1;
// 22 %finish
#line 22 "test-new/nrimp10s-77.imp"
L_0005:;
// 23 pos = pos-1 %and store(pos) = '-' %if v < 0
#line 23 "test-new/nrimp10s-77.imp"
if (V >= 0) goto L_0007;
#line 23 "test-new/nrimp10s-77.imp"
POS = POS - 1;
#line 23 "test-new/nrimp10s-77.imp"
STORE[POS] = 45;
#line 23 "test-new/nrimp10s-77.imp"
L_0007:;
// 24 %while pos > p %and pos > 1 %cycle
#line 24 "test-new/nrimp10s-77.imp"
L_0008:;
#line 24 "test-new/nrimp10s-77.imp"
if (POS <= P) goto L_0009;
#line 24 "test-new/nrimp10s-77.imp"
if (POS <= 1) goto L_0009;
// 25 pos = pos-1; store(pos) = ' '
#line 25 "test-new/nrimp10s-77.imp"
POS = POS - 1;
#line 25 "test-new/nrimp10s-77.imp"
STORE[POS] = 32;
// 26 %repeat
#line 26 "test-new/nrimp10s-77.imp"
goto L_0008;
#line 26 "test-new/nrimp10s-77.imp"
L_0009:;
// 27 pos = pos-1; store(pos) = 127-pos
#line 27 "test-new/nrimp10s-77.imp"
POS = POS - 1;
#line 27 "test-new/nrimp10s-77.imp"
STORE[POS] = 127 - POS;
// 28 %result = string(addr(store(pos)))
#line 28 "test-new/nrimp10s-77.imp"
return *(_imp_string127 *)_imp_STRING(_imp_ADDR(/*?*/ &STORE[POS]));
// 29 %end
#line 29 "test-new/nrimp10s-77.imp"
} /* end of ITOS */
// 30
// 31 %integermap LONGINTEGER(%integer Addr)
#line 31 "test-new/nrimp10s-77.imp"
int *LONGINTEGER(int ADDR)
#line 31 "test-new/nrimp10s-77.imp"
{
// 32 %result == INTEGER(Addr)
#line 32 "test-new/nrimp10s-77.imp"
return _imp_INTEGER(ADDR);
// 33 %end
#line 33 "test-new/nrimp10s-77.imp"
} /* end of LONGINTEGER */
// 34 %routine pprofile
#line 34 "test-new/nrimp10s-77.imp"
void PPROFILE(void) {
// 35 %end
#line 35 "test-new/nrimp10s-77.imp"
return;
#line 35 "test-new/nrimp10s-77.imp"
} /* end of PPROFILE */
// 36 %routine print ch(%integer I)
#line 36 "test-new/nrimp10s-77.imp"
void PRINTCH(int I) {
// 37 print symbol(I)
#line 37 "test-new/nrimp10s-77.imp"
_imp_PRINTSYMBOL(I);
// 38 %end
#line 38 "test-new/nrimp10s-77.imp"
return;
#line 38 "test-new/nrimp10s-77.imp"
} /* end of PRINTCH */
// 39 %routine newpage
#line 39 "test-new/nrimp10s-77.imp"
void NEWPAGE(void) {
// 40 print ch(12)
#line 40 "test-new/nrimp10s-77.imp"
PRINTCH(12);
// 41 %end
#line 41 "test-new/nrimp10s-77.imp"
return;
#line 41 "test-new/nrimp10s-77.imp"
} /* end of NEWPAGE */
// 42 %integerfn IMOD(%integer I)
#line 42 "test-new/nrimp10s-77.imp"
int IMOD(int I) {
// 43 %result = |I|
#line 43 "test-new/nrimp10s-77.imp"
return _imp_IMOD(I);
// 44 %end
#line 44 "test-new/nrimp10s-77.imp"
} /* end of IMOD */
// 45 %realfn MOD(%real R)
#line 45 "test-new/nrimp10s-77.imp"
float MOD(float R) {
// 46 %result = |R|
#line 46 "test-new/nrimp10s-77.imp"
return _imp_MOD(R);
// 47 %end
#line 47 "test-new/nrimp10s-77.imp"
} /* end of MOD */
// 48 %realfn FRACPT(%real r)
#line 48 "test-new/nrimp10s-77.imp"
float FRACPT(float R) {
// 49 %result = r-INTPT(r)
#line 49 "test-new/nrimp10s-77.imp"
return R - _imp_INTPT(R);
// 50 %end
#line 50 "test-new/nrimp10s-77.imp"
} /* end of FRACPT */
// 51 %CONSTINTEGER RELEASE=10
// 52 %CONSTINTEGER YES=1,NO=0
// 53 %CONSTINTEGER USE IMP=YES
// 54 %CONSTINTEGER VMEB=NO
// 55 %CONSTSTRING(9) LADATE="28 Jan 81"; ! LAST ALTERED
#line 55 "test-new/nrimp10s-77.imp"
const _imp_string9 LADATE = _imp_str_init("28 Jan 81");
// 56 %INTEGER I, J, K
#line 56 "test-new/nrimp10s-77.imp"
int I;
#line 56 "test-new/nrimp10s-77.imp"
int J;
#line 56 "test-new/nrimp10s-77.imp"
int K;
// 57 ! PRODUCED BY OLDPS FROM NRIMPPS8 ON 16/12/80
// 58 %CONSTBYTEINTEGERARRAY CLETT(0: 500)= 1,
#line 58 "test-new/nrimp10s-77.imp"
const unsigned char CLETT[501] = {
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};
// 59+ 43, 1, 45, 1, 40, 1, 41, 1, 44, 2, 201, 198, 6, 213,
// 60+ 206, 204, 197, 211, 211, 5, 215, 200, 201, 204, 197, 5, 213, 206,
// 61+ 212, 201, 204, 3, 198, 207, 210, 1, 61, 4, 210, 197, 193, 204,
// 62+ 7, 201, 206, 212, 197, 199, 197, 210, 8, 204, 207, 206, 199, 210,
// 63+ 197, 193, 204, 4, 204, 207, 206, 199, 11, 194, 217, 212, 197, 201,
// 64+ 206, 212, 197, 199, 197, 210, 6, 211, 212, 210, 201, 206, 199, 11,
// 65+ 200, 193, 204, 198, 201, 206, 212, 197, 199, 197, 210, 7, 210, 207,
// 66+ 213, 212, 201, 206, 197, 2, 198, 206, 3, 205, 193, 208, 8, 198,
// 67+ 213, 206, 195, 212, 201, 207, 206, 6, 210, 197, 195, 207, 210, 196,
// 68+ 4, 206, 193, 205, 197, 5, 193, 210, 210, 193, 217, 9, 193, 210,
// 69+ 210, 193, 217, 206, 193, 205, 197, 9, 207, 198, 208, 210, 207, 199,
// 70+ 210, 193, 205, 6, 207, 198, 198, 201, 204, 197, 6, 207, 198, 204,
// 71+ 201, 211, 212, 6, 198, 207, 210, 205, 193, 212, 4, 211, 208, 197,
// 72+ 195, 3, 206, 207, 212, 3, 193, 206, 196, 2, 207, 210, 1, 58,
// 73+ 6, 206, 207, 210, 205, 193, 204, 3, 207, 215, 206, 8, 197, 216,
// 74+ 212, 197, 210, 206, 193, 204, 9, 197, 216, 212, 210, 201, 206, 211,
// 75+ 201, 195, 8, 195, 207, 206, 211, 212, 193, 206, 212, 5, 195, 207,
// 76+ 206, 211, 212, 5, 197, 214, 197, 206, 212, 5, 211, 212, 193, 210,
// 77+ 212, 9, 212, 200, 197, 206, 211, 212, 193, 210, 212, 4, 212, 200,
// 78+ 197, 206, 9, 197, 204, 211, 197, 211, 212, 193, 210, 212, 4, 197,
// 79+ 204, 211, 197, 1, 95, 6, 211, 217, 211, 212, 197, 205, 7, 196,
// 80+ 217, 206, 193, 205, 201, 195, 2, 42, 61, 1, 42, 4, 80, 85,
// 81+ 84, 95, 5, 67, 78, 79, 80, 95, 2, 204, 61, 1, 60, 1,
// 82+ 62, 4, 40, 196, 210, 43, 2, 196, 210, 1, 194, 3, 212, 207,
// 83+ 211, 3, 204, 206, 194, 3, 216, 206, 194, 2, 208, 195, 3, 195,
// 84+ 212, 194, 2, 45, 62, 6, 210, 197, 212, 213, 210, 206, 6, 210,
// 85+ 197, 211, 213, 204, 212, 7, 205, 207, 206, 201, 212, 207, 210, 4,
// 86+ 211, 212, 207, 208, 6, 211, 201, 199, 206, 193, 204, 4, 197, 216,
// 87+ 201, 212, 8, 195, 207, 206, 212, 201, 206, 213, 197, 6, 198, 201,
// 88+ 206, 201, 211, 200, 5, 195, 217, 195, 204, 197, 6, 210, 197, 208,
// 89+ 197, 193, 212, 3, 197, 206, 196, 5, 210, 197, 193, 204, 211, 5,
// 90+ 194, 197, 199, 201, 206, 2, 207, 206, 6, 211, 215, 201, 212, 195,
// 91+ 200, 4, 204, 201, 211, 212, 7, 211, 208, 197, 195, 201, 193, 204,
// 92+ 14, 212, 210, 213, 211, 212, 197, 196, 208, 210, 207, 199, 210, 193,
// 93+ 205, 6, 205, 193, 201, 206, 197, 208, 7, 195, 207, 206, 212, 210,
// 94+ 207, 204, 7, 201, 206, 195, 204, 213, 196, 197;
// 95
// 96
// 97
// 98
// 99 {%CONST}%ownINTEGERARRAY SYMBOL(1300: 2213)= 1307,
#line 99 "test-new/nrimp10s-77.imp"
static int SYMBOL[914] = {
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};
// 100+ 1303, 0, 1305, 2, 1307, 1000, 1319, 1312, 1001, 1357,
// 101+ 1824, 1315, 1003, 1020, 1319, 4, 1336, 6, 1329, 1323,
// 102+ 1001, 1014, 1325, 1003, 1329, 4, 1329, 6, 1336, 1336,
// 103+ 1010, 1028, 1319, 1011, 1350, 1343, 1343, 1010, 1028, 1307,
// 104+ 1011, 1343, 1350, 1348, 1026, 1307, 999, 1350, 1000, 1357,
// 105+ 1355, 1026, 1319, 999, 1357, 1000, 1365, 1363, 4, 1336,
// 106+ 1365, 6, 1365, 1000, 1372, 1370, 8, 1336, 999, 1372,
// 107+ 1000, 1377, 1375, 10, 1377, 13, 1401, 1384, 20, 1010,
// 108+ 1542, 1562, 1011, 1390, 26, 1010, 1542, 1562, 1011, 1401,
// 109+ 32, 1010, 1001, 36, 1336, 8, 1336, 8, 1336, 1011,
// 110+ 1408, 1406, 8, 1001, 999, 1408, 1000, 1415, 1411, 38,
// 111+ 1413, 43, 1415, 51, 1430, 1418, 43, 1420, 38, 1423,
// 112+ 60, 1408, 1425, 65, 1428, 77, 1925, 1430, 84, 1437,
// 113+ 1433, 96, 1437, 1031, 1415, 1437, 1444, 1440, 104, 1442,
// 114+ 107, 1444, 111, 1466, 1450, 1415, 1476, 1001, 1401, 1456,
// 115+ 120, 1466, 127, 1001, 1401, 1462, 1430, 1471, 1001, 1401,
// 116+ 1483, 1466, 127, 1001, 1401, 1471, 1469, 132, 1471, 1000,
// 117+ 1476, 1474, 127, 1476, 1000, 1483, 1479, 138, 1481, 127,
// 118+ 1483, 1000, 1493, 1491, 4, 1010, 1444, 1011, 1493, 6,
// 119+ 1493, 1000, 1502, 1500, 1030, 1010, 1444, 1011, 999, 1502,
// 120+ 1000, 1513, 1506, 148, 1016, 1508, 158, 1511, 165, 1018,
// 121+ 1513, 1016, 1518, 1516, 172, 1518, 1000, 1542, 1526, 172,
// 122+ 1001, 4, 1876, 1869, 6, 1535, 179, 1010, 1001, 1818,
// 123+ 1011, 4, 1001, 6, 1542, 1010, 1615, 1011, 4, 1001,
// 124+ 6, 1556, 1548, 1336, 1032, 1336, 1556, 1553, 4, 1542,
// 125+ 1562, 6, 1556, 184, 1542, 1562, 1560, 1037, 1336, 1562,
// 126+ 1000, 1573, 1567, 188, 1542, 1573, 1571, 192, 1542, 1580,
// 127+ 1573, 1000, 1580, 1578, 188, 1542, 999, 1580, 1000, 1587,
// 128+ 1585, 192, 1542, 999, 1587, 1000, 1595, 1591, 1033, 1336,
// 129+ 1593, 195, 1595, 1000, 1601, 1599, 179, 1008, 1601, 1015,
// 130+ 1606, 1604, 60, 1606, 197, 1615, 1613, 8, 1336, 195,
// 131+ 1336, 1606, 1615, 1000, 1624, 1620, 1476, 1001, 1401, 1624,
// 132+ 132, 1513, 1624, 1630, 1630, 1001, 1401, 1832, 1630, 1636,
// 133+ 1634, 8, 1624, 1636, 1000, 1652, 1646, 1476, 1010, 1001,
// 134+ 1401, 1840, 1011, 1652, 1006, 1652, 132, 1513, 1001, 1832,
// 135+ 1701, 1663, 1661, 8, 1010, 1001, 1401, 1840, 1011, 1652,
// 136+ 1663, 1000, 1674, 1666, 204, 1668, 208, 1670, 217, 1672,
// 137+ 227, 1674, 236, 1701, 1678, 1415, 1636, 1689, 120, 1476,
// 138+ 1010, 1001, 1401, 1011, 4, 1001, 6, 1006, 1701, 120,
// 139+ 132, 1513, 1010, 1001, 1832, 1011, 4, 1001, 6, 1006,
// 140+ 1711, 1709, 36, 1028, 1319, 1350, 1722, 1711, 1711, 1000,
// 141+ 1722, 1720, 8, 1012, 1028, 1319, 1350, 1722, 999, 1722,
// 142+ 1000, 1731, 1729, 4, 1028, 1319, 1350, 6, 1731, 1000,
// 143+ 1738, 1736, 8, 1009, 999, 1738, 1000, 1743, 1741, 242,
// 144+ 1743, 1000, 1749, 1747, 8, 1336, 1749, 1000, 1762, 1760,
// 145+ 8, 1001, 1401, 4, 1336, 195, 1336, 6, 999, 1762,
// 146+ 1000, 1769, 1767, 26, 1542, 1562, 1769, 1000, 1782, 1772,
// 147+ 1019, 1774, 1006, 1779, 1372, 1542, 1562, 1006, 1782, 1377,
// 148+ 1006, 1795, 1786, 248, 1034, 1789, 254, 1034, 1795, 264,
// 149+ 1010, 2060, 1011, 1801, 1801, 1799, 188, 2060, 1801, 1000,
// 150+ 1818, 1805, 269, 1034, 1813, 279, 1372, 1010, 1542, 1562,
// 151+ 1011, 1782, 1816, 279, 2060, 1818, 1000, 1824, 1822, 284,
// 152+ 1001, 1824, 1000, 1832, 1830, 284, 1001, 1357, 1824, 1832,
// 153+ 1000, 1840, 1840, 4, 1336, 195, 1336, 1606, 6, 1848,
// 154+ 1846, 36, 1028, 1319, 1350, 1848, 1000, 1858, 1852, 286,
// 155+ 1013, 1854, 208, 1856, 293, 1858, 1000, 1869, 1867, 1001,
// 156+ 36, 1336, 8, 1336, 8, 1336, 1869, 1000, 1876, 1874,
// 157+ 8, 1876, 999, 1876, 1000, 1916, 1882, 1415, 1476, 1001,
// 158+ 1401, 1889, 1415, 132, 1001, 1401, 1832, 1916, 1895, 120,
// 159+ 1466, 127, 1001, 1401, 1904, 120, 1010, 1001, 1401, 1011,
// 160+ 4, 1001, 6, 1916, 120, 132, 1010, 1001, 1401, 1832,
// 161+ 1916, 1011, 4, 1001, 6, 1925, 1923, 8, 1001, 1401,
// 162+ 1832, 999, 1925, 1000, 1932, 1930, 4, 1009, 6, 1932,
// 163+ 1000, 1950, 1936, 301, 1001, 1939, 304, 1001, 1942, 306,
// 164+ 1002, 1945, 1022, 1950, 1950, 311, 1009, 8, 1009, 1964,
// 165+ 1954, 1023, 1964, 1959, 1024, 317, 2003, 2008, 1964, 1025,
// 166+ 1005, 8, 1987, 1987, 1969, 320, 1001, 322, 1971, 2036,
// 167+ 1976, 4, 2036, 2025, 6, 1980, 324, 2036, 6, 1985,
// 168+ 4, 329, 2025, 6, 1987, 332, 2003, 1992, 320, 1001,
// 169+ 322, 1994, 2036, 1999, 4, 329, 2025, 6, 2003, 324,
// 170+ 1005, 6, 2008, 2006, 329, 2008, 1005, 2016, 2014, 8,
// 171+ 1005, 8, 1005, 2016, 1000, 2025, 2020, 0, 1005, 2023,
// 172+ 2, 1005, 2025, 1000, 2031, 2029, 0, 332, 2031, 1000,
// 173+ 2036, 2034, 36, 2036, 1000, 2051, 2041, 2031, 1300, 1003,
// 174+ 2044, 1001, 2016, 2049, 4, 2051, 2016, 6, 2051, 334,
// 175+ 2060, 2054, 338, 2056, 342, 2058, 346, 2060, 349, 2093,
// 176+ 2069, 1010, 1001, 1357, 1824, 1011, 1587, 1795, 2073, 353,
// 177+ 1001, 1357, 2075, 356, 2079, 363, 1033, 1336, 2082, 370,
// 178+ 1795, 2084, 378, 2089, 383, 1738, 1009, 1743, 2091, 390,
// 179+ 2093, 395, 2214, 2100, 1027, 1010, 2060, 1011, 1769, 2102,
// 180+ 1007, 2110, 1372, 1010, 1542, 1562, 1011, 1782, 1006, 2115,
// 181+ 404, 1035, 1801, 1006, 2120, 411, 1029, 1858, 1006, 2125,
// 182+ 417, 1036, 1762, 1006, 2130, 1377, 411, 1029, 1006, 2136,
// 183+ 1031, 1008, 1415, 1615, 1006, 2140, 424, 1502, 1006, 2144,
// 184+ 120, 1518, 1006, 2153, 1010, 1848, 1430, 1011, 1595, 1001,
// 185+ 1483, 1006, 2156, 1663, 1674, 2160, 428, 1601, 1006, 2164,
// 186+ 434, 1015, 1006, 2173, 440, 1021, 1738, 1009, 1731, 248,
// 187+ 1034, 1006, 2184, 443, 1001, 1401, 4, 1336, 195, 1336,
// 188+ 6, 1749, 1006, 2188, 450, 1006, 1017, 2193, 455, 127,
// 189+ 1001, 1006, 2197, 304, 1932, 1006, 2200, 463, 1006, 2204,
// 190+ 478, 1001, 1006, 2208, 485, 1003, 1006, 2212, 493, 1003,
// 191+ 1038, 2214, 1006;
// 192
// 193 %CONSTINTEGER SS= 2093
// 194
// 195 !
// 196 %CONST %BYTE %INTEGER %ARRAY I TO E TAB(0 : 127) = {%C
#line 196 "test-new/nrimp10s-77.imp"
const unsigned char ITOETAB[128] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 21, 64, 12, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 79, 127, 123, 91, 108, 80, 125, 77, 93, 92, 78,
107, 96, 75, 97, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 122, 94, 76, 126, 110, 111, 124, 193,
194, 195, 196, 197, 198, 199, 200, 201, 209, 210, 211, 212, 213, 214, 215, 216, 217, 226, 227, 228, 229, 230,
231, 232, 233, 74, 95, 90, 106, 109, 124, 129, 130, 131, 132, 133, 134, 135, 136, 137, 145, 146, 147, 148,
149, 150, 151, 152, 153, 162, 163, 164, 165, 166, 167, 168, 169, 192, 64, 208, 64, 64};
// 197+ 16_40,16_40,16_40,16_40,16_40,16_40,16_40,16_40,
// 198+ 16_40,16_40,16_15,16_40,16_0C,16_40,16_40,16_40,
// 199+ 16_40,16_40,16_40,16_40,16_40,16_40,16_40,16_40,
// 200+ 16_40,16_40,16_40,16_40,16_40,16_40,16_40,16_40,
// 201+ 16_40,16_4F,16_7F,16_7B,16_5B,16_6C,16_50,16_7D,
// 202+ 16_4D,16_5D,16_5C,16_4E,16_6B,16_60,16_4B,16_61,
// 203+ 16_F0,16_F1,16_F2,16_F3,16_F4,16_F5,16_F6,16_F7,
// 204+ 16_F8,16_F9,16_7A,16_5E,16_4C,16_7E,16_6E,16_6F,
// 205+ 16_7C,16_C1,16_C2,16_C3,16_C4,16_C5,16_C6,16_C7,
// 206+ 16_C8,16_C9,16_D1,16_D2,16_D3,16_D4,16_D5,16_D6,
// 207+ 16_D7,16_D8,16_D9,16_E2,16_E3,16_E4,16_E5,16_E6,
// 208+ 16_E7,16_E8,16_E9,16_4A,16_5F,16_5A,16_6A,16_6D,
// 209+ 16_7C,16_81,16_82,16_83,16_84,16_85,16_86,16_87,
// 210+ 16_88,16_89,16_91,16_92,16_93,16_94,16_95,16_96,
// 211+ 16_97,16_98,16_99,16_A2,16_A3,16_A4,16_A5,16_A6,
// 212+ 16_A7,16_A8,16_A9,16_C0,16_40,16_D0,16_40,16_40
// 213 %CONSTINTEGERARRAY OPC(0:126)=0,
#line 213 "test-new/nrimp10s-77.imp"
const int OPC[127] = {
0, 541737795, 541737300, 541737286, [4 ... 7] = 0, 542523724, 541284676, 1229865793, 1297040452,
1347568460, 538976330, 541740107, 1128352844, 541148226, 542327362, 1145389642, 541282370, 542329159,
541940034, 542526809, 1129335106, 541868884, 1297109842, 1129337682, 1398031188, 1163413844, 1163085144,
542070100, 541147988, 538989388, 1397510995, 1397510980, 1397510993, 538989396, 1398035784, 1398036558,
1229212741, 542329924, 542329922, 1413760323, 1229865812, 542331972, 542331970, 1398033486, 1398035270,
538976332, 541872979, 541872964, 541872977, 1381127235, 541873480, 1380011086, 541152070, 1279545932,
541869121, 1279546434, 541869122, 538987588, 538987586, 541871182, 541874254, 542393160, 1095648339,
542069331, 1313165651, 1163415617, 541150788, 538988370, 542000465, 538988619, 541675091, 1398100043,
541415504, 1129270593, 541344854, 1146242134, 1145914454, 1398228305, 1398230597, 541282387, 542397522,
541477972, 541672534, 1230128214, 1229800534, 541939276, 538987862, 1128812374, 541282125, 541477208,
542262358, 1381123158, 1380210244, 542458180, 542462786, 1431458626, 542458704, 542462792, 542265172,
542328915, 542328922, 541344068, 541348674, 1146245954, 541344592, 541348680, 541347161, 1145919812,
1128417614, 541671748, 541676354, 1230132034, 541672272, 541676360, 541674841, 1229805892, 1128547651,
542261572, 542266178, 1381126978, 542262096, 542266179, 542264665, 1380800836};
// 214+ M' JCC',M' JAT',M' JAF',0(4),
// 215+ M' VAL',M' CYD',M'INCA',M'MODD',M'PRCL',M' J',M' JLK',M'CALL',
// 216+ M' ADB',M' SBB',M'DEBJ',M' CPB',M' SIG',M' MYB',M' VMY',M'CPIB',
// 217+ M' LCT',M'MPSR',M'CPSR',M'STCT',M'EXIT',M'ESEX',M' OUT',M' ACT',
// 218+ M' SL',M'SLSS',M'SLSD',M'SLSQ',M' ST',M'STUH',M'STXN',M'IDLE',
// 219+ M' SLD',M' SLB',M'TDEC',M'INCT',M' STD',M' STB',M'STLN',M'STSF',
// 220+ M' L',M' LSS',M' LSD',M' LSQ',M'RRTC',M' LUH',M'RALN',M' ASF',
// 221+ M'LDRL',M' LDA',M'LDTB',M' LDB',M' LD',M' LB',M' LLN',M' LXN',
// 222+ M' TCH',M'ANDS',M' ORS',M'NEQS',M'EXPA',M' AND',M' OR',M' NEQ',
// 223+ M' PK',M' INS',M'SUPK',M' EXP',M'COMA',M' DDV',M'DRDV',M'DMDV',
// 224+ M'SWEQ',M'SWNE',M' CPS',M' TTR',M' FLT',M' IDV',M'IRDV',M'IMDV',
// 225+ M' MVL',M' MV',M'CHOV',M' COM',M' FIX',M' RDV',M'RRDV',M'RDVD',
// 226+ M' UAD',M' USB',M'URSB',M' UCP',M' USH',M' ROT',M' SHS',M' SHZ',
// 227+ M' DAD',M' DSB',M'DRSB',M' DCP',M' DSH',M' DMY',M'DMYD',M'CBIN',
// 228+ M' IAD',M' ISB',M'IRSB',M' ICP',M' ISH',M' IMY',M'IMYD',M'CDEC',
// 229+ M' RAD',M' RSB',M'RRSB',M' RCP',M' RSC',M' RMY',M'RMYD';
// 230 %CONSTBYTEINTEGERARRAY ONE CASE(0 : 127) = {%C
#line 230 "test-new/nrimp10s-77.imp"
const unsigned char ONECASE[128] = {
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};
// 231+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
// 232+ 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
// 233+ 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
// 234+ 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
// 235+ 64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
// 236+ 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
// 237+ 96,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
// 238+ 80,81,82,83,84,85,86,87,88,89,90,123,124,125,126,127;
// 239 %CONSTINTEGERARRAY TSNAME (0:62)=16_1000(8),
#line 239 "test-new/nrimp10s-77.imp"
const int TSNAME[63] = {[0 ... 7] = 4096,
4097,
[9 ... 13] = 4096,
4097,
4194,
[16 ... 17] = 4097,
4194,
[19 ... 20] = 4096,
82,
81,
98,
[24 ... 30] = 4194,
4096,
49,
81,
[34 ... 35] = 4194,
49,
4096,
81,
98,
[40 ... 41] = 4096,
53,
4096,
4149,
49,
53,
4149,
51,
0,
4096,
49,
82,
81,
97,
114,
97,
114,
81,
98,
4177,
65,
4096};
// 240+ 16_1001,16_1000(5),16_1001,16_1062,16_1001(2),16_1062,
// 241+ 16_1000(2),16_52,16_51,16_62,16_1062(7),
// 242+ 16_1000,16_31,16_51,16_1062(2),16_31,16_1000,
// 243+ 16_51,16_62,16_1000(2),16_35,16_1000,16_1035,
// 244+ 16_31,16_35,16_1035,16_33,0,16_1000,16_31,16_52,16_51,
// 245+ 16_61,16_72,16_61,16_72,16_51,16_62,16_1051,16_41,
// 246+ 16_1000;
// 247 !
// 248 %OWNINTEGERARRAY FIXED GLA(0:11)=0,
#line 248 "test-new/nrimp10s-77.imp"
static int FIXEDGLA[12] = {0, 1342177280, [2 ... 3] = 0, -1, 0, [6 ... 11] = 0};
// 249+ 16_50000000,0(2),-1,0,0(6);
// 250 %CONSTBYTEINTEGERARRAY BYTES(0:7)=0(3),1,2,4,8,16;
#line 250 "test-new/nrimp10s-77.imp"
const unsigned char BYTES[8] = {[0 ... 2] = 0, 1, 2, 4, 8, 16};
// 251 %CONSTBYTEINTEGERARRAY TRTAB(0:255)=0(48),
#line 251 "test-new/nrimp10s-77.imp"
const unsigned char TRTAB[256] = {[0 ... 47] = 0, [48 ... 57] = 1, [58 ... 64] = 0, [65 ... 90] = 2,
[91 ... 96] = 0, [97 ... 122] = 2, [123 ... 127] = 0, [128 ... 255] = 0};
// 252+ 1(10),0(7),2(26),0(6),2(26),0(5),0(128)
// 253 %CONSTINTEGER MAXLEVELS=31,CONCOP=13,FIXEDGLALEN=48
// 254 %CONSTINTEGER JOBBERBIT=16_40000000; ! SET IN JOBBER MODE
// 255 %CONSTINTEGER CEBIT=1; ! SET IN COMPILER ENVIRONMENT
// 256 %CONSTINTEGER MAXDICT=16_100; ! SET FOR MAX OF EVERYTHING
// 257 !
// 258 ! THE PRINCIPAL OPCODES ARE HERE DEFINED AS THEIR MNEMONICS(AMENDED)
// 259 !
// 260 %CONSTINTEGER LB=16_7A,SLB=16_52,STB=16_5A,ADB=16_20,CPB=16_26, {%C
// 261+ MYB=16_2A,SBB=16_22,CPIB=16_2E,OUT=16_3C,CPSR=16_34
// 262 %CONSTINTEGER LD=16_78,LDA=16_72,INCA=16_14,STD=16_58,LDB=16_76, {%C
// 263+ LDTB=16_74,LDRL=16_70,CYD=16_12,MODD=16_16,SLD=16_50
// 264 %CONSTINTEGER STLN=16_5C,ASF=16_6E,ST=16_48,RALN=16_6C,LXN=16_7E,{%C
// 265+ LLN=16_7C,LSS=16_62,SLSS=16_42,MPSR=16_32,STSF=16_5E,{%C
// 266+ LUH=16_6A,STUH=16_4A,LSD=16_64,SLSD=16_44,PRCL=16_18, {%C
// 267+ LSQ=16_66,SLSQ=16_46,STXN=16_4C,LCT=16_30,STCT=16_36
// 268 %CONSTINTEGER JUNC=16_1A,JLK=16_1C,CALL=16_1E,EXIT=16_38,JCC=2, {%C
// 269+ JAT=4,JAF=6,DEBJ=16_24
// 270 %CONSTINTEGER IAD=16_E0,ICP=16_E6,USH=16_C8,ISB=16_E2,IRSB=16_E4,{%C
// 271+ OR=16_8C,UCP=16_C6,IMY=16_EA,IMDV=16_AE,AND=16_8A, {%C
// 272+ ISH=16_E8,IMYD=16_EC,IDV=16_AA
// 273 %CONSTINTEGER RAD=16_F0,RSB=16_F2,RRSB=16_F4,FLT=16_A8,RRDV=16_BC, {%C
// 274+ RSC=16_F8,FIX=16_B8,RDV=16_BA,RDDV=16_BE,RMYD=16_FC, {%C
// 275+ RMY=16_FA
// 276 !
// 277 %CONSTINTEGER MVL=16_B0,MV=16_B2,SWEQ=16_A0,SWNE=16_A2,CPS=16_A4
// 278 !
// 279 ! DEFINE SOME MNEMONICS FOR THE VISIBLE REGISTERS (XCEPT LNB)
// 280 !
// 281 %CONSTINTEGER ACCR=0,DR=1,LNB=2,XNB=3,PC=4,CTB=5,TOS=6,BREG=7
// 282 %CONSTBYTEINTEGERARRAY LDCODE(0:7)=0,16_78,16_7C,16_7E,0,48,0,16_7A;
#line 282 "test-new/nrimp10s-77.imp"
const unsigned char LDCODE[8] = {0, 120, 124, 126, 0, 48, 0, 122};
// 283 !
// 284 %CONSTSTRING(8)MDEP="S#NDIAG"
#line 284 "test-new/nrimp10s-77.imp"
const _imp_string8 MDEP = _imp_str_init("S#NDIAG");
// 285 %CONSTSTRING(8)IOCPEP="S#IOCP"; ! EP FOR IOCP
#line 285 "test-new/nrimp10s-77.imp"
const _imp_string8 IOCPEP = _imp_str_init("S#IOCP");
// 286 %CONSTSTRING(11)AUXSTEP="ICL9CEAUXST";! DATA REF FOR INDIRECT AUX ST
#line 286 "test-new/nrimp10s-77.imp"
const _imp_string11 AUXSTEP = _imp_str_init("ICL9CEAUXST");
// 287 %CONSTINTEGER SNPT=16_1006; ! SPECIALNAME PTYPE
// 288 %CONSTINTEGER COMMALT=2,ENDALT=9,UNASSPAT=16_81818181,DECALT=8
// 289 !
// 290 %INTEGER DICTBASE, CONSTPTR, CONSTBTM, DFHEAD, CONSTHOLE, WKFILEAD, {%C
#line 290 "test-new/nrimp10s-77.imp"
int DICTBASE;
#line 290 "test-new/nrimp10s-77.imp"
int CONSTPTR;
#line 290 "test-new/nrimp10s-77.imp"
int CONSTBTM;
#line 290 "test-new/nrimp10s-77.imp"
int DFHEAD;
#line 290 "test-new/nrimp10s-77.imp"
int CONSTHOLE;
#line 290 "test-new/nrimp10s-77.imp"
int WKFILEAD;
#line 290 "test-new/nrimp10s-77.imp"
int WKFILEK;
#line 290 "test-new/nrimp10s-77.imp"
int DUMMYFORMAT;
#line 290 "test-new/nrimp10s-77.imp"
int P1SIZE;
#line 290 "test-new/nrimp10s-77.imp"
int LEVELINF;
#line 290 "test-new/nrimp10s-77.imp"
int IOCPDISP;
#line 290 "test-new/nrimp10s-77.imp"
int PARMBITS1;
#line 290 "test-new/nrimp10s-77.imp"
int PARMBITS2;
#line 290 "test-new/nrimp10s-77.imp"
int PARMLET;
// 291+ WKFILEK, DUMMYFORMAT, P1SIZE, LEVELINF, IOCPDISP, PARMBITS1, {%C
// 292+ PARMBITS2,PARMLET
// 293 !
// 294 %INTEGER ASL, NNAMES, ARSIZE, CABUF, PPCURR, CONSTLIMIT, OLDLINE, {%C
#line 294 "test-new/nrimp10s-77.imp"
int ASL;
#line 294 "test-new/nrimp10s-77.imp"
int NNAMES;
#line 294 "test-new/nrimp10s-77.imp"
int ARSIZE;
#line 294 "test-new/nrimp10s-77.imp"
int CABUF;
#line 294 "test-new/nrimp10s-77.imp"
int PPCURR;
#line 294 "test-new/nrimp10s-77.imp"
int CONSTLIMIT;
#line 294 "test-new/nrimp10s-77.imp"
int OLDLINE;
#line 294 "test-new/nrimp10s-77.imp"
int LINE;
#line 294 "test-new/nrimp10s-77.imp"
int LENGTH;
#line 294 "test-new/nrimp10s-77.imp"
int NEXTP;
#line 294 "test-new/nrimp10s-77.imp"
int SNUM;
#line 294 "test-new/nrimp10s-77.imp"
int RLEVEL;
#line 294 "test-new/nrimp10s-77.imp"
int NMAX;
#line 294 "test-new/nrimp10s-77.imp"
int USTPTR;
#line 294 "test-new/nrimp10s-77.imp"
int PLABEL;
#line 294 "test-new/nrimp10s-77.imp"
int LEVEL;
#line 294 "test-new/nrimp10s-77.imp"
int CA;
#line 294 "test-new/nrimp10s-77.imp"
int LASTNAME;
#line 294 "test-new/nrimp10s-77.imp"
int CDCOUNT;
#line 294 "test-new/nrimp10s-77.imp"
int ASLCURBTM;
#line 294 "test-new/nrimp10s-77.imp"
int PARMDYNAMIC;
// 295+ LINE, LENGTH, NEXTP, SNUM, RLEVEL, NMAX, USTPTR, PLABEL,{%C
// 296+ LEVEL, CA, LASTNAME, CDCOUNT, ASL CUR BTM, PARMDYNAMIC
// 297 !
// 298 %INTEGER FAULTY, HIT, INHCODE, IMPS, TTOPUT, LIST, PARMDIAG, {%C
#line 298 "test-new/nrimp10s-77.imp"
int FAULTY;
#line 298 "test-new/nrimp10s-77.imp"
int HIT;
#line 298 "test-new/nrimp10s-77.imp"
int INHCODE;
#line 298 "test-new/nrimp10s-77.imp"
int IMPS;
#line 298 "test-new/nrimp10s-77.imp"
int TTOPUT;
#line 298 "test-new/nrimp10s-77.imp"
int LIST;
#line 298 "test-new/nrimp10s-77.imp"
int PARMDIAG;
#line 298 "test-new/nrimp10s-77.imp"
int WARNFLAG;
#line 298 "test-new/nrimp10s-77.imp"
int PARMTRACE;
#line 298 "test-new/nrimp10s-77.imp"
int PARMLINE;
#line 298 "test-new/nrimp10s-77.imp"
int PARMOPT;
#line 298 "test-new/nrimp10s-77.imp"
int CTYPE;
#line 298 "test-new/nrimp10s-77.imp"
int DCOMP;
#line 298 "test-new/nrimp10s-77.imp"
int CPRMODE;
#line 298 "test-new/nrimp10s-77.imp"
int PARMCHK;
#line 298 "test-new/nrimp10s-77.imp"
int PARMARR;
#line 298 "test-new/nrimp10s-77.imp"
int ALLLONG;
#line 298 "test-new/nrimp10s-77.imp"
int PARMDBUG;
#line 298 "test-new/nrimp10s-77.imp"
int COMPILER;
#line 298 "test-new/nrimp10s-77.imp"
int LASTINST;
#line 298 "test-new/nrimp10s-77.imp"
int SMAP;
#line 298 "test-new/nrimp10s-77.imp"
int STACK;
#line 298 "test-new/nrimp10s-77.imp"
int AUXST;
#line 298 "test-new/nrimp10s-77.imp"
int PARMY;
#line 298 "test-new/nrimp10s-77.imp"
int BFFLAG;
// 299+ WARNFLAG, PARMTRACE, PARMLINE, PARMOPT, CTYPE, DCOMP, {%C
// 300+ CPRMODE, PARMCHK, PARMARR, ALLLONG, PARMDBUG,{%C
// 301+ COMPILER, LAST INST, SMAP, STACK, AUXST, PARMY, BFFLAG
// 302 !
// 303 %INTEGER RBASE, N, FREE FORMAT, PARMPROF, EXITLAB, CONTLAB, {%C
#line 303 "test-new/nrimp10s-77.imp"
int RBASE;
#line 303 "test-new/nrimp10s-77.imp"
int N;
#line 303 "test-new/nrimp10s-77.imp"
int FREEFORMAT;
#line 303 "test-new/nrimp10s-77.imp"
int PARMPROF;
#line 303 "test-new/nrimp10s-77.imp"
int EXITLAB;
#line 303 "test-new/nrimp10s-77.imp"
int CONTLAB;
#line 303 "test-new/nrimp10s-77.imp"
int Q;
#line 303 "test-new/nrimp10s-77.imp"
int R;
#line 303 "test-new/nrimp10s-77.imp"
int S;
#line 303 "test-new/nrimp10s-77.imp"
int NEST;
#line 303 "test-new/nrimp10s-77.imp"
int FNAME;
#line 303 "test-new/nrimp10s-77.imp"
int LDPTR;
#line 303 "test-new/nrimp10s-77.imp"
int GLACA;
#line 303 "test-new/nrimp10s-77.imp"
int GLACABUF;
#line 303 "test-new/nrimp10s-77.imp"
int GLACURR;
#line 303 "test-new/nrimp10s-77.imp"
int CREFHEAD;
#line 303 "test-new/nrimp10s-77.imp"
int SSTL;
#line 303 "test-new/nrimp10s-77.imp"
int QMAX;
#line 303 "test-new/nrimp10s-77.imp"
int STMTS;
#line 303 "test-new/nrimp10s-77.imp"
int LASTAT;
#line 303 "test-new/nrimp10s-77.imp"
int FILEADDR;
#line 303 "test-new/nrimp10s-77.imp"
int FILEPTR;
#line 303 "test-new/nrimp10s-77.imp"
int FILEEND;
#line 303 "test-new/nrimp10s-77.imp"
int FILESIZE;
#line 303 "test-new/nrimp10s-77.imp"
int LASTEND;
#line 303 "test-new/nrimp10s-77.imp"
int BIMSTR;
#line 303 "test-new/nrimp10s-77.imp"
int STLIMIT;
#line 303 "test-new/nrimp10s-77.imp"
int STRLINK;
#line 303 "test-new/nrimp10s-77.imp"
int RECTB;
#line 303 "test-new/nrimp10s-77.imp"
int ASLWARN;
#line 303 "test-new/nrimp10s-77.imp"
int IHEAD;
// 304+ Q, R, S, NEST, FNAME, LDPTR, GLACA, GLACABUF, {%C
// 305+ GLACURR, CREFHEAD, SSTL, QMAX, STMTS, LASTAT, {%C
// 306+ FILE ADDR, FILE PTR, FILE END, FILE SIZE, LASTEND, {%C
// 307+ BIMSTR,STLIMIT,STRLINK,RECTB,ASL WARN,IHEAD
// 308 !
// 309 %INTEGER MAX ULAB, SFLABEL
#line 309 "test-new/nrimp10s-77.imp"
int MAXULAB;
#line 309 "test-new/nrimp10s-77.imp"
int SFLABEL;
// 310 %LONGREAL CVALUE, IMAX, CTIME
#line 310 "test-new/nrimp10s-77.imp"
double CVALUE;
#line 310 "test-new/nrimp10s-77.imp"
double IMAX;
#line 310 "test-new/nrimp10s-77.imp"
double CTIME;
// 311 %STRING(31)MAINEP
#line 311 "test-new/nrimp10s-77.imp"
_imp_string31 MAINEP;
// 312 %RECORDFORMAT LISTF(%INTEGER S1,S2,S3,LINK)
#line 312 "test-new/nrimp10s-77.imp"
struct LISTF {
union {
struct {
#line 312 "test-new/nrimp10s-77.imp"
int S1;
#line 312 "test-new/nrimp10s-77.imp"
int S2;
#line 312 "test-new/nrimp10s-77.imp"
int S3;
#line 312 "test-new/nrimp10s-77.imp"
int LINK;
#line 312 "test-new/nrimp10s-77.imp"
};
};
};
// 313 %INTEGER LOGEPDISP,EXPEPDISP
#line 313 "test-new/nrimp10s-77.imp"
int LOGEPDISP;
#line 313 "test-new/nrimp10s-77.imp"
int EXPEPDISP;
// 314 !
// 315 %SYSTEMINTEGERMAPSPEC COMREG(%INTEGER N)
#line 315 "test-new/nrimp10s-77.imp"
extern int *COMREG(int N)
#line 315 "test-new/nrimp10s-77.imp"
;
// 316 %BEGIN
#line 316 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 317 FILE ADDR=COMREG(46); ! SOURCE FILE IF CLEAN
#line 317 "test-new/nrimp10s-77.imp"
FILEADDR = *COMREG(46);
// 318 PARMBITS1=COMREG(27)
#line 318 "test-new/nrimp10s-77.imp"
PARMBITS1 = *COMREG(27);
// 319 PARMBITS2=COMREG(28)
#line 319 "test-new/nrimp10s-77.imp"
PARMBITS2 = *COMREG(28);
// 320 WKFILEAD=COMREG(14)
#line 320 "test-new/nrimp10s-77.imp"
WKFILEAD = *COMREG(14);
// 321 {WKFILEK=INTEGER(WKFILEAD+8)>>10
// 322 wkfilek = 128
#line 322 "test-new/nrimp10s-77.imp"
WKFILEK = 128;
// 323 %IF FILE ADDR<=0 %THEN FILESIZE=64000 %AND FILE ADDR=0 %ELSESTART
#line 323 "test-new/nrimp10s-77.imp"
if (FILEADDR > 0) goto L_000A;
#line 323 "test-new/nrimp10s-77.imp"
FILESIZE = 64000;
#line 323 "test-new/nrimp10s-77.imp"
FILEADDR = 0;
#line 323 "test-new/nrimp10s-77.imp"
goto L_000B;
#line 323 "test-new/nrimp10s-77.imp"
L_000A:;
// 324 FILE PTR=FILE ADDR+INTEGER(FILE ADDR+4)
#line 324 "test-new/nrimp10s-77.imp"
FILEPTR = FILEADDR + *_imp_INTEGER(FILEADDR + 4);
// 325 FILE END=FILE ADDR+INTEGER(FILE ADDR)
#line 325 "test-new/nrimp10s-77.imp"
FILEEND = FILEADDR + *_imp_INTEGER(FILEADDR);
// 326 FILE SIZE=INTEGER(FILE ADDR)
#line 326 "test-new/nrimp10s-77.imp"
FILESIZE = *_imp_INTEGER(FILEADDR);
// 327 %FINISH
#line 327 "test-new/nrimp10s-77.imp"
L_000B:;
// 328 NNAMES=255
#line 328 "test-new/nrimp10s-77.imp"
NNAMES = 255;
// 329 %IF FILESIZE>10000 %THEN NNAMES=511
#line 329 "test-new/nrimp10s-77.imp"
if (FILESIZE <= 10000) goto L_000C;
#line 329 "test-new/nrimp10s-77.imp"
NNAMES = 511;
#line 329 "test-new/nrimp10s-77.imp"
L_000C:;
// 330 %IF PARMBITS1&JOBBER BIT=0 %START
#line 330 "test-new/nrimp10s-77.imp"
if (PARMBITS1 & 1073741824 != 0) goto L_000D;
// 331 %IF FILESIZE>32000 %THEN NNAMES=1023
#line 331 "test-new/nrimp10s-77.imp"
if (FILESIZE <= 32000) goto L_000E;
#line 331 "test-new/nrimp10s-77.imp"
NNAMES = 1023;
#line 331 "test-new/nrimp10s-77.imp"
L_000E:;
// 332 %IF FILESIZE>256*1024 %OR PARMBITS2&MAXDICT#0 %OR WKFILEK>512 %THEN NNAMES=2047
#line 332 "test-new/nrimp10s-77.imp"
if (FILESIZE > 256 * 1024) goto L_000F;
#line 332 "test-new/nrimp10s-77.imp"
if (PARMBITS2 & 256 != 0) goto L_000F;
#line 332 "test-new/nrimp10s-77.imp"
if (WKFILEK <= 512) goto L_0010;
#line 332 "test-new/nrimp10s-77.imp"
L_000F:;
#line 332 "test-new/nrimp10s-77.imp"
NNAMES = 2047;
#line 332 "test-new/nrimp10s-77.imp"
L_0010:;
// 333 %FINISH
#line 333 "test-new/nrimp10s-77.imp"
L_000D:;
// 334 ASL=3*NNAMES
#line 334 "test-new/nrimp10s-77.imp"
ASL = 3 * NNAMES;
// 335 ASL=4095 %IF ASL>4095 %AND PARMBITS2&MAXDICT=0;! STAY WITHIN 128K AUXSTACK
#line 335 "test-new/nrimp10s-77.imp"
if (ASL <= 4095) goto L_0011;
#line 335 "test-new/nrimp10s-77.imp"
if (PARMBITS2 & 256 != 0) goto L_0011;
#line 335 "test-new/nrimp10s-77.imp"
ASL = 4095;
#line 335 "test-new/nrimp10s-77.imp"
L_0011:;
// 336 ARSIZE=WKFILEK*768-300
#line 336 "test-new/nrimp10s-77.imp"
ARSIZE = WKFILEK * 768 - 300;
// 337 {%END ... extra block level enables dynamic array bound declarations ...
// 338 {%BYTEINTEGERARRAYFORMAT AF(0:ARSIZE)
// 339 {%BYTEINTEGERARRAYNAME A
// 340 %byteintegerarray A(0:WKFILEK*1024)
#line 340 "test-new/nrimp10s-77.imp"
unsigned char A[WKFILEK * 1024 + 1];
// 341 %RECORD(LISTF)%ARRAY ASLIST(0:ASL){(LISTF)
#line 341 "test-new/nrimp10s-77.imp"
struct LISTF ASLIST[ASL + 1];
// 342 %INTEGERARRAY WORD, TAGS(0:NNAMES)
#line 342 "test-new/nrimp10s-77.imp"
int WORD[NNAMES + 1];
#line 342 "test-new/nrimp10s-77.imp"
int TAGS[NNAMES + 1];
// 343 %INTEGERARRAY DVHEADS(0:12)
#line 343 "test-new/nrimp10s-77.imp"
int DVHEADS[13];
#line 343 "test-new/nrimp10s-77.imp"
auto int FROMAR4(int PTR);
#line 343 "test-new/nrimp10s-77.imp"
auto int FROMAR2(int PTR);
#line 343 "test-new/nrimp10s-77.imp"
auto void TOAR8(int PTR, double VALUE);
#line 343 "test-new/nrimp10s-77.imp"
auto void TOAR4(int PTR, int VALUE);
#line 343 "test-new/nrimp10s-77.imp"
auto void TOAR2(int PTR, int VALUE);
#line 343 "test-new/nrimp10s-77.imp"
auto void WARN(int N, int V);
#line 343 "test-new/nrimp10s-77.imp"
auto void FAULT2(int N, int DATA, int IDENT);
#line 343 "test-new/nrimp10s-77.imp"
auto void FAULT(int N, int FNAME);
#line 343 "test-new/nrimp10s-77.imp"
auto _imp_string255 PRINTNAME(int N);
#line 343 "test-new/nrimp10s-77.imp"
auto int MORESPACE(void);
#line 343 "test-new/nrimp10s-77.imp"
auto void INSERTATEND(int *CELL, int S1, int S2, int S3);
#line 343 "test-new/nrimp10s-77.imp"
auto void FROM12(int CELL, int *S1, int *S2);
#line 343 "test-new/nrimp10s-77.imp"
auto void FROM123(int CELL, int *S1, int *S2, int *S3);
#line 343 "test-new/nrimp10s-77.imp"
auto void POP(int *CELL, int *S1, int *S2, int *S3);
#line 343 "test-new/nrimp10s-77.imp"
auto void PUSH(int *CELL, int S1, int S2, int S3);
#line 343 "test-new/nrimp10s-77.imp"
auto int FIND(int LAB, int LIST);
#line 343 "test-new/nrimp10s-77.imp"
auto void MLINK(int *CELL);
#line 343 "test-new/nrimp10s-77.imp"
auto void REPLACE1(int CELL, int S1);
#line 343 "test-new/nrimp10s-77.imp"
auto void REPLACE2(int CELL, int S2);
#line 343 "test-new/nrimp10s-77.imp"
auto void REPLACE3(int CELL, int S3);
#line 343 "test-new/nrimp10s-77.imp"
auto void REPLACE123(int CELL, int S1, int S2, int S3);
#line 343 "test-new/nrimp10s-77.imp"
auto int FROM2(int CELL);
#line 343 "test-new/nrimp10s-77.imp"
auto int FROM1(int CELL);
#line 343 "test-new/nrimp10s-77.imp"
auto int FROM3(int CELL);
#line 343 "test-new/nrimp10s-77.imp"
auto void BINSERT(int *TOP, int *BOT, int S1, int S2, int S3);
#line 343 "test-new/nrimp10s-77.imp"
auto void CLEARLIST(int *OPHEAD);
#line 343 "test-new/nrimp10s-77.imp"
auto _imp_string255 MESSAGE(int N);
// 344 %INTEGERFNSPEC FROMAR4(%INTEGER PTR)
// 345 %INTEGERFNSPEC FROMAR2(%INTEGER PTR)
// 346 %ROUTINESPEC TOAR8(%INTEGER PTR, %LONGREAL VALUE)
// 347 %ROUTINESPEC TOAR4(%INTEGER PTR, VALUE)
// 348 %ROUTINESPEC TOAR2(%INTEGER PTR,VALUE)
// 349 %ROUTINESPEC WARN(%INTEGER N,V)
// 350 %ROUTINESPEC FAULT2(%INTEGER N,VAL,IDEN)
// 351 %ROUTINESPEC FAULT(%INTEGER N, VALUE)
// 352 %STRING(255)%FNSPEC PRINTNAME(%INTEGER N)
// 353 %INTEGERFNSPEC MORE SPACE
// 354 !%INTEGERFNSPEC NEWCELL
// 355 %ROUTINESPEC INSERTATEND(%INTEGERNAME S, %INTEGER A, B, C)
// 356 %ROUTINESPEC FROM12(%INTEGER CELL, %INTEGERNAME S1, S2)
// 357 %ROUTINESPEC FROM123(%INTEGER CELL, %INTEGERNAME S1, S2, S3)
// 358 %ROUTINESPEC POP(%INTEGERNAME C, P, Q, R)
// 359 %ROUTINESPEC PUSH(%INTEGERNAME C, %INTEGER S1, S2, S3)
// 360 %INTEGERFNSPEC FIND(%INTEGER LAB, LIST)
// 361 %ROUTINESPEC MLINK(%INTEGERNAME CELL)
// 362 %ROUTINESPEC REPLACE1(%INTEGER CELL, S1)
// 363 %ROUTINESPEC REPLACE2(%INTEGER CELL, S2)
// 364 %ROUTINESPEC REPLACE3(%INTEGER CELL,S3)
// 365 %ROUTINESPEC REPLACE123(%INTEGER CELL,A1,A2,S3)
// 366 %INTEGERFNSPEC FROM2(%INTEGER CELL)
// 367 %INTEGERFNSPEC FROM1(%INTEGER CELL)
// 368 %INTEGERFNSPEC FROM3(%INTEGER CELL)
// 369 %ROUTINESPEC BINSERT(%INTEGERNAME T,B,%INTEGER S1,S2,S3)
// 370 %ROUTINESPEC CLEARLIST(%INTEGERNAME HEAD)
// 371 %STRING(255)%FNSPEC MESSAGE(%INTEGER N)
// 372 %SYSTEMROUTINESPEC LPUT(%INTEGER A, B, C, D)
#line 372 "test-new/nrimp10s-77.imp"
extern void LPUT(int A, int B, int C, int D);
// 373 %SYSTEMLONGREALFNSPEC CPUTIME
#line 373 "test-new/nrimp10s-77.imp"
extern double CPUTIME(void);
// 374 !*DELSTART
// 375 %SYSTEMROUTINESPEC NCODE(%INTEGER START, FINISH, CA)
#line 375 "test-new/nrimp10s-77.imp"
extern void NCODE(int START, int FINISH, int CA);
#line 375 "test-new/nrimp10s-77.imp"
auto void PRINTLIST(int HEAD);
#line 375 "test-new/nrimp10s-77.imp"
auto void PRHEX(int VALUE, int PLACES);
#line 375 "test-new/nrimp10s-77.imp"
auto void CHECKASL(void);
// 376 %ROUTINESPEC PRINTLIST(%INTEGER HEAD)
// 377 %ROUTINESPEC PRHEX(%INTEGER VALUE,PLACES)
// 378 %ROUTINESPEC CHECK ASL
// 379 !*DELEND
// 380 %IF VMEB=NO %THEN %START
#line 380 "test-new/nrimp10s-77.imp"
if (0 != 0) goto L_0012;
// 381 %SYSTEMROUTINESPEC CONSOURCE(%STRING(31)FILE,%INTEGERNAME AD)
#line 381 "test-new/nrimp10s-77.imp"
extern void CONSOURCE(_imp_string31 FILE, int *AD);
// 382 %FINISH
#line 382 "test-new/nrimp10s-77.imp"
L_0012:;
// 383 ! START OF COMPILATION
// 384 {A==ARRAY(WKFILE AD+256*WKFILEK, AF)
// 385 %BEGIN
#line 385 "test-new/nrimp10s-77.imp"
{ /*%begin*/
#line 385 "test-new/nrimp10s-77.imp"
auto void READLINE(int MODE, int CHAR);
#line 385 "test-new/nrimp10s-77.imp"
auto int COMPARE(int P);
#line 385 "test-new/nrimp10s-77.imp"
auto void PNAME(int MODE);
#line 385 "test-new/nrimp10s-77.imp"
auto void CONST(int MODE);
#line 385 "test-new/nrimp10s-77.imp"
auto void TEXTTEXT(int EBCDIC);
// 386 !***********************************************************************
// 387 !* THIS BLOCK INITIALISE THE COMPILER SCALARS AND ARRAYS *
// 388 !* WAS ORIGINALLY ROUTINE 'INITIALISE'. *
// 389 !* THE INITIALISATION OF THE CONSTANT LISTS WITH THE VALUES *
// 390 !* IN PERM MAY BE OMITTED IN BATCH OR CUT-DOWN VERSIONS. *
// 391 !***********************************************************************
// 392 %ROUTINESPEC READ LINE(%INTEGER MODE,CHAR)
// 393 %INTEGERFNSPEC COMPARE(%INTEGER P)
// 394 %ROUTINESPEC PNAME(%INTEGER MODE)
// 395 %ROUTINESPEC CONST(%INTEGER MODE)
// 396 %ROUTINESPEC TEXTTEXT(%INTEGER EBCDIC)
// 397 %INTEGER CCSIZE,DSIZE,NEXT,ATLINE1,STARSTART
#line 397 "test-new/nrimp10s-77.imp"
int CCSIZE;
#line 397 "test-new/nrimp10s-77.imp"
int DSIZE;
#line 397 "test-new/nrimp10s-77.imp"
int NEXT;
#line 397 "test-new/nrimp10s-77.imp"
int ATLINE1;
#line 397 "test-new/nrimp10s-77.imp"
int STARSTART;
// 398 CCSIZE=1000; DSIZE=7*NNAMES
#line 398 "test-new/nrimp10s-77.imp"
CCSIZE = 1000;
#line 398 "test-new/nrimp10s-77.imp"
DSIZE = 7 * NNAMES;
// 399 %INTEGERARRAY DISPLAY,SFS(0:MAXLEVELS)
#line 399 "test-new/nrimp10s-77.imp"
int DISPLAY[32];
#line 399 "test-new/nrimp10s-77.imp"
int SFS[32];
// 400 %BYTEINTEGERARRAY TLINE(-60:161),CC(0:CCSIZE),LETT(0:DSIZE+20)
#line 400 "test-new/nrimp10s-77.imp"
unsigned char TLINE[222];
#line 400 "test-new/nrimp10s-77.imp"
unsigned char CC[CCSIZE + 1];
#line 400 "test-new/nrimp10s-77.imp"
unsigned char LETT[DSIZE + 20 + 1];
// 401 %LONGINTEGER ATL0,ASYM0
#line 401 "test-new/nrimp10s-77.imp"
long int ATL0;
#line 401 "test-new/nrimp10s-77.imp"
long int ASYM0;
// 402 %CONSTBYTEINTEGERARRAY ILETT(0: 500)= 11,
#line 402 "test-new/nrimp10s-77.imp"
const unsigned char ILETT[501] = {
11, 83, 69, 76, 69, 67, 84, 73, 78, 80, 85, 84, 12, 83, 69, 76, 69, 67, 84, 79, 85, 84, 80, 85, 84, 7, 78,
69, 87, 76, 73, 78, 69, 5, 83, 80, 65, 67, 69, 10, 83, 75, 73, 80, 83, 89, 77, 66, 79, 76, 10, 82, 69, 65,
68, 83, 84, 82, 73, 78, 71, 8, 78, 69, 87, 76, 73, 78, 69, 83, 6, 83, 80, 65, 67, 69, 83, 10, 78, 69, 88,
84, 83, 89, 77, 66, 79, 76, 11, 80, 82, 73, 78, 84, 83, 89, 77, 66, 79, 76, 10, 82, 69, 65, 68, 83, 89, 77,
66, 79, 76, 4, 82, 69, 65, 68, 5, 87, 82, 73, 84, 69, 7, 78, 69, 87, 80, 65, 71, 69, 4, 65, 68, 68, 82,
6, 65, 82, 67, 83, 73, 78, 3, 73, 78, 84, 5, 73, 78, 84, 80, 84, 6, 70, 82, 65, 67, 80, 84, 5, 80, 82,
73, 78, 84, 7, 80, 82, 73, 78, 84, 70, 76, 4, 82, 69, 65, 76, 7, 73, 78, 84, 69, 71, 69, 82, 3, 77, 79,
68, 6, 65, 82, 67, 67, 79, 83, 4, 83, 81, 82, 84, 3, 76, 79, 71, 3, 83, 73, 78, 3, 67, 79, 83, 3, 84,
65, 78, 3, 69, 88, 80, 11, 67, 76, 79, 83, 69, 83, 84, 82, 69, 65, 77, 11, 66, 89, 84, 69, 73, 78, 84, 69,
71, 69, 82, 8, 69, 86, 69, 78, 84, 73, 78, 70, 6, 82, 65, 68, 73, 85, 83, 6, 65, 82, 67, 84, 65, 78, 6,
76, 69, 78, 71, 84, 72, 11, 80, 82, 73, 78, 84, 83, 84, 82, 73, 78, 71, 2, 78, 76, 8, 76, 79, 78, 71, 82,
69, 65, 76, 7, 80, 82, 73, 78, 84, 67, 72, 6, 82, 69, 65, 68, 67, 72, 6, 83, 84, 82, 73, 78, 71, 8, 82,
69, 65, 68, 73, 84, 69, 77, 8, 78, 69, 88, 84, 73, 84, 69, 77, 6, 67, 72, 65, 82, 78, 79, 8, 84, 79, 83,
84, 82, 73, 78, 71, 10, 70, 82, 79, 77, 83, 84, 82, 73, 78, 71, 6, 82, 69, 67, 79, 82, 68, 5, 65, 82, 82,
65, 89, 10, 83, 69, 84, 77, 65, 82, 71, 73, 78, 83, 4, 73, 77, 79, 68, 2, 80, 73, 9, 69, 86, 69, 78, 84,
76, 73, 78, 69, 11, 76, 79, 78, 71, 73, 78, 84, 69, 71, 69, 82, 12, 76, 79, 78, 71, 76, 79, 78, 71, 82, 69,
65, 76, 9, 76, 69, 78, 71, 84, 72, 69, 78, 73, 9, 76, 69, 78, 71, 84, 72, 69, 78, 82, 8, 83, 72, 79, 82,
84, 69, 78, 73, 8, 83, 72, 79, 82, 84, 69, 78, 82, 6, 78, 69, 88, 84, 67, 72, 11, 72, 65, 76, 70, 73, 78,
84, 69, 71, 69, 82, 8, 80, 80, 82, 79, 70, 73, 76, 69, 255};
// 403+ 'S','E','L','E','C','T','I','N','P','U','T', 12,'S','E','L','E',
// 404+ 'C','T','O','U','T','P','U','T', 7,'N','E','W','L','I','N','E',
// 405+ 5,'S','P','A','C','E', 10,'S','K','I','P','S','Y','M','B','O',
// 406+ 'L', 10,'R','E','A','D','S','T','R','I','N','G', 8,'N','E','W',
// 407+ 'L','I','N','E','S', 6,'S','P','A','C','E','S', 10,'N','E','X',
// 408+ 'T','S','Y','M','B','O','L', 11,'P','R','I','N','T','S','Y','M',
// 409+ 'B','O','L', 10,'R','E','A','D','S','Y','M','B','O','L', 4,'R',
// 410+ 'E','A','D', 5,'W','R','I','T','E', 7,'N','E','W','P','A','G',
// 411+ 'E', 4,'A','D','D','R', 6,'A','R','C','S','I','N', 3,'I','N',
// 412+ 'T', 5,'I','N','T','P','T', 6,'F','R','A','C','P','T', 5,'P',
// 413+ 'R','I','N','T', 7,'P','R','I','N','T','F','L', 4,'R','E','A',
// 414+ 'L', 7,'I','N','T','E','G','E','R', 3,'M','O','D', 6,'A','R',
// 415+ 'C','C','O','S', 4,'S','Q','R','T', 3,'L','O','G', 3,'S','I',
// 416+ 'N', 3,'C','O','S', 3,'T','A','N', 3,'E','X','P', 11,'C','L',
// 417+ 'O','S','E','S','T','R','E','A','M', 11,'B','Y','T','E','I','N',
// 418+ 'T','E','G','E','R', 8,'E','V','E','N','T','I','N','F',
// 419+ 6,'R','A','D','I','U','S', 6,'A','R','C','T','A','N',
// 420+ 6,'L','E','N','G','T','H', 11,'P','R','I','N','T','S','T','R',
// 421+ 'I','N','G', 2,'N','L', 8,'L','O','N','G','R','E','A','L', 7,
// 422+ 'P','R','I','N','T','C','H', 6,'R','E','A','D','C','H', 6,'S',
// 423+ 'T','R','I','N','G', 8,'R','E','A','D','I','T','E','M', 8,'N',
// 424+ 'E','X','T','I','T','E','M', 6,'C','H','A','R','N','O', 8,'T',
// 425+ 'O','S','T','R','I','N','G', 10,'F','R','O','M','S','T','R','I',
// 426+ 'N','G', 6,'R','E','C','O','R','D', 5,'A','R','R','A','Y', 10,
// 427+ 'S','E','T','M','A','R','G','I','N','S',4,'I','M','O','D',2,'P',
// 428+ 'I',9,'E','V','E','N','T','L','I','N','E',11,'L','O','N','G',
// 429+ 'I','N','T','E','G','E','R',12,'L','O','N','G','L','O','N','G',
// 430+ 'R','E','A','L',9,'L','E','N','G','T','H','E','N','I',
// 431+ 9,'L','E','N','G','T','H','E','N','R',
// 432+ 8,'S','H','O','R','T','E','N','I',
// 433+ 8,'S','H','O','R','T','E','N','R',
// 434+ 6,'N','E','X','T','C','H',
// 435+ 11,'H','A','L','F','I','N','T','E','G','E','R',
// 436+ 8,'P','P','R','O','F','I','L','E',255;
// 437 IMAX=(-1)>>1;PLABEL=24999
#line 437 "test-new/nrimp10s-77.imp"
IMAX = (unsigned int)-1 >> 1;
#line 437 "test-new/nrimp10s-77.imp"
PLABEL = 24999;
// 438 LETT(0)=0
#line 438 "test-new/nrimp10s-77.imp"
LETT[0] = 0;
// 439 ATLINE1=ADDR(TLINE(1))
#line 439 "test-new/nrimp10s-77.imp"
ATLINE1 = _imp_ADDR(/*?*/ &TLINE[61]);
// 440 INTEGER(ADDR(ATL0)+4)=ATLINE1-1
#line 440 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(/*?*/ &ATL0) + 4) = ATLINE1 - 1;
// 441 INTEGER(ADDR(ATL0))=16_18000100
#line 441 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(/*?*/ &ATL0)) = 402653440;
// 442 INTEGER(ADDR(ASYM0))=16_28000C00
#line 442 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(/*?*/ &ASYM0)) = 671091712;
// 443 INTEGER(ADDR(ASYM0)+4)=ADDR(SYMBOL(1300))-4*1300
#line 443 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(/*?*/ &ASYM0) + 4) = _imp_ADDR(/*?*/ &SYMBOL[0]) - 4 * 1300;
// 444 N=12;
#line 444 "test-new/nrimp10s-77.imp"
N = 12;
// 445 MAX ULAB=NNAMES+16384; ! LARGEST VALID USER LABEL
#line 445 "test-new/nrimp10s-77.imp"
MAXULAB = NNAMES + 16384;
// 446 GLACURR=0; GLACA=FIXEDGLALEN; GLACABUF=GLACA
#line 446 "test-new/nrimp10s-77.imp"
GLACURR = 0;
#line 446 "test-new/nrimp10s-77.imp"
GLACA = 48;
#line 446 "test-new/nrimp10s-77.imp"
GLACABUF = GLACA;
// 447 PARMOPT=1 ; PARMARR=1; LAST INST=0
#line 447 "test-new/nrimp10s-77.imp"
PARMOPT = 1;
#line 447 "test-new/nrimp10s-77.imp"
PARMARR = 1;
#line 447 "test-new/nrimp10s-77.imp"
LASTINST = 0;
// 448 PARMLINE=1; PARMTRACE=1; PARMDIAG=1
#line 448 "test-new/nrimp10s-77.imp"
PARMLINE = 1;
#line 448 "test-new/nrimp10s-77.imp"
PARMTRACE = 1;
#line 448 "test-new/nrimp10s-77.imp"
PARMDIAG = 1;
// 449 LIST=1; SFLABEL=20999; PARMCHK=1
#line 449 "test-new/nrimp10s-77.imp"
LIST = 1;
#line 449 "test-new/nrimp10s-77.imp"
SFLABEL = 20999;
#line 449 "test-new/nrimp10s-77.imp"
PARMCHK = 1;
// 450 EXITLAB=0; CONTLAB=0
#line 450 "test-new/nrimp10s-77.imp"
EXITLAB = 0;
#line 450 "test-new/nrimp10s-77.imp"
CONTLAB = 0;
// 451 CABUF=0; PPCURR=0; OLDLINE=0; COMPILER=0
#line 451 "test-new/nrimp10s-77.imp"
CABUF = 0;
#line 451 "test-new/nrimp10s-77.imp"
PPCURR = 0;
#line 451 "test-new/nrimp10s-77.imp"
OLDLINE = 0;
#line 451 "test-new/nrimp10s-77.imp"
COMPILER = 0;
// 452 RLEVEL=0; NMAX=0; USTPTR=0
#line 452 "test-new/nrimp10s-77.imp"
RLEVEL = 0;
#line 452 "test-new/nrimp10s-77.imp"
NMAX = 0;
#line 452 "test-new/nrimp10s-77.imp"
USTPTR = 0;
// 453 LEVEL=0; CA=0; LASTAT=0
#line 453 "test-new/nrimp10s-77.imp"
LEVEL = 0;
#line 453 "test-new/nrimp10s-77.imp"
CA = 0;
#line 453 "test-new/nrimp10s-77.imp"
LASTAT = 0;
// 454 FAULTY=0; WARNFLAG=0; ALLLONG=0; INHCODE=0
#line 454 "test-new/nrimp10s-77.imp"
FAULTY = 0;
#line 454 "test-new/nrimp10s-77.imp"
WARNFLAG = 0;
#line 454 "test-new/nrimp10s-77.imp"
ALLLONG = 0;
#line 454 "test-new/nrimp10s-77.imp"
INHCODE = 0;
// 455 DCOMP=0; BFFLAG=0; CPRMODE=0
#line 455 "test-new/nrimp10s-77.imp"
DCOMP = 0;
#line 455 "test-new/nrimp10s-77.imp"
BFFLAG = 0;
#line 455 "test-new/nrimp10s-77.imp"
CPRMODE = 0;
// 456 NEXT=1; LDPTR=0
#line 456 "test-new/nrimp10s-77.imp"
NEXT = 1;
#line 456 "test-new/nrimp10s-77.imp"
LDPTR = 0;
// 457 IOCPDISP=0; CREFHEAD=0; AUXST=0
#line 457 "test-new/nrimp10s-77.imp"
IOCPDISP = 0;
#line 457 "test-new/nrimp10s-77.imp"
CREFHEAD = 0;
#line 457 "test-new/nrimp10s-77.imp"
AUXST = 0;
// 458 RBASE=10; LOGEPDISP=0; EXPEPDISP=0; STRLINK=0
#line 458 "test-new/nrimp10s-77.imp"
RBASE = 10;
#line 458 "test-new/nrimp10s-77.imp"
LOGEPDISP = 0;
#line 458 "test-new/nrimp10s-77.imp"
EXPEPDISP = 0;
#line 458 "test-new/nrimp10s-77.imp"
STRLINK = 0;
// 459 RECTB=0; IHEAD=0
#line 459 "test-new/nrimp10s-77.imp"
RECTB = 0;
#line 459 "test-new/nrimp10s-77.imp"
IHEAD = 0;
// 460 SSTL=0; STMTS=1; SNUM=0; LEVELINF=0
#line 460 "test-new/nrimp10s-77.imp"
SSTL = 0;
#line 460 "test-new/nrimp10s-77.imp"
STMTS = 1;
#line 460 "test-new/nrimp10s-77.imp"
SNUM = 0;
#line 460 "test-new/nrimp10s-77.imp"
LEVELINF = 0;
// 461 CDCOUNT=0
#line 461 "test-new/nrimp10s-77.imp"
CDCOUNT = 0;
// 462 BIMSTR=0
#line 462 "test-new/nrimp10s-77.imp"
BIMSTR = 0;
// 463 LOGEPDISP=0; EXPEPDISP=0
#line 463 "test-new/nrimp10s-77.imp"
LOGEPDISP = 0;
#line 463 "test-new/nrimp10s-77.imp"
EXPEPDISP = 0;
// 464 MAINEP="S#GO"; ! DEFAULT MAIN ENTRY
#line 464 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &MAINEP, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = _imp_str_literal("S#GO");
(void *)&tmp;
}),
/*max:*/ 31);
// 465 DICTBASE=ADDR(LETT(0))
#line 465 "test-new/nrimp10s-77.imp"
DICTBASE = _imp_ADDR(/*?*/ &LETT[0]);
// 466 !
// 467 ! OPEN OBJECT FILE HERE BEFORE MORE PAGES OF COMPILER CODE
// 468 ! ARE PAGED IN AND SUB-SYSTEM PAGES MOVE OUT
// 469 !
// 470 LPUT(0,0,0,0)
#line 470 "test-new/nrimp10s-77.imp"
LPUT(0, 0, 0, 0);
// 471 CTIME=CPUTIME
#line 471 "test-new/nrimp10s-77.imp"
CTIME = CPUTIME();
// 472 I=COMREG(27)
#line 472 "test-new/nrimp10s-77.imp"
I = *COMREG(27);
// 473 STLIMIT=16_1F000
#line 473 "test-new/nrimp10s-77.imp"
STLIMIT = 126976;
// 474 %IF I>>24&1#0 %THEN STLIMIT=COMREG(48)-4096
#line 474 "test-new/nrimp10s-77.imp"
if ((unsigned int)I >> 24 & 1 == 0) goto L_0013;
#line 474 "test-new/nrimp10s-77.imp"
STLIMIT = *COMREG(48) - 4096;
#line 474 "test-new/nrimp10s-77.imp"
L_0013:;
// 475 %IF I&2=2 %THEN LIST=0
#line 475 "test-new/nrimp10s-77.imp"
if (I & 2 != 2) goto L_0014;
#line 475 "test-new/nrimp10s-77.imp"
LIST = 0;
#line 475 "test-new/nrimp10s-77.imp"
L_0014:;
// 476 %IF I&4=4 %THEN PARMDIAG=0
#line 476 "test-new/nrimp10s-77.imp"
if (I & 4 != 4) goto L_0015;
#line 476 "test-new/nrimp10s-77.imp"
PARMDIAG = 0;
#line 476 "test-new/nrimp10s-77.imp"
L_0015:;
// 477 %IF I&16_800000#0 %THEN PARMLINE=0
#line 477 "test-new/nrimp10s-77.imp"
if (I & 8388608 == 0) goto L_0016;
#line 477 "test-new/nrimp10s-77.imp"
PARMLINE = 0;
#line 477 "test-new/nrimp10s-77.imp"
L_0016:;
// 478 %IF I&16=16 %THEN PARMCHK=0
#line 478 "test-new/nrimp10s-77.imp"
if (I & 16 != 16) goto L_0017;
#line 478 "test-new/nrimp10s-77.imp"
PARMCHK = 0;
#line 478 "test-new/nrimp10s-77.imp"
L_0017:;
// 479 %IF I&32=32 %THEN PARMARR=0
#line 479 "test-new/nrimp10s-77.imp"
if (I & 32 != 32) goto L_0018;
#line 479 "test-new/nrimp10s-77.imp"
PARMARR = 0;
#line 479 "test-new/nrimp10s-77.imp"
L_0018:;
// 480 PARMPROF=(I>>15&1)!(I>>7&1); ! USE MAP OR PROFILE BIT PRO TEM
#line 480 "test-new/nrimp10s-77.imp"
PARMPROF = (unsigned int)I >> 15 & 1 | (unsigned int)I >> 7 & 1;
// 481 PARMDYNAMIC=I>>20&1
#line 481 "test-new/nrimp10s-77.imp"
PARMDYNAMIC = (unsigned int)I >> 20 & 1;
// 482 PARMLET=I>>13&1
#line 482 "test-new/nrimp10s-77.imp"
PARMLET = (unsigned int)I >> 13 & 1;
// 483 DCOMP=I>>14&1; ! PARM CODE OR D
#line 483 "test-new/nrimp10s-77.imp"
DCOMP = (unsigned int)I >> 14 & 1;
// 484 PARMDBUG=I>>18&1
#line 484 "test-new/nrimp10s-77.imp"
PARMDBUG = (unsigned int)I >> 18 & 1;
// 485 %IF I&64=64 %THEN PARMTRACE=0 %AND PARMDIAG=0
#line 485 "test-new/nrimp10s-77.imp"
if (I & 64 != 64) goto L_0019;
#line 485 "test-new/nrimp10s-77.imp"
PARMTRACE = 0;
#line 485 "test-new/nrimp10s-77.imp"
PARMDIAG = 0;
#line 485 "test-new/nrimp10s-77.imp"
L_0019:;
// 486 FREE FORMAT=I&16_80000
#line 486 "test-new/nrimp10s-77.imp"
FREEFORMAT = I & 524288;
// 487 STACK=I>>3&1
#line 487 "test-new/nrimp10s-77.imp"
STACK = (unsigned int)I >> 3 & 1;
// 488 SMAP=I>>26&1; ! USE PARMZ BIT FOR DUMPING WKFILE
#line 488 "test-new/nrimp10s-77.imp"
SMAP = (unsigned int)I >> 26 & 1;
// 489 TTOPUT=COMREG(40)
#line 489 "test-new/nrimp10s-77.imp"
TTOPUT = *COMREG(40);
// 490 %IF I&(1<<16)#0 %THEN %START
#line 490 "test-new/nrimp10s-77.imp"
if (I & 1 << 16 == 0) goto L_001A;
// 491 PARMARR=0; PARMOPT=0
#line 491 "test-new/nrimp10s-77.imp"
PARMARR = 0;
#line 491 "test-new/nrimp10s-77.imp"
PARMOPT = 0;
// 492 PARMLINE=0; PARMCHK=0; PARMDIAG=0
#line 492 "test-new/nrimp10s-77.imp"
PARMLINE = 0;
#line 492 "test-new/nrimp10s-77.imp"
PARMCHK = 0;
#line 492 "test-new/nrimp10s-77.imp"
PARMDIAG = 0;
// 493 %FINISH
#line 493 "test-new/nrimp10s-77.imp"
L_001A:;
// 494 PARMTRACE=PARMTRACE!PARMOPT; ! ALLOW NOTRACE ONLY WITH OPT
#line 494 "test-new/nrimp10s-77.imp"
PARMTRACE = PARMTRACE | PARMOPT;
// 495 IMPS=I>>23&1; ! BIT SET IF IMPS REQUESTED
#line 495 "test-new/nrimp10s-77.imp"
IMPS = (unsigned int)I >> 23 & 1;
// 496 IMPS=1; ! FOR TESTING
#line 496 "test-new/nrimp10s-77.imp"
IMPS = 1;
// 497 NEWLINES(3); SPACES(14)
#line 497 "test-new/nrimp10s-77.imp"
_imp_NEWLINES(3);
#line 497 "test-new/nrimp10s-77.imp"
_imp_SPACES(14);
// 498 PRINTSTRING("ERCC. Imp")
#line 498 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("ERCC. Imp"));
// 499 %IF IMPS#0 %THEN PRINTSYMBOL('s')
#line 499 "test-new/nrimp10s-77.imp"
if (IMPS == 0) goto L_001B;
#line 499 "test-new/nrimp10s-77.imp"
_imp_PRINTSYMBOL(115);
#line 499 "test-new/nrimp10s-77.imp"
L_001B:;
// 500 PRINTSTRING(" Compiler Release")
#line 500 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" Compiler Release"));
// 501 WRITE(RELEASE,1)
#line 501 "test-new/nrimp10s-77.imp"
_imp_WRITE(10, 1);
// 502 PRINTSTRING(" Version ".LADATE)
#line 502 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(
#line 502 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = *({
_imp_string255 tmp =
_imp_join((_imp_string *)/*?*/ _imp_str_literal_ptr(" Version "), (_imp_string *)/*?*/ &LADATE);
(_imp_string255 *)&tmp;
}) /*q*/;
(_imp_string255 *)&tmp;
})
#line 502 "test-new/nrimp10s-77.imp"
);
// 503 NEWLINES(3)
#line 503 "test-new/nrimp10s-77.imp"
_imp_NEWLINES(3);
// 504 WRITE(NNAMES,5); WRITE(ASL,5)
#line 504 "test-new/nrimp10s-77.imp"
_imp_WRITE(NNAMES, 5);
#line 504 "test-new/nrimp10s-77.imp"
_imp_WRITE(ASL, 5);
// 505 NEWLINE
#line 505 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
// 506 ASL WARN=0
#line 506 "test-new/nrimp10s-77.imp"
ASLWARN = 0;
// 507 ASL CUR BTM=ASL-240
#line 507 "test-new/nrimp10s-77.imp"
ASLCURBTM = ASL - 240;
// 508 CONST LIMIT=4*ASL CUR BTM-8
#line 508 "test-new/nrimp10s-77.imp"
CONSTLIMIT = 4 * ASLCURBTM - 8;
// 509 %CYCLE I=ASL CUR BTM,1,ASL-1
#line 509 "test-new/nrimp10s-77.imp"
// %for I = ASLCURBTM, 1, ASL - 1 %cycle
#line 509 "test-new/nrimp10s-77.imp"
{
int _control, _initial = ASLCURBTM, _increment = 1, _final = ASL - 1;
#line 509 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = ASLCURBTM, 1, ASL - 1");
_control = I = _initial - _increment;
#line 509 "test-new/nrimp10s-77.imp"
L_001C:
#line 509 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 509 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_001D;
#line 509 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 510 ASLIST(I+1)_LINK=I
#line 510 "test-new/nrimp10s-77.imp"
ASLIST[I + 1].LINK = I;
// 511 %REPEAT
#line 511 "test-new/nrimp10s-77.imp"
goto L_001C;
#line 511 "test-new/nrimp10s-77.imp"
}
#line 511 "test-new/nrimp10s-77.imp"
L_001D:;
// 512 ASLIST(ASL CUR BTM)_LINK=0
#line 512 "test-new/nrimp10s-77.imp"
ASLIST[ASLCURBTM].LINK = 0;
// 513 ASLIST(0)_S1=-1
#line 513 "test-new/nrimp10s-77.imp"
ASLIST[0].S1 = -1;
// 514 ASLIST(0)_S2=-1
#line 514 "test-new/nrimp10s-77.imp"
ASLIST[0].S2 = -1;
// 515 ASLIST(0)_S3=-1
#line 515 "test-new/nrimp10s-77.imp"
ASLIST[0].S3 = -1;
// 516 ASLIST(0)_LINK=0
#line 516 "test-new/nrimp10s-77.imp"
ASLIST[0].LINK = 0;
// 517 %CYCLE I=0,1,NNAMES
#line 517 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, NNAMES %cycle
#line 517 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = NNAMES;
#line 517 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, NNAMES");
_control = I = _initial - _increment;
#line 517 "test-new/nrimp10s-77.imp"
L_001F:
#line 517 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 517 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0020;
#line 517 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 518 WORD(I)=0; TAGS(I)=0;
#line 518 "test-new/nrimp10s-77.imp"
WORD[I] = 0;
#line 518 "test-new/nrimp10s-77.imp"
TAGS[I] = 0;
// 519 %REPEAT
#line 519 "test-new/nrimp10s-77.imp"
goto L_001F;
#line 519 "test-new/nrimp10s-77.imp"
}
#line 519 "test-new/nrimp10s-77.imp"
L_0020:;
// 520 %CYCLE I=0,1,12
#line 520 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 12 %cycle
#line 520 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 12;
#line 520 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 12");
_control = I = _initial - _increment;
#line 520 "test-new/nrimp10s-77.imp"
L_0021:
#line 520 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 520 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0022;
#line 520 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 521 DVHEADS(I)=0
#line 521 "test-new/nrimp10s-77.imp"
DVHEADS[I] = 0;
// 522 %REPEAT
#line 522 "test-new/nrimp10s-77.imp"
goto L_0021;
#line 522 "test-new/nrimp10s-77.imp"
}
#line 522 "test-new/nrimp10s-77.imp"
L_0022:;
// 523 !
// 524 ! NOW DECLARE THE SPECIAL NAMES WHICH ARE IN ARRAY ILETT.
// 525 !
// 526 K=0; NEXT=1
#line 526 "test-new/nrimp10s-77.imp"
K = 0;
#line 526 "test-new/nrimp10s-77.imp"
NEXT = 1;
// 527 I=ILETT(0)
#line 527 "test-new/nrimp10s-77.imp"
I = ILETT[0];
// 528 %WHILE I<255 %CYCLE
#line 528 "test-new/nrimp10s-77.imp"
L_0023:;
#line 528 "test-new/nrimp10s-77.imp"
if (I >= 255) goto L_0024;
// 529 %CYCLE J=I,-1,1
#line 529 "test-new/nrimp10s-77.imp"
// %for J = I, -1, 1 %cycle
#line 529 "test-new/nrimp10s-77.imp"
{
int _control, _initial = I, _increment = -1, _final = 1;
#line 529 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = I, -1, 1");
_control = J = _initial - _increment;
#line 529 "test-new/nrimp10s-77.imp"
L_0025:
#line 529 "test-new/nrimp10s-77.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 529 "test-new/nrimp10s-77.imp"
if (J == _final) goto L_0026;
#line 529 "test-new/nrimp10s-77.imp"
_control += _increment;
J -= 1;
// ?Non-local
// 530 CC(J)=ILETT(K+J)
#line 530 "test-new/nrimp10s-77.imp"
CC[J] = ILETT[K + J];
// 531 %REPEAT
#line 531 "test-new/nrimp10s-77.imp"
goto L_0025;
#line 531 "test-new/nrimp10s-77.imp"
}
#line 531 "test-new/nrimp10s-77.imp"
L_0026:;
// 532 CC(I+1)=';'
#line 532 "test-new/nrimp10s-77.imp"
CC[I + 1] = 59;
// 533 R=2; Q=1; PNAME(1)
#line 533 "test-new/nrimp10s-77.imp"
R = 2;
#line 533 "test-new/nrimp10s-77.imp"
Q = 1;
#line 533 "test-new/nrimp10s-77.imp"
PNAME(1);
// 534 PUSH(TAGS(LASTNAME),SNPT<<16!16_8000,0,SNUM<<16)
#line 534 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &TAGS[LASTNAME], 4102 << 16 | 32768, 0, SNUM << 16);
// 535 SNUM=SNUM+1
#line 535 "test-new/nrimp10s-77.imp"
SNUM = SNUM + 1;
// 536 K=K+I+1; I=ILETT(K)
#line 536 "test-new/nrimp10s-77.imp"
K = K + I + 1;
#line 536 "test-new/nrimp10s-77.imp"
I = ILETT[K];
// 537 %REPEAT
#line 537 "test-new/nrimp10s-77.imp"
goto L_0023;
#line 537 "test-new/nrimp10s-77.imp"
L_0024:;
// 538 !
// 539 COMREG(24)=16; ! RETURN CODE
#line 539 "test-new/nrimp10s-77.imp"
*COMREG(24) = 16;
// 540 DUMMY FORMAT=0; ! DUMMY RECORD FORMAT
#line 540 "test-new/nrimp10s-77.imp"
DUMMYFORMAT = 0;
// 541 DFHEAD=0
#line 541 "test-new/nrimp10s-77.imp"
DFHEAD = 0;
// 542 PUSH(DFHEAD,0,0,0)
#line 542 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &DFHEAD, 0, 0, 0);
// 543 PUSH(DUMMY FORMAT,0,0,DFHEAD); ! FOR BETTER ERROR RECOVERY
#line 543 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &DUMMYFORMAT, 0, 0, DFHEAD);
// 544 LINE=0; LENGTH=0; Q=1
#line 544 "test-new/nrimp10s-77.imp"
LINE = 0;
#line 544 "test-new/nrimp10s-77.imp"
LENGTH = 0;
#line 544 "test-new/nrimp10s-77.imp"
Q = 1;
// 545 R=1; LEVEL=1
#line 545 "test-new/nrimp10s-77.imp"
R = 1;
#line 545 "test-new/nrimp10s-77.imp"
LEVEL = 1;
// 546 %CYCLE
#line 546 "test-new/nrimp10s-77.imp"
L_0028:;
// 547 %IF Q>=LENGTH %THEN QMAX=1 %AND READ LINE(0,0)
#line 547 "test-new/nrimp10s-77.imp"
if (Q < LENGTH) goto L_0029;
#line 547 "test-new/nrimp10s-77.imp"
QMAX = 1;
#line 547 "test-new/nrimp10s-77.imp"
READLINE(0, 0);
#line 547 "test-new/nrimp10s-77.imp"
L_0029:;
// 548 WARNFLAG=0
#line 548 "test-new/nrimp10s-77.imp"
WARNFLAG = 0;
// 549 STARSTART=R
#line 549 "test-new/nrimp10s-77.imp"
STARSTART = R;
// 550 R=R+3
#line 550 "test-new/nrimp10s-77.imp"
R = R + 3;
// 551 OLDLINE=LINE
#line 551 "test-new/nrimp10s-77.imp"
OLDLINE = LINE;
// 552 A(R)=LINE>>8
#line 552 "test-new/nrimp10s-77.imp"
A[R] = (unsigned int)LINE >> 8;
// 553 A(R+1)=LINE&255
#line 553 "test-new/nrimp10s-77.imp"
A[R + 1] = LINE & 255;
// 554 R=R+2
#line 554 "test-new/nrimp10s-77.imp"
R = R + 2;
// 555 %IF COMPARE(SS)=0 %THEN %START
#line 555 "test-new/nrimp10s-77.imp"
if (COMPARE(2093) != 0) goto L_002A;
// 556 FAULT(100,ADDR(CC(0)))
#line 556 "test-new/nrimp10s-77.imp"
FAULT(100, _imp_ADDR(/*?*/ &CC[0]));
// 557 R=STARSTART
#line 557 "test-new/nrimp10s-77.imp"
R = STARSTART;
// 558 %FINISH %ELSE %START
#line 558 "test-new/nrimp10s-77.imp"
goto L_002B;
#line 558 "test-new/nrimp10s-77.imp"
L_002A:;
// 559 FAULT(102, 0) %IF R>ARSIZE
#line 559 "test-new/nrimp10s-77.imp"
if (R <= ARSIZE) goto L_002C;
#line 559 "test-new/nrimp10s-77.imp"
FAULT(102, 0);
#line 559 "test-new/nrimp10s-77.imp"
L_002C:;
// 560 %IF A(STARSTART+5)=COMMALT %THEN R=STARSTART %ELSE %START
#line 560 "test-new/nrimp10s-77.imp"
if (A[STARSTART + 5] != 2) goto L_002D;
#line 560 "test-new/nrimp10s-77.imp"
R = STARSTART;
#line 560 "test-new/nrimp10s-77.imp"
goto L_002E;
#line 560 "test-new/nrimp10s-77.imp"
L_002D:;
// 561 I=R-STARSTART
#line 561 "test-new/nrimp10s-77.imp"
I = R - STARSTART;
// 562 A(STARSTART)=I>>16
#line 562 "test-new/nrimp10s-77.imp"
A[STARSTART] = (unsigned int)I >> 16;
// 563 A(STARSTART+1)=I>>8&255
#line 563 "test-new/nrimp10s-77.imp"
A[STARSTART + 1] = (unsigned int)I >> 8 & 255;
// 564 A(STARSTART+2)=I&255
#line 564 "test-new/nrimp10s-77.imp"
A[STARSTART + 2] = I & 255;
// 565 %IF A(STARSTART+5)=DECALT %AND LEVEL>1 %THEN %START
#line 565 "test-new/nrimp10s-77.imp"
if (A[STARSTART + 5] != 8) goto L_002F;
#line 565 "test-new/nrimp10s-77.imp"
if (LEVEL <= 1) goto L_002F;
// 566 %IF SFS(LEVEL)=0 %THEN %START
#line 566 "test-new/nrimp10s-77.imp"
if (SFS[LEVEL] != 0) goto L_0030;
// 567 TO AR4(DISPLAY(LEVEL),STARSTART)
#line 567 "test-new/nrimp10s-77.imp"
TOAR4(DISPLAY[LEVEL], STARSTART);
// 568 DISPLAY(LEVEL)=STARSTART+6
#line 568 "test-new/nrimp10s-77.imp"
DISPLAY[LEVEL] = STARSTART + 6;
// 569 %FINISH %ELSE A(STARSTART+6)=128;! FLAG AS UNLINKED
#line 569 "test-new/nrimp10s-77.imp"
goto L_0031;
#line 569 "test-new/nrimp10s-77.imp"
L_0030:;
#line 569 "test-new/nrimp10s-77.imp"
A[STARSTART + 6] = 128;
#line 569 "test-new/nrimp10s-77.imp"
L_0031:;
// 570 %FINISH
#line 570 "test-new/nrimp10s-77.imp"
L_002F:;
// 571 !*DELSTART
// 572 %IF SMAP#0 %THEN %START
#line 572 "test-new/nrimp10s-77.imp"
if (SMAP == 0) goto L_0032;
// 573 NEWLINE; WRITE(LINE, 5)
#line 573 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
#line 573 "test-new/nrimp10s-77.imp"
_imp_WRITE(LINE, 5);
// 574 WRITE(STARSTART,5); NEWLINE; J=0
#line 574 "test-new/nrimp10s-77.imp"
_imp_WRITE(STARSTART, 5);
#line 574 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
#line 574 "test-new/nrimp10s-77.imp"
J = 0;
// 575 %CYCLE I=STARSTART, 1, R-1
#line 575 "test-new/nrimp10s-77.imp"
// %for I = STARSTART, 1, R - 1 %cycle
#line 575 "test-new/nrimp10s-77.imp"
{
int _control, _initial = STARSTART, _increment = 1, _final = R - 1;
#line 575 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = STARSTART, 1, R - 1");
_control = I = _initial - _increment;
#line 575 "test-new/nrimp10s-77.imp"
L_0033:
#line 575 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 575 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0034;
#line 575 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 576 WRITE(A(I), 5)
#line 576 "test-new/nrimp10s-77.imp"
_imp_WRITE(A[I], 5);
// 577 J=J+1
#line 577 "test-new/nrimp10s-77.imp"
J = J + 1;
// 578 %IF J>=20 %THEN NEWLINE %AND J=0
#line 578 "test-new/nrimp10s-77.imp"
if (J < 20) goto L_0036;
#line 578 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
#line 578 "test-new/nrimp10s-77.imp"
J = 0;
#line 578 "test-new/nrimp10s-77.imp"
L_0036:;
// 579 %REPEAT
#line 579 "test-new/nrimp10s-77.imp"
goto L_0033;
#line 579 "test-new/nrimp10s-77.imp"
}
#line 579 "test-new/nrimp10s-77.imp"
L_0034:;
// 580 NEWLINE
#line 580 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
// 581 %FINISH
#line 581 "test-new/nrimp10s-77.imp"
L_0032:;
// 582 !*DELEND
// 583 %EXIT %IF A(STARSTART+5)=ENDALT %AND 1<=A(STARSTART+6)<=2;! ENDOF PROG OR FILE
#line 583 "test-new/nrimp10s-77.imp"
if (A[STARSTART + 5] != 9) goto L_0037;
#line 583 "test-new/nrimp10s-77.imp"
{
// Double-sided test on A[STARSTART + 6] (Part I)
#line 583 "test-new/nrimp10s-77.imp"
unsigned char tmp;
#line 583 "test-new/nrimp10s-77.imp"
if (1 > (tmp = A[STARSTART + 6])) goto L_0037;
// Double-sided test on A[STARSTART + 6] (Part II)
#line 583 "test-new/nrimp10s-77.imp"
if (tmp > 2) goto L_0037;
#line 583 "test-new/nrimp10s-77.imp"
}
#line 583 "test-new/nrimp10s-77.imp"
goto L_0038;
#line 583 "test-new/nrimp10s-77.imp"
L_0037:;
// 584 %IF LEVEL=0 %THEN FAULT(14, 0) %AND %EXIT
#line 584 "test-new/nrimp10s-77.imp"
if (LEVEL != 0) goto L_0039;
#line 584 "test-new/nrimp10s-77.imp"
FAULT(14, 0);
#line 584 "test-new/nrimp10s-77.imp"
goto L_0038;
#line 584 "test-new/nrimp10s-77.imp"
L_0039:;
// 585 %FINISH
#line 585 "test-new/nrimp10s-77.imp"
L_002E:;
// 586 %FINISH
#line 586 "test-new/nrimp10s-77.imp"
L_002B:;
// 587 %REPEAT
#line 587 "test-new/nrimp10s-77.imp"
goto L_0028;
#line 587 "test-new/nrimp10s-77.imp"
L_0038:;
// 588 TO AR8(R,0); R=R+8
#line 588 "test-new/nrimp10s-77.imp"
TOAR8(R, 0);
#line 588 "test-new/nrimp10s-77.imp"
R = R + 8;
// 589 %IF R+NEXT>ARSIZE %THEN FAULT(102,0)
#line 589 "test-new/nrimp10s-77.imp"
if (R + NEXT <= ARSIZE) goto L_003A;
#line 589 "test-new/nrimp10s-77.imp"
FAULT(102, 0);
#line 589 "test-new/nrimp10s-77.imp"
L_003A:;
// 590 P1SIZE=R
#line 590 "test-new/nrimp10s-77.imp"
P1SIZE = R;
// 591 ! %IF USE IMP=YES %THEN %START
// 592 %CYCLE I=0,1,NEXT
#line 592 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, NEXT %cycle
#line 592 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = NEXT;
#line 592 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, NEXT");
_control = I = _initial - _increment;
#line 592 "test-new/nrimp10s-77.imp"
L_003B:
#line 592 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 592 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_003C;
#line 592 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 593 A(R+I)=LETT(I)
#line 593 "test-new/nrimp10s-77.imp"
A[R + I] = LETT[I];
// 594 %REPEAT
#line 594 "test-new/nrimp10s-77.imp"
goto L_003B;
#line 594 "test-new/nrimp10s-77.imp"
}
#line 594 "test-new/nrimp10s-77.imp"
L_003C:;
// 595 ! %FINISH %ELSE %START
// 596 ! *LDTB_16_18000000
// 597 ! *LDB_NEXT
// 598 ! *LDA_LETT+4
// 599 ! *CYD_0
// 600 ! *LDA_A+4
// 601 ! *INCA_R
// 602 ! *MV_%L=%DR
// 603 ! %FINISH
// 604 DICTBASE=ADDR(A(R))
#line 604 "test-new/nrimp10s-77.imp"
DICTBASE = _imp_ADDR(/*?*/ &A[R]);
// 605 R=R+NEXT+1
#line 605 "test-new/nrimp10s-77.imp"
R = R + NEXT + 1;
// 606 ->BEND
#line 606 "test-new/nrimp10s-77.imp"
goto U_1000;
// 607 %ROUTINE READ LINE(%INTEGER MODE,CHAR)
#line 607 "test-new/nrimp10s-77.imp"
void READLINE(int MODE, int CHAR) {
#line 607 "test-new/nrimp10s-77.imp"
auto void GETLINE(void);
// 608 %ROUTINESPEC GET LINE
// 609 %INTEGER DEL, LL, LP
#line 609 "test-new/nrimp10s-77.imp"
int DEL;
#line 609 "test-new/nrimp10s-77.imp"
int LL;
#line 609 "test-new/nrimp10s-77.imp"
int LP;
// 610 LL=0; LP=0; Q=1
#line 610 "test-new/nrimp10s-77.imp"
LL = 0;
#line 610 "test-new/nrimp10s-77.imp"
LP = 0;
#line 610 "test-new/nrimp10s-77.imp"
Q = 1;
// 611 LENGTH=0; DEL=0
#line 611 "test-new/nrimp10s-77.imp"
LENGTH = 0;
#line 611 "test-new/nrimp10s-77.imp"
DEL = 0;
// 612 NEXT:
#line 612 "test-new/nrimp10s-77.imp"
U_1001:;
// 613 ! %IF USE IMP=YES %THEN %START
// 614 LP=LP+1
#line 614 "test-new/nrimp10s-77.imp"
LP = LP + 1;
// 615 %IF LP>LL %THEN GET LINE %AND LP=1
#line 615 "test-new/nrimp10s-77.imp"
if (LP <= LL) goto L_003D;
#line 615 "test-new/nrimp10s-77.imp"
GETLINE();
#line 615 "test-new/nrimp10s-77.imp"
LP = 1;
#line 615 "test-new/nrimp10s-77.imp"
L_003D:;
// 616 I=TLINE(LP)
#line 616 "test-new/nrimp10s-77.imp"
I = TLINE[LP + 60];
// 617 %IF MODE=0 %THEN %START
#line 617 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_003E;
// 618 %IF I='%' %THEN DEL=128 %AND ->NEXT
#line 618 "test-new/nrimp10s-77.imp"
if (I != 37) goto L_003F;
#line 618 "test-new/nrimp10s-77.imp"
DEL = 128;
#line 618 "test-new/nrimp10s-77.imp"
goto U_1001;
#line 618 "test-new/nrimp10s-77.imp"
L_003F:;
// 619 I=ONE CASE(I)
#line 619 "test-new/nrimp10s-77.imp"
I = ONECASE[I];
// 620 %IF 'A'<=I<='Z' %THEN I=I!DEL %ELSE %START
#line 620 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 620 "test-new/nrimp10s-77.imp"
int tmp;
#line 620 "test-new/nrimp10s-77.imp"
if (65 > (tmp = I)) goto L_0040;
// Double-sided test on I (Part II)
#line 620 "test-new/nrimp10s-77.imp"
if (tmp > 90) goto L_0040;
#line 620 "test-new/nrimp10s-77.imp"
}
#line 620 "test-new/nrimp10s-77.imp"
I = I | DEL;
#line 620 "test-new/nrimp10s-77.imp"
goto L_0041;
#line 620 "test-new/nrimp10s-77.imp"
L_0040:;
// 621 DEL=0
#line 621 "test-new/nrimp10s-77.imp"
DEL = 0;
// 622 ->NEXT %IF I=' '
#line 622 "test-new/nrimp10s-77.imp"
if (I != 32) goto L_0042;
#line 622 "test-new/nrimp10s-77.imp"
goto U_1001;
#line 622 "test-new/nrimp10s-77.imp"
L_0042:;
// 623 %FINISH
#line 623 "test-new/nrimp10s-77.imp"
L_0041:;
// 624 LENGTH=LENGTH+1
#line 624 "test-new/nrimp10s-77.imp"
LENGTH = LENGTH + 1;
// 625 CC(LENGTH)=I
#line 625 "test-new/nrimp10s-77.imp"
CC[LENGTH] = I;
// 626 %IF I='''' %OR I=34 %THEN MODE=1 %AND CHAR=I
#line 626 "test-new/nrimp10s-77.imp"
if (I == 39) goto L_0027;
#line 626 "test-new/nrimp10s-77.imp"
if (I != 34) goto L_0043;
#line 626 "test-new/nrimp10s-77.imp"
L_0027:;
#line 626 "test-new/nrimp10s-77.imp"
MODE = 1;
#line 626 "test-new/nrimp10s-77.imp"
CHAR = I;
#line 626 "test-new/nrimp10s-77.imp"
L_0043:;
// 627 %FINISH %ELSE %START
#line 627 "test-new/nrimp10s-77.imp"
goto L_0044;
#line 627 "test-new/nrimp10s-77.imp"
L_003E:;
// 628 LENGTH=LENGTH+1
#line 628 "test-new/nrimp10s-77.imp"
LENGTH = LENGTH + 1;
// 629 CC(LENGTH)=I
#line 629 "test-new/nrimp10s-77.imp"
CC[LENGTH] = I;
// 630 %IF I=CHAR %THEN MODE=0
#line 630 "test-new/nrimp10s-77.imp"
if (I != CHAR) goto L_0045;
#line 630 "test-new/nrimp10s-77.imp"
MODE = 0;
#line 630 "test-new/nrimp10s-77.imp"
L_0045:;
// 631 %FINISH
#line 631 "test-new/nrimp10s-77.imp"
L_0044:;
// 632 ->NEXT %UNLESS I=NL
#line 632 "test-new/nrimp10s-77.imp"
if (I == 10) goto L_0046;
#line 632 "test-new/nrimp10s-77.imp"
goto U_1001;
#line 632 "test-new/nrimp10s-77.imp"
L_0046:;
// 633 ! %FINISH %ELSE %START
// 634 ! *LB_LP
// 635 ! *ADB_1
// 636 ! *CPB_LL
// 637 ! *JCC_12,<RLL1>
// 638 ! GET LINE
// 639 ! *LB_1
// 640 !RLL1:
// 641 ! *STB_LP
// 642 ! *LB_(ATL0+%B)
// 643 ! *LSS_MODE
// 644 ! *JAF_4,<RLL2>
// 645 ! *CPB_37; !'%'
// 646 ! *JCC_7,<RLL3>
// 647 ! *L_128
// 648 ! *ST_DEL
// 649 ! *J_<NEXT>
// 650 !RLL3:
// 651 ! *LSS_(ONE CASE+%B); ! LOWER CASE TO UPPER
// 652 ! *ICP_65; !'A'
// 653 ! *JCC_4,<RLL4>
// 654 ! *ICP_90; !'Z'
// 655 ! *JCC_2,<RLL4>
// 656 ! *OR_DEL
// 657 ! *J_<RLL5>
// 658 !RLL4:
// 659 ! *LB_0
// 660 ! *STB_DEL
// 661 ! *ICP_32; !' '
// 662 ! *JCC_8,<NEXT>
// 663 !RLL5:
// 664 ! *LB_LENGTH
// 665 ! *ADB_1
// 666 ! *STB_LENGTH
// 667 ! *ST_(CC+%B)
// 668 ! *ICP_39; !''''
// 669 ! *JCC_8,<RLL6>
// 670 ! *ICP_34; !'"'
// 671 ! *JCC_7,<RLL7>
// 672 !RLL6:
// 673 ! *ST_CHAR
// 674 ! *LB_1
// 675 ! *STB_MODE
// 676 !RLL7:
// 677 ! *ICP_10
// 678 ! *JCC_7,<NEXT>
// 679 ! *J_<RLL8>
// 680 !RLL2:
// 681 ! *LSS_%B
// 682 ! *LB_LENGTH
// 683 ! *ADB_1
// 684 ! *STB_LENGTH
// 685 ! *ST_(CC+%B)
// 686 ! *ICP_CHAR
// 687 ! *JCC_7,<RLL9>
// 688 ! *LB_0
// 689 ! *STB_MODE
// 690 !RLL9:
// 691 ! *ICP_10
// 692 ! *JCC_7,<NEXT>
// 693 !RLL8:
// 694 ! %FINISH
// 695 %IF CC(LENGTH-1)='C'+128 %THEN LENGTH=LENGTH-2 %AND ->NEXT
#line 695 "test-new/nrimp10s-77.imp"
if (CC[LENGTH - 1] != 67 + 128) goto L_0047;
#line 695 "test-new/nrimp10s-77.imp"
LENGTH = LENGTH - 2;
#line 695 "test-new/nrimp10s-77.imp"
goto U_1001;
#line 695 "test-new/nrimp10s-77.imp"
L_0047:;
// 696 FAULT(101,0) %IF LENGTH>CCSIZE
#line 696 "test-new/nrimp10s-77.imp"
if (LENGTH <= CCSIZE) goto L_0048;
#line 696 "test-new/nrimp10s-77.imp"
FAULT(101, 0);
#line 696 "test-new/nrimp10s-77.imp"
L_0048:;
// 697 %RETURN
#line 697 "test-new/nrimp10s-77.imp"
return;
// 698 %ROUTINE GET LINE
#line 698 "test-new/nrimp10s-77.imp"
void GETLINE(void) {
// 699 %SYSTEMROUTINESPEC IOCP(%INTEGER A,B)
#line 699 "test-new/nrimp10s-77.imp"
extern void IOCP(int A, int B);
// 700 %CONSTBYTEINTEGERARRAY ITOI(0:255)={%C
#line 700 "test-new/nrimp10s-77.imp"
const unsigned char ITOI[256] = {[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};
// 701+ 32(10),10,32(14),25,26,32(5),
// 702+ 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
// 703+ 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
// 704+ 64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
// 705+ 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
// 706+ 96,97,98,99,100,101,102,103,104,105,106,107,108,109,
// 707+ 110,111,112,113,114,115,116,117,118,119,
// 708+ 120,121,122,123,124,125,126,32,
// 709+ 26(5),10,26(10),
// 710+ 26(16),
// 711+ 26(14),92,38,
// 712+ 26(11),35,26(4),
// 713+ 26(16),
// 714+ 26(9),35,26(5),94,
// 715+ 26(32);
// 716 %INTEGER K
#line 716 "test-new/nrimp10s-77.imp"
int K;
// 717 LL=0
#line 717 "test-new/nrimp10s-77.imp"
LL = 0;
// 718 %IF FILE ADDR=0 %THEN %START; ! SOURCE NOT A 'CLEAN' FILE
#line 718 "test-new/nrimp10s-77.imp"
if (FILEADDR != 0) goto L_0049;
// 719 {%UNTIL K=NL} %CYCLE
#line 719 "test-new/nrimp10s-77.imp"
L_004A:;
// 720 READ SYMBOL(K)
#line 720 "test-new/nrimp10s-77.imp"
_imp_READSYMBOL(/*?*/ &K);
// 721 TLINE(LL+1)=ITOI(K)
#line 721 "test-new/nrimp10s-77.imp"
TLINE[LL + 1 + 60] = ITOI[K];
// 722 LL=LL+1
#line 722 "test-new/nrimp10s-77.imp"
LL = LL + 1;
// 723 %REPEAT %UNTIL K=NL
#line 723 "test-new/nrimp10s-77.imp"
if (K == 10) goto L_004B;
#line 723 "test-new/nrimp10s-77.imp"
goto L_004A;
#line 723 "test-new/nrimp10s-77.imp"
L_004B:;
// 724 %FINISH %ELSE %START
#line 724 "test-new/nrimp10s-77.imp"
goto L_004C;
#line 724 "test-new/nrimp10s-77.imp"
L_0049:;
// 725 %IF FILEPTR>=FILE END %START
#line 725 "test-new/nrimp10s-77.imp"
if (FILEPTR < FILEEND) goto L_004D;
// 726 %IF IHEAD#0 %THEN POP(IHEAD,FILEADDR,FILEPTR,FILEEND) %AND GETLINE %AND %RETURN
#line 726 "test-new/nrimp10s-77.imp"
if (IHEAD == 0) goto L_004E;
#line 726 "test-new/nrimp10s-77.imp"
POP(/*?*/ &IHEAD, /*?*/ &FILEADDR, /*?*/ &FILEPTR, /*?*/ &FILEEND);
#line 726 "test-new/nrimp10s-77.imp"
GETLINE();
#line 726 "test-new/nrimp10s-77.imp"
return;
#line 726 "test-new/nrimp10s-77.imp"
L_004E:;
// 727 %SIGNAL %EVENT 9,1
#line 727 "test-new/nrimp10s-77.imp"
_imp_signal(9, 1, 0, "");
// 728 %FINISH
#line 728 "test-new/nrimp10s-77.imp"
L_004D:;
// 729 ! %IF USE IMP=NO %THEN %START
// 730 ! *LDA_FILEPTR
// 731 ! *LB_FILEEND
// 732 ! *SBB_FILEPTR
// 733 ! *ADB_16_18000000
// 734 ! *LDTB_%B
// 735 ! *SWNE_%L=%DR,0,10
// 736 ! *JCC_8,<IMP>
// 737 ! *CYD_0
// 738 ! *STUH_%B
// 739 ! *IAD_1
// 740 ! *ST_%B
// 741 ! *ISB_FILEPTR
// 742 ! *ST_LL
// 743 ! *LDA_FILEPTR
// 744 ! *STB_FILEPTR
// 745 ! *LDB_LL
// 746 ! *CYD_0
// 747 ! *LDA_ATLINE1
// 748 ! *MV_%L=%DR,0,0
// 749 ! *LDA_ATLINE1; *LDTB_16_18000000
// 750 ! *LDB_LL
// 751 ! *LSS_ITOI+4; *LUH_16_180000FF
// 752 ! *TTR_%L=%DR
// 753 ! ->OLIST
// 754 ! %FINISH
// 755 IMP:
#line 755 "test-new/nrimp10s-77.imp"
U_1002:;
// 756 {%UNTIL K=NL %OR K=0} %CYCLE
#line 756 "test-new/nrimp10s-77.imp"
L_004F:;
// 757 K=BYTE INTEGER(FILEPTR); ! NEXT CHAR FROM SORCE FILE
#line 757 "test-new/nrimp10s-77.imp"
K = *_imp_BYTEINTEGER(FILEPTR);
// 758 FILE PTR=FILE PTR+1
#line 758 "test-new/nrimp10s-77.imp"
FILEPTR = FILEPTR + 1;
// 759 TLINE(LL+1)=ITOI(K)
#line 759 "test-new/nrimp10s-77.imp"
TLINE[LL + 1 + 60] = ITOI[K];
// 760 LL=LL+1
#line 760 "test-new/nrimp10s-77.imp"
LL = LL + 1;
// 761 %REPEAT %UNTIL K=NL %OR K=0
#line 761 "test-new/nrimp10s-77.imp"
if (K == 10) goto L_0050;
#line 761 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_0050;
#line 761 "test-new/nrimp10s-77.imp"
goto L_004F;
#line 761 "test-new/nrimp10s-77.imp"
L_0050:;
// 762 OLIST:
#line 762 "test-new/nrimp10s-77.imp"
U_1003:;
// 763 %FINISH
#line 763 "test-new/nrimp10s-77.imp"
L_004C:;
// 764 ! %IF MODE=0 %AND LL=1 %THEN GET LINE %AND %RETURN
// 765 ! LINE=LINE+1 %UNLESS MODE=0 %AND LENGTH>0
// 766 LINE=LINE+1; ! COUNT ALL LINES
#line 766 "test-new/nrimp10s-77.imp"
LINE = LINE + 1;
// 767 %IF LIST#0 %THEN %START
#line 767 "test-new/nrimp10s-77.imp"
if (LIST == 0) goto L_0051;
// 768 %IF MODE=0 %AND LENGTH>0 %THEN PRINTSTRING(" C") %ELSE WRITE(LINE, 5)
#line 768 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_0052;
#line 768 "test-new/nrimp10s-77.imp"
if (LENGTH <= 0) goto L_0052;
#line 768 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" C"));
#line 768 "test-new/nrimp10s-77.imp"
goto L_0053;
#line 768 "test-new/nrimp10s-77.imp"
L_0052:;
#line 768 "test-new/nrimp10s-77.imp"
_imp_WRITE(LINE, 5);
#line 768 "test-new/nrimp10s-77.imp"
L_0053:;
// 769 ! SPACES(8)
// 770 %CYCLE K=-7,1,0
#line 770 "test-new/nrimp10s-77.imp"
// %for K = -7, 1, 0 %cycle
#line 770 "test-new/nrimp10s-77.imp"
{
int _control, _initial = -7, _increment = 1, _final = 0;
#line 770 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle K = -7, 1, 0");
_control = K = _initial - _increment;
#line 770 "test-new/nrimp10s-77.imp"
L_0054:
#line 770 "test-new/nrimp10s-77.imp"
if (K != _control) _imp_signal(4, 2, 0, "Corrupt control variable K");
#line 770 "test-new/nrimp10s-77.imp"
if (K == _final) goto L_0055;
#line 770 "test-new/nrimp10s-77.imp"
_control += _increment;
K += _increment;
// 771 TLINE(K)=' '
#line 771 "test-new/nrimp10s-77.imp"
TLINE[K + 60] = 32;
// 772 %REPEAT
#line 772 "test-new/nrimp10s-77.imp"
goto L_0054;
#line 772 "test-new/nrimp10s-77.imp"
}
#line 772 "test-new/nrimp10s-77.imp"
L_0055:;
// 773 %IF MODE#0 %THEN TLINE(-7)=M'"'
#line 773 "test-new/nrimp10s-77.imp"
if (MODE == 0) goto L_0057;
#line 773 "test-new/nrimp10s-77.imp"
TLINE[53] = 34;
#line 773 "test-new/nrimp10s-77.imp"
L_0057:;
// 774 TLINE(-8)=LL+8
#line 774 "test-new/nrimp10s-77.imp"
TLINE[52] = LL + 8;
// 775 IOCP(15,ADDR(TLINE(-8)))
#line 775 "test-new/nrimp10s-77.imp"
IOCP(15, _imp_ADDR(/*?*/ &TLINE[52]));
// 776 %FINISH
#line 776 "test-new/nrimp10s-77.imp"
L_0051:;
// 777 %IF FREE FORMAT=0 %AND LL>73 %THEN TLINE(73)=10 %AND LL=73
#line 777 "test-new/nrimp10s-77.imp"
if (FREEFORMAT != 0) goto L_0058;
#line 777 "test-new/nrimp10s-77.imp"
if (LL <= 73) goto L_0058;
#line 777 "test-new/nrimp10s-77.imp"
TLINE[133] = 10;
#line 777 "test-new/nrimp10s-77.imp"
LL = 73;
#line 777 "test-new/nrimp10s-77.imp"
L_0058:;
// 778 %END
#line 778 "test-new/nrimp10s-77.imp"
return;
#line 778 "test-new/nrimp10s-77.imp"
} /* end of GETLINE */
// ?OLIST unused
// ?IMP unused
// 779 %END
#line 779 "test-new/nrimp10s-77.imp"
return;
#line 779 "test-new/nrimp10s-77.imp"
} /* end of READLINE */
// 780 %INTEGERFN COMPARE(%INTEGER P)
#line 780 "test-new/nrimp10s-77.imp"
int COMPARE(int P) {
// 781 %INTEGER I, J, ITEM, RA, RL, RP, RQ, RR, RS, MARKER, SSL, ALT, PP
#line 781 "test-new/nrimp10s-77.imp"
int I;
#line 781 "test-new/nrimp10s-77.imp"
int J;
#line 781 "test-new/nrimp10s-77.imp"
int ITEM;
#line 781 "test-new/nrimp10s-77.imp"
int RA;
#line 781 "test-new/nrimp10s-77.imp"
int RL;
#line 781 "test-new/nrimp10s-77.imp"
int RP;
#line 781 "test-new/nrimp10s-77.imp"
int RQ;
#line 781 "test-new/nrimp10s-77.imp"
int RR;
#line 781 "test-new/nrimp10s-77.imp"
int RS;
#line 781 "test-new/nrimp10s-77.imp"
int MARKER;
#line 781 "test-new/nrimp10s-77.imp"
int SSL;
#line 781 "test-new/nrimp10s-77.imp"
int ALT;
#line 781 "test-new/nrimp10s-77.imp"
int PP;
// 782 %OWNINTEGER SAVECOMP; ! FOR CHECKING DSIDED CONDS
#line 782 "test-new/nrimp10s-77.imp"
static int SAVECOMP;
// 783 %SWITCH BIP(999:1038)
#line 783 "test-new/nrimp10s-77.imp"
int BIP_index;
#line 783 "test-new/nrimp10s-77.imp"
int BIP_line;
#line 783 "test-new/nrimp10s-77.imp"
char *BIP_file;
#line 783 "test-new/nrimp10s-77.imp"
static const void *BIP[40] = {
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing,
&&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing, &&case_BIP_missing};
// 784 ! %IF USE IMP=YES %THEN %START
// 785 RP=SYMBOL(P)
#line 785 "test-new/nrimp10s-77.imp"
RP = SYMBOL[P - 1300];
// 786 RL=LEVEL
#line 786 "test-new/nrimp10s-77.imp"
RL = LEVEL;
// 787 P=P+1
#line 787 "test-new/nrimp10s-77.imp"
P = P + 1;
// 788 PP=P; ! ROUTINE REALLY STARTS HERE
#line 788 "test-new/nrimp10s-77.imp"
PP = P;
// 789 ! %FINISH %ELSE %START
// 790 ! *LB_P
// 791 ! *JLK_2
// 792 ! *EXIT_-64
// 793 !SUBENTRY:
// 794 ! *LSS_(ASYM0+%B)
// 795 ! *LUH_LEVEL
// 796 ! *ST_RL
// 797 ! *ADB_1
// 798 ! *STB_P
// 799 ! *STB_PP
// 800 ! %FINISH
// 801 COMM:
#line 801 "test-new/nrimp10s-77.imp"
U_1004:;
// 802 ! %IF USE IMP=YES %THEN %START
// 803 RQ=Q; ! RESET VALUES OF LINE&AR PTRS
#line 803 "test-new/nrimp10s-77.imp"
RQ = Q;
// 804 RR=R
#line 804 "test-new/nrimp10s-77.imp"
RR = R;
// 805 SSL=STRLINK; ! SAVE STRING LINK
#line 805 "test-new/nrimp10s-77.imp"
SSL = STRLINK;
// 806 ALT=1; ! FIRST ALTERNATIVE TO BE TRIED
#line 806 "test-new/nrimp10s-77.imp"
ALT = 1;
// 807 RA=SYMBOL(P); ! RA TO NEXT PHRASE ALTERNATIVE
#line 807 "test-new/nrimp10s-77.imp"
RA = SYMBOL[P - 1300];
// 808 RS=P
#line 808 "test-new/nrimp10s-77.imp"
RS = P;
// 809 ! %FINISH %ELSE %START
// 810 ! *LSD_Q
// 811 ! *ST_RQ
// 812 ! *LSS_1
// 813 ! *LUH_STRLINK
// 814 ! *ST_SSL
// 815 ! *LB_P
// 816 ! *LSS_(ASYM0+%B)
// 817 ! *ST_RA
// 818 ! *STB_RS
// 819 ! %FINISH
// 820 UPR: R=R+1
#line 820 "test-new/nrimp10s-77.imp"
U_1005:;
#line 820 "test-new/nrimp10s-77.imp"
R = R + 1;
// 821 SUCC: ! SUCCESS ON TO NEXT ITEM
#line 821 "test-new/nrimp10s-77.imp"
U_1006:;
// 822 ! %IF USE IMP=YES %THEN %START
// 823 RS=RS+1; ! RS=NEXT ALTERNATIVE MEANS THAT
#line 823 "test-new/nrimp10s-77.imp"
RS = RS + 1;
// 824 ! THIS ALT HAS BEEN COMPLETED SO
// 825 ! EXIT WITH HIT=1
// 826 %IF RS=RA %THEN ->FINI
#line 826 "test-new/nrimp10s-77.imp"
if (RS != RA) goto L_0059;
#line 826 "test-new/nrimp10s-77.imp"
goto U_1007;
#line 826 "test-new/nrimp10s-77.imp"
L_0059:;
// 827 ITEM=SYMBOL(RS); ! NEXT BRICK IN THE CURRENT ALT
#line 827 "test-new/nrimp10s-77.imp"
ITEM = SYMBOL[RS - 1300];
// 828 %IF ITEM<999 %THEN ->LIT
#line 828 "test-new/nrimp10s-77.imp"
if (ITEM >= 999) goto L_005A;
#line 828 "test-new/nrimp10s-77.imp"
goto U_1008;
#line 828 "test-new/nrimp10s-77.imp"
L_005A:;
// 829 ! %FINISH %ELSE %START
// 830 ! *LB_RS
// 831 ! *ADB_1
// 832 ! *CPB_RA
// 833 ! *JCC_8,<FINI>
// 834 ! *STB_RS
// 835 ! *LB_(ASYM0+%B)
// 836 ! *CPB_999
// 837 ! *JCC_4,<LIT>
// 838 ! *STB_ITEM
// 839 ! %FINISH
// 840 %IF ITEM<1300 %THEN ->BIP(ITEM)
#line 840 "test-new/nrimp10s-77.imp"
if (ITEM >= 1300) goto L_005B;
#line 840 "test-new/nrimp10s-77.imp"
BIP_line = __LINE__;
BIP_file = __FILE__;
BIP_index = ITEM;
goto case_BIP_dispatch;
#line 840 "test-new/nrimp10s-77.imp"
L_005B:;
// 841 ! BRICK IS A PHRASE TYPE
// 842 ! %IF USE IMP=YES %THEN %START
// 843 %IF COMPARE(ITEM)=0 %THEN ->FAIL
#line 843 "test-new/nrimp10s-77.imp"
if (COMPARE(ITEM) != 0) goto L_005D;
#line 843 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 843 "test-new/nrimp10s-77.imp"
L_005D:;
// 844 ! %FINISH %ELSE %START
// 845 ! *LSD_RA
// 846 ! *SLSQ_RP
// 847 ! *SLSQ_MARKER
// 848 ! *ST_%TOS
// 849 ! *LB_ITEM
// 850 ! *JLK_<SUBENTRY>
// 851 ! *ST_%B; ! RESULT=0 FOR FAIL
// 852 ! *LSQ_%TOS; *ST_MARKER
// 853 ! *LSQ_%TOS; *ST_RP
// 854 ! *LSD_%TOS; *ST_RA
// 855 ! *JAT_12,<FAIL>
// 856 ! %FINISH
// 857 ->SUCC
#line 857 "test-new/nrimp10s-77.imp"
goto U_1006;
// 858 LIT: ! BRICK IS LITERAL
#line 858 "test-new/nrimp10s-77.imp"
U_1008:;
// 859 ! %IF USE IMP=YES %THEN %START
// 860 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 860 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 861 ->FAIL %UNLESS I=CLETT(ITEM+1)
#line 861 "test-new/nrimp10s-77.imp"
if (I == CLETT[ITEM + 1]) goto L_005E;
#line 861 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 861 "test-new/nrimp10s-77.imp"
L_005E:;
// 862 Q=Q+1
#line 862 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 863 K=CLETT(ITEM)+ITEM
#line 863 "test-new/nrimp10s-77.imp"
K = CLETT[ITEM] + ITEM;
// 864 ITEM=ITEM+2
#line 864 "test-new/nrimp10s-77.imp"
ITEM = ITEM + 2;
// 865 %WHILE ITEM<=K %CYCLE
#line 865 "test-new/nrimp10s-77.imp"
L_005F:;
#line 865 "test-new/nrimp10s-77.imp"
if (ITEM > K) goto L_0060;
// 866 ->FAIL %UNLESS CC(Q)=CLETT(ITEM)
#line 866 "test-new/nrimp10s-77.imp"
if (CC[Q] == CLETT[ITEM]) goto L_0061;
#line 866 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 866 "test-new/nrimp10s-77.imp"
L_0061:;
// 867 Q=Q+1
#line 867 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 868 ITEM=ITEM+1
#line 868 "test-new/nrimp10s-77.imp"
ITEM = ITEM + 1;
// 869 %REPEAT; ! CHECK IT WITH LITERAL DICT ENTRY
#line 869 "test-new/nrimp10s-77.imp"
goto L_005F;
#line 869 "test-new/nrimp10s-77.imp"
L_0060:;
// 870 ! %FINISH %ELSE %START
// 871 ! *LDB_(CLETT+%B)
// 872 ! *INCA_%B
// 873 ! *INCA_1
// 874 ! *LSS_Q
// 875 ! *IAD_CC+4
// 876 ! *LUH_CC
// 877 ! *CPS_%L=%DR,0,0
// 878 ! *JCC_7,<FAIL>
// 879 ! *STUH_%B
// 880 ! *ISB_CC+4
// 881 ! *ST_Q
// 882 ! %FINISH
// 883 ->SUCC; ! MATCHED SUCCESSFULLY
#line 883 "test-new/nrimp10s-77.imp"
goto U_1006;
// 884 FAIL: ! FAILURE - NOTE POSITION REACHD
#line 884 "test-new/nrimp10s-77.imp"
U_1009:;
// 885 ! %IF USE IMP=YES %THEN %START
// 886 %IF RA=RP %THEN ->TFAIL; ! TOTAL FAILURE NO ALT TO TRY
#line 886 "test-new/nrimp10s-77.imp"
if (RA != RP) goto L_0062;
#line 886 "test-new/nrimp10s-77.imp"
goto U_100A;
#line 886 "test-new/nrimp10s-77.imp"
L_0062:;
// 887 QMAX=Q %IF Q>QMAX
#line 887 "test-new/nrimp10s-77.imp"
if (Q <= QMAX) goto L_0063;
#line 887 "test-new/nrimp10s-77.imp"
QMAX = Q;
#line 887 "test-new/nrimp10s-77.imp"
L_0063:;
// 888 Q=RQ; ! RESET LINE AND A.R. POINTERS
#line 888 "test-new/nrimp10s-77.imp"
Q = RQ;
// 889 R=RR+1; ! AVOID GOING VIA UPR:
#line 889 "test-new/nrimp10s-77.imp"
R = RR + 1;
// 890 STRLINK=SSL
#line 890 "test-new/nrimp10s-77.imp"
STRLINK = SSL;
// 891 ALT=ALT+1; ! MOVE TO NEXT ALT OF PHRASE
#line 891 "test-new/nrimp10s-77.imp"
ALT = ALT + 1;
// 892 RS=RA
#line 892 "test-new/nrimp10s-77.imp"
RS = RA;
// 893 RA=SYMBOL(RA)
#line 893 "test-new/nrimp10s-77.imp"
RA = SYMBOL[RA - 1300];
// 894 ! %FINISH %ELSE %START
// 895 ! *LB_RA
// 896 ! *CPB_RP
// 897 ! *JCC_8,<TFAIL>
// 898 ! *LSS_Q
// 899 ! *ICP_QMAX
// 900 ! *JCC_12,<CPL1>
// 901 ! *ST_QMAX
// 902 !CPL1: *LSD_RQ
// 903 ! *IAD_1
// 904 ! *ST_Q
// 905 ! *L_SSL
// 906 ! *STUH_STRLINK
// 907 ! *IAD_1
// 908 ! *ST_ALT
// 909 ! *STB_RS
// 910 ! *L_(ASYM0+%B)
// 911 ! *ST_RA
// 912 ! %FINISH
// 913 ->SUCC
#line 913 "test-new/nrimp10s-77.imp"
goto U_1006;
// 914 TFAIL:
#line 914 "test-new/nrimp10s-77.imp"
U_100A:;
// 915 LEVEL=RL
#line 915 "test-new/nrimp10s-77.imp"
LEVEL = RL;
// 916 ! %IF USE IMP=YES %THEN %START
// 917 %RESULT=0
#line 917 "test-new/nrimp10s-77.imp"
return 0;
// 918 ! %FINISH %ELSE %START
// 919 ! *LSS_0; *J_%TOS
// 920 ! %FINISH
// 921 BIP(999): ! REPEATED PHRASE
#line 921 "test-new/nrimp10s-77.imp"
case_BIP_999:;
// 922 A(RR)=ALT; P=PP
#line 922 "test-new/nrimp10s-77.imp"
A[RR] = ALT;
#line 922 "test-new/nrimp10s-77.imp"
P = PP;
// 923 ->COMM
#line 923 "test-new/nrimp10s-77.imp"
goto U_1004;
// 924 BIP(1000):FINI: ! NULL ALWAYS LAST & OK
#line 924 "test-new/nrimp10s-77.imp"
case_BIP_1000:;
#line 924 "test-new/nrimp10s-77.imp"
U_1007:;
// 925 A(RR)=ALT
#line 925 "test-new/nrimp10s-77.imp"
A[RR] = ALT;
// 926 ! %IF USE IMP=YES %THEN %START
// 927 %RESULT=1
#line 927 "test-new/nrimp10s-77.imp"
return 1;
// 928 ! %FINISH %ELSE %START
// 929 ! *LSS_1; *J_%TOS
// 930 ! %FINISH
// 931 BIP(1001): ! PHRASE NAME
#line 931 "test-new/nrimp10s-77.imp"
case_BIP_1001:;
// 932 BIP(1004): ! PHRASE OLDNAME
#line 932 "test-new/nrimp10s-77.imp"
case_BIP_1004:;
// 933 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 933 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 934 ->FAIL %UNLESS TRTAB(I)=2
#line 934 "test-new/nrimp10s-77.imp"
if (TRTAB[I] == 2) goto L_0064;
#line 934 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 934 "test-new/nrimp10s-77.imp"
L_0064:;
// 935 PNAME(ITEM-1004)
#line 935 "test-new/nrimp10s-77.imp"
PNAME(ITEM - 1004);
// 936 ->SUCC %IF HIT=1; ->FAIL
#line 936 "test-new/nrimp10s-77.imp"
if (HIT != 1) goto L_0065;
#line 936 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 936 "test-new/nrimp10s-77.imp"
L_0065:;
#line 936 "test-new/nrimp10s-77.imp"
goto U_1009;
// 937 BIP(1002): ! PHRASE INTEGER CONSTANT
#line 937 "test-new/nrimp10s-77.imp"
case_BIP_1002:;
// 938 BIP(1003): ! PHRASE CONST
#line 938 "test-new/nrimp10s-77.imp"
case_BIP_1003:;
// 939 CONST(ITEM-1003)
#line 939 "test-new/nrimp10s-77.imp"
CONST(ITEM - 1003);
// 940 ->FAIL %IF HIT=0
#line 940 "test-new/nrimp10s-77.imp"
if (HIT != 0) goto L_0066;
#line 940 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 940 "test-new/nrimp10s-77.imp"
L_0066:;
// 941 ->SUCC
#line 941 "test-new/nrimp10s-77.imp"
goto U_1006;
// 942 BIP(1005): ! PHRASE N
#line 942 "test-new/nrimp10s-77.imp"
case_BIP_1005:;
// 943 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 943 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 944 ->FAIL %UNLESS '0'<=I<='9'
#line 944 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 944 "test-new/nrimp10s-77.imp"
int tmp;
#line 944 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_001E;
// Double-sided test on I (Part II)
#line 944 "test-new/nrimp10s-77.imp"
if (tmp <= 57) goto L_0067;
#line 944 "test-new/nrimp10s-77.imp"
}
#line 944 "test-new/nrimp10s-77.imp"
L_001E:;
#line 944 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 944 "test-new/nrimp10s-77.imp"
L_0067:;
// 945 S=0
#line 945 "test-new/nrimp10s-77.imp"
S = 0;
// 946 %WHILE '0'<=I<='9' %CYCLE
#line 946 "test-new/nrimp10s-77.imp"
L_0068:;
#line 946 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 946 "test-new/nrimp10s-77.imp"
int tmp;
#line 946 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_0069;
// Double-sided test on I (Part II)
#line 946 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_0069;
#line 946 "test-new/nrimp10s-77.imp"
}
// 947 S=10*S+I&15
#line 947 "test-new/nrimp10s-77.imp"
S = 10 * S + (I & 15);
// 948 Q=Q+1; I=CC(Q)
#line 948 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 948 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 949 %REPEAT
#line 949 "test-new/nrimp10s-77.imp"
goto L_0068;
#line 949 "test-new/nrimp10s-77.imp"
L_0069:;
// 950 TOAR2(R,S)
#line 950 "test-new/nrimp10s-77.imp"
TOAR2(R, S);
// 951 R=R+2; ->SUCC
#line 951 "test-new/nrimp10s-77.imp"
R = R + 2;
#line 951 "test-new/nrimp10s-77.imp"
goto U_1006;
// 952 BIP(1006): ! PHRASE S=SEPARATOR
#line 952 "test-new/nrimp10s-77.imp"
case_BIP_1006:;
// 953 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 953 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 954 ->SUCC %IF I=NL
#line 954 "test-new/nrimp10s-77.imp"
if (I != 10) goto L_006A;
#line 954 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 954 "test-new/nrimp10s-77.imp"
L_006A:;
// 955 ->FAIL %UNLESS I=';'
#line 955 "test-new/nrimp10s-77.imp"
if (I == 59) goto L_006B;
#line 955 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 955 "test-new/nrimp10s-77.imp"
L_006B:;
// 956 Q=Q+1; ->SUCC
#line 956 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 956 "test-new/nrimp10s-77.imp"
goto U_1006;
// 957 BIP(1007):
#line 957 "test-new/nrimp10s-77.imp"
case_BIP_1007:;
// 958 ! PHRASE COMMENT TEXT
// 959 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 959 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 960 J=I
#line 960 "test-new/nrimp10s-77.imp"
J = I;
// 961 ->TX %IF I=';' %OR I=NL
#line 961 "test-new/nrimp10s-77.imp"
if (I == 59) goto L_006C;
#line 961 "test-new/nrimp10s-77.imp"
if (I != 10) goto L_006D;
#line 961 "test-new/nrimp10s-77.imp"
L_006C:;
#line 961 "test-new/nrimp10s-77.imp"
goto U_100B;
#line 961 "test-new/nrimp10s-77.imp"
L_006D:;
// 962 ->FAIL %UNLESS I='!' %OR I='|' %OR (I='C'+128 %AND CC(Q+1)='O'+128 %AND CC(Q+2)=CC(Q+3)='M'+128 %AND CC(Q+4)='E'+128 %AND CC(Q+5)='N'+128 %AND CC(Q+6)='T'+128)
#line 962 "test-new/nrimp10s-77.imp"
if (I == 33) goto L_006E;
#line 962 "test-new/nrimp10s-77.imp"
if (I == 124) goto L_006E;
#line 962 "test-new/nrimp10s-77.imp"
if (I != 67 + 128) goto L_006F;
#line 962 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 79 + 128) goto L_006F;
#line 962 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CC[Q + 3] (Part I)
#line 962 "test-new/nrimp10s-77.imp"
unsigned char tmp;
#line 962 "test-new/nrimp10s-77.imp"
if (CC[Q + 2] != (tmp = CC[Q + 3])) goto L_006F;
// Double-sided test on CC[Q + 3] (Part II)
#line 962 "test-new/nrimp10s-77.imp"
if (tmp != 77 + 128) goto L_006F;
#line 962 "test-new/nrimp10s-77.imp"
}
#line 962 "test-new/nrimp10s-77.imp"
if (CC[Q + 4] != 69 + 128) goto L_006F;
#line 962 "test-new/nrimp10s-77.imp"
if (CC[Q + 5] != 78 + 128) goto L_006F;
#line 962 "test-new/nrimp10s-77.imp"
if (CC[Q + 6] == 84 + 128) goto L_006E;
#line 962 "test-new/nrimp10s-77.imp"
L_006F:;
#line 962 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 962 "test-new/nrimp10s-77.imp"
L_006E:;
// 963 Q=Q+1+6*(I>>7); J=CC(Q)
#line 963 "test-new/nrimp10s-77.imp"
Q = Q + 1 + 6 * ((unsigned int)I >> 7);
#line 963 "test-new/nrimp10s-77.imp"
J = CC[Q];
// 964 %CYCLE
#line 964 "test-new/nrimp10s-77.imp"
L_0070:;
// 965 %EXIT %IF J=NL %OR J=';'
#line 965 "test-new/nrimp10s-77.imp"
if (J == 10) goto L_0056;
#line 965 "test-new/nrimp10s-77.imp"
if (J != 59) goto L_0071;
#line 965 "test-new/nrimp10s-77.imp"
L_0056:;
#line 965 "test-new/nrimp10s-77.imp"
goto L_0072;
#line 965 "test-new/nrimp10s-77.imp"
L_0071:;
// 966 Q=Q+1; J=CC(Q)
#line 966 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 966 "test-new/nrimp10s-77.imp"
J = CC[Q];
// 967 %REPEAT
#line 967 "test-new/nrimp10s-77.imp"
goto L_0070;
#line 967 "test-new/nrimp10s-77.imp"
L_0072:;
// 968 TX: Q=Q+1 %IF J=';'
#line 968 "test-new/nrimp10s-77.imp"
U_100B:;
#line 968 "test-new/nrimp10s-77.imp"
if (J != 59) goto L_0073;
#line 968 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 968 "test-new/nrimp10s-77.imp"
L_0073:;
// 969 ->SUCC
#line 969 "test-new/nrimp10s-77.imp"
goto U_1006;
// 970 BIP(1008): ! PHRASE BIGHOLE
#line 970 "test-new/nrimp10s-77.imp"
case_BIP_1008:;
// 971 TO AR4(R,0)
#line 971 "test-new/nrimp10s-77.imp"
TOAR4(R, 0);
// 972 R=R+4; ->SUCC
#line 972 "test-new/nrimp10s-77.imp"
R = R + 4;
#line 972 "test-new/nrimp10s-77.imp"
goto U_1006;
// 973 BIP(1009): ! PHRASE N255
#line 973 "test-new/nrimp10s-77.imp"
case_BIP_1009:;
// 974 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 974 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 975 ->FAIL %UNLESS '0'<=I<='9'
#line 975 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 975 "test-new/nrimp10s-77.imp"
int tmp;
#line 975 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_0074;
// Double-sided test on I (Part II)
#line 975 "test-new/nrimp10s-77.imp"
if (tmp <= 57) goto L_0075;
#line 975 "test-new/nrimp10s-77.imp"
}
#line 975 "test-new/nrimp10s-77.imp"
L_0074:;
#line 975 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 975 "test-new/nrimp10s-77.imp"
L_0075:;
// 976 S=0
#line 976 "test-new/nrimp10s-77.imp"
S = 0;
// 977 %WHILE '0'<=I<='9' %CYCLE
#line 977 "test-new/nrimp10s-77.imp"
L_0076:;
#line 977 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 977 "test-new/nrimp10s-77.imp"
int tmp;
#line 977 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_0077;
// Double-sided test on I (Part II)
#line 977 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_0077;
#line 977 "test-new/nrimp10s-77.imp"
}
// 978 S=10*S+I&15
#line 978 "test-new/nrimp10s-77.imp"
S = 10 * S + (I & 15);
// 979 Q=Q+1; I=CC(Q)
#line 979 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 979 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 980 %REPEAT
#line 980 "test-new/nrimp10s-77.imp"
goto L_0076;
#line 980 "test-new/nrimp10s-77.imp"
L_0077:;
// 981 ->FAIL %UNLESS 0<=S<=255
#line 981 "test-new/nrimp10s-77.imp"
{
// Double-sided test on S (Part I)
#line 981 "test-new/nrimp10s-77.imp"
int tmp;
#line 981 "test-new/nrimp10s-77.imp"
if (0 > (tmp = S)) goto L_0078;
// Double-sided test on S (Part II)
#line 981 "test-new/nrimp10s-77.imp"
if (tmp <= 255) goto L_0079;
#line 981 "test-new/nrimp10s-77.imp"
}
#line 981 "test-new/nrimp10s-77.imp"
L_0078:;
#line 981 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 981 "test-new/nrimp10s-77.imp"
L_0079:;
// 982 A(R)=S; ->UPR
#line 982 "test-new/nrimp10s-77.imp"
A[R] = S;
#line 982 "test-new/nrimp10s-77.imp"
goto U_1005;
// 983 BIP(1010): ! PHRASE HOLE
#line 983 "test-new/nrimp10s-77.imp"
case_BIP_1010:;
// 984 MARKER=R; R=R+2; ->SUCC
#line 984 "test-new/nrimp10s-77.imp"
MARKER = R;
#line 984 "test-new/nrimp10s-77.imp"
R = R + 2;
#line 984 "test-new/nrimp10s-77.imp"
goto U_1006;
// 985 BIP(1011): ! PHRASE MARK
#line 985 "test-new/nrimp10s-77.imp"
case_BIP_1011:;
// 986 I=R-MARKER
#line 986 "test-new/nrimp10s-77.imp"
I = R - MARKER;
// 987 A(MARKER+1)<-I
#line 987 "test-new/nrimp10s-77.imp"
A[MARKER + 1] = (unsigned char)(I);
// 988 A(MARKER)<-I>>8
#line 988 "test-new/nrimp10s-77.imp"
A[MARKER] = (unsigned char)((unsigned int)I >> 8);
// 989 ->SUCC
#line 989 "test-new/nrimp10s-77.imp"
goto U_1006;
// 990 BIP(1012): ! PHRASE READLINE?
#line 990 "test-new/nrimp10s-77.imp"
case_BIP_1012:;
// 991 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 991 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 992 %WHILE I=NL %%CYCLE
#line 992 "test-new/nrimp10s-77.imp"
L_007A:;
#line 992 "test-new/nrimp10s-77.imp"
if (I != 10) goto L_007B;
// 993 READLINE(0,0)
#line 993 "test-new/nrimp10s-77.imp"
READLINE(0, 0);
// 994 RQ=1
#line 994 "test-new/nrimp10s-77.imp"
RQ = 1;
// 995 I=CC(Q)
#line 995 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 996 %REPEAT
#line 996 "test-new/nrimp10s-77.imp"
goto L_007A;
#line 996 "test-new/nrimp10s-77.imp"
L_007B:;
// 997 FAULT(102,0) %IF R>ARSIZE
#line 997 "test-new/nrimp10s-77.imp"
if (R <= ARSIZE) goto L_007C;
#line 997 "test-new/nrimp10s-77.imp"
FAULT(102, 0);
#line 997 "test-new/nrimp10s-77.imp"
L_007C:;
// 998 ->SUCC
#line 998 "test-new/nrimp10s-77.imp"
goto U_1006;
// 999 BIP(1013): ! PHRASE CHECKIMPS
#line 999 "test-new/nrimp10s-77.imp"
case_BIP_1013:;
// 1000 ->FAIL %UNLESS IMPS=1; ->SUCC
#line 1000 "test-new/nrimp10s-77.imp"
if (IMPS == 1) goto L_007D;
#line 1000 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1000 "test-new/nrimp10s-77.imp"
L_007D:;
#line 1000 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1001 BIP(1014): ! PHRASE DUMMY APP
#line 1001 "test-new/nrimp10s-77.imp"
case_BIP_1014:;
// 1002 A(R)=2; A(R+1)=2
#line 1002 "test-new/nrimp10s-77.imp"
A[R] = 2;
#line 1002 "test-new/nrimp10s-77.imp"
A[R + 1] = 2;
// 1003 R=R+2; ->SUCC
#line 1003 "test-new/nrimp10s-77.imp"
R = R + 2;
#line 1003 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1004 BIP(1015): ! PHRASE DOWN=NEW TEXT LEVEL
#line 1004 "test-new/nrimp10s-77.imp"
case_BIP_1015:;
// 1005 LEVEL=LEVEL+1
#line 1005 "test-new/nrimp10s-77.imp"
LEVEL = LEVEL + 1;
// 1006 TO AR4(R,0)
#line 1006 "test-new/nrimp10s-77.imp"
TOAR4(R, 0);
// 1007 DISPLAY(LEVEL)=R
#line 1007 "test-new/nrimp10s-77.imp"
DISPLAY[LEVEL] = R;
// 1008 SFS(LEVEL)=0
#line 1008 "test-new/nrimp10s-77.imp"
SFS[LEVEL] = 0;
// 1009 R=R+4
#line 1009 "test-new/nrimp10s-77.imp"
R = R + 4;
// 1010 ->SUCC
#line 1010 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1011 BIP(1016): ! PHRASE UP 1 TEXTUAL LEVEL
#line 1011 "test-new/nrimp10s-77.imp"
case_BIP_1016:;
// 1012 DISPLAY(LEVEL)=0
#line 1012 "test-new/nrimp10s-77.imp"
DISPLAY[LEVEL] = 0;
// 1013 %WHILE SFS(LEVEL)#0 %CYCLE
#line 1013 "test-new/nrimp10s-77.imp"
L_007E:;
#line 1013 "test-new/nrimp10s-77.imp"
if (SFS[LEVEL] == 0) goto L_007F;
// 1014 POP(SFS(LEVEL),I,J,K)
#line 1014 "test-new/nrimp10s-77.imp"
POP(/*?*/ &SFS[LEVEL], /*?*/ &I, /*?*/ &J, /*?*/ &K);
// 1015 %IF I=1 %THEN FAULT2(53,K,0); ! FINISH MISSING
#line 1015 "test-new/nrimp10s-77.imp"
if (I != 1) goto L_0080;
#line 1015 "test-new/nrimp10s-77.imp"
FAULT2(53, K, 0);
#line 1015 "test-new/nrimp10s-77.imp"
L_0080:;
// 1016 %IF I=2 %THEN FAULT2(13,K,0); ! %REPEAT MISSING
#line 1016 "test-new/nrimp10s-77.imp"
if (I != 2) goto L_0081;
#line 1016 "test-new/nrimp10s-77.imp"
FAULT2(13, K, 0);
#line 1016 "test-new/nrimp10s-77.imp"
L_0081:;
// 1017 %REPEAT
#line 1017 "test-new/nrimp10s-77.imp"
goto L_007E;
#line 1017 "test-new/nrimp10s-77.imp"
L_007F:;
// 1018 LEVEL=LEVEL-1
#line 1018 "test-new/nrimp10s-77.imp"
LEVEL = LEVEL - 1;
// 1019 ->SUCC
#line 1019 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1020 BIP(1017): ! PHRASE LISTON
#line 1020 "test-new/nrimp10s-77.imp"
case_BIP_1017:;
// 1021 LIST=1; ->SUCC
#line 1021 "test-new/nrimp10s-77.imp"
LIST = 1;
#line 1021 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1022 BIP(1018): ! PHRASE LISTOFF
#line 1022 "test-new/nrimp10s-77.imp"
case_BIP_1018:;
// 1023 LIST=0; ->SUCC
#line 1023 "test-new/nrimp10s-77.imp"
LIST = 0;
#line 1023 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1024 BIP(1019): ! PHRASE COLON FOR LABEL
#line 1024 "test-new/nrimp10s-77.imp"
case_BIP_1019:;
// 1025 ->FAIL %UNLESS CC(Q-1)=':'
#line 1025 "test-new/nrimp10s-77.imp"
if (CC[Q - 1] == 58) goto L_0082;
#line 1025 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1025 "test-new/nrimp10s-77.imp"
L_0082:;
// 1026 ->SUCC
#line 1026 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1027 BIP(1020): ! PHRASE NOTE CONST
#line 1027 "test-new/nrimp10s-77.imp"
case_BIP_1020:;
// 1028 %IF CTYPE=5 %THEN TOAR4(S-4,STRLINK) %AND STRLINK=S-4
#line 1028 "test-new/nrimp10s-77.imp"
if (CTYPE != 5) goto L_0083;
#line 1028 "test-new/nrimp10s-77.imp"
TOAR4(S - 4, STRLINK);
#line 1028 "test-new/nrimp10s-77.imp"
STRLINK = S - 4;
#line 1028 "test-new/nrimp10s-77.imp"
L_0083:;
// 1029 ->SUCC
#line 1029 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1030 BIP(1021): ! TRACE FOR ON CONDITIONS
#line 1030 "test-new/nrimp10s-77.imp"
case_BIP_1021:;
// 1031 PARMTRACE=1; ->SUCC
#line 1031 "test-new/nrimp10s-77.imp"
PARMTRACE = 1;
#line 1031 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1032 BIP(1022): ! SET MNEMONIC
#line 1032 "test-new/nrimp10s-77.imp"
case_BIP_1022:;
// 1033 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1033 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1034 S=M' '
#line 1034 "test-new/nrimp10s-77.imp"
S = 538976288;
// 1035 %WHILE 'A'<=I<='Z' %CYCLE
#line 1035 "test-new/nrimp10s-77.imp"
L_0084:;
#line 1035 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1035 "test-new/nrimp10s-77.imp"
int tmp;
#line 1035 "test-new/nrimp10s-77.imp"
if (65 > (tmp = I)) goto L_0085;
// Double-sided test on I (Part II)
#line 1035 "test-new/nrimp10s-77.imp"
if (tmp > 90) goto L_0085;
#line 1035 "test-new/nrimp10s-77.imp"
}
// 1036 S=S<<8!I; Q=Q+1; I=CC(Q)
#line 1036 "test-new/nrimp10s-77.imp"
S = S << 8 | I;
#line 1036 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1036 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1037 %REPEAT
#line 1037 "test-new/nrimp10s-77.imp"
goto L_0084;
#line 1037 "test-new/nrimp10s-77.imp"
L_0085:;
// 1038 ->FAIL %UNLESS I='_' %AND S#M' '
#line 1038 "test-new/nrimp10s-77.imp"
if (I != 95) goto L_0086;
#line 1038 "test-new/nrimp10s-77.imp"
if (S != 538976288) goto L_0087;
#line 1038 "test-new/nrimp10s-77.imp"
L_0086:;
#line 1038 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1038 "test-new/nrimp10s-77.imp"
L_0087:;
// 1039 Q=Q+1; ->SUCC
#line 1039 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1039 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1040 BIP(1023): ! PRIMARY FORMAT MNEMOINC
#line 1040 "test-new/nrimp10s-77.imp"
case_BIP_1023:;
// 1041 %CYCLE I=7,1,126
#line 1041 "test-new/nrimp10s-77.imp"
// %for I = 7, 1, 126 %cycle
#line 1041 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 7, _increment = 1, _final = 126;
#line 1041 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 7, 1, 126");
_control = I = _initial - _increment;
#line 1041 "test-new/nrimp10s-77.imp"
L_0088:
#line 1041 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1041 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0089;
#line 1041 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 1042 ->PFND %IF OPC(I)=S
#line 1042 "test-new/nrimp10s-77.imp"
if (OPC[I] != S) goto L_008B;
#line 1042 "test-new/nrimp10s-77.imp"
goto U_100C;
#line 1042 "test-new/nrimp10s-77.imp"
L_008B:;
// 1043 %REPEAT
#line 1043 "test-new/nrimp10s-77.imp"
goto L_0088;
#line 1043 "test-new/nrimp10s-77.imp"
}
#line 1043 "test-new/nrimp10s-77.imp"
L_0089:;
// 1044 ->FAIL
#line 1044 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1045 PFND:
#line 1045 "test-new/nrimp10s-77.imp"
U_100C:;
// 1046 ->FAIL %IF 8<=I>>3<=11 %AND I&7<=3
#line 1046 "test-new/nrimp10s-77.imp"
{
// Double-sided test on (unsigned int)I >> 3 (Part I)
#line 1046 "test-new/nrimp10s-77.imp"
int tmp;
#line 1046 "test-new/nrimp10s-77.imp"
if (8 > (tmp = (unsigned int)I >> 3)) goto L_008C;
// Double-sided test on (unsigned int)I >> 3 (Part II)
#line 1046 "test-new/nrimp10s-77.imp"
if (tmp > 11) goto L_008C;
#line 1046 "test-new/nrimp10s-77.imp"
}
#line 1046 "test-new/nrimp10s-77.imp"
if (I & 7 > 3) goto L_008C;
#line 1046 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1046 "test-new/nrimp10s-77.imp"
L_008C:;
// 1047 A(R)=2*I; ->UPR
#line 1047 "test-new/nrimp10s-77.imp"
A[R] = 2 * I;
#line 1047 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1048 BIP(1024): ! SECONDARY FORMAT MNEMONIC
#line 1048 "test-new/nrimp10s-77.imp"
case_BIP_1024:;
// 1049 %CYCLE I=64,8,88
#line 1049 "test-new/nrimp10s-77.imp"
// %for I = 64, 8, 88 %cycle
#line 1049 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 64, _increment = 8, _final = 88;
#line 1049 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 64, 8, 88");
_control = I = _initial - _increment;
#line 1049 "test-new/nrimp10s-77.imp"
L_008D:
#line 1049 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1049 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_008E;
#line 1049 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 1050 %CYCLE J=0,1,3
#line 1050 "test-new/nrimp10s-77.imp"
// %for J = 0, 1, 3 %cycle
#line 1050 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 3;
#line 1050 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 0, 1, 3");
_control = J = _initial - _increment;
#line 1050 "test-new/nrimp10s-77.imp"
L_008F:
#line 1050 "test-new/nrimp10s-77.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 1050 "test-new/nrimp10s-77.imp"
if (J == _final) goto L_0090;
#line 1050 "test-new/nrimp10s-77.imp"
_control += _increment;
J += _increment;
// 1051 ->SFND %IF OPC(I+J)=S
#line 1051 "test-new/nrimp10s-77.imp"
if (OPC[I + J] != S) goto L_0092;
#line 1051 "test-new/nrimp10s-77.imp"
goto U_100D;
#line 1051 "test-new/nrimp10s-77.imp"
L_0092:;
// 1052 %REPEAT
#line 1052 "test-new/nrimp10s-77.imp"
goto L_008F;
#line 1052 "test-new/nrimp10s-77.imp"
}
#line 1052 "test-new/nrimp10s-77.imp"
L_0090:;
// 1053 %REPEAT
#line 1053 "test-new/nrimp10s-77.imp"
goto L_008D;
#line 1053 "test-new/nrimp10s-77.imp"
}
#line 1053 "test-new/nrimp10s-77.imp"
L_008E:;
// 1054 ->FAIL
#line 1054 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1055 SFND: A(R)=2*(I+J); ->UPR
#line 1055 "test-new/nrimp10s-77.imp"
U_100D:;
#line 1055 "test-new/nrimp10s-77.imp"
A[R] = 2 * (I + J);
#line 1055 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1056 BIP(1025): ! TERTIARY FORMAT MNEMONIC
#line 1056 "test-new/nrimp10s-77.imp"
case_BIP_1025:;
// 1057 %CYCLE I=3,-1,1
#line 1057 "test-new/nrimp10s-77.imp"
// %for I = 3, -1, 1 %cycle
#line 1057 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 3, _increment = -1, _final = 1;
#line 1057 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 3, -1, 1");
_control = I = _initial - _increment;
#line 1057 "test-new/nrimp10s-77.imp"
L_0093:
#line 1057 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1057 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0094;
#line 1057 "test-new/nrimp10s-77.imp"
_control += _increment;
I -= 1;
// 1058 %IF OPC(I)=S %THEN A(R)=2*I %AND ->UPR
#line 1058 "test-new/nrimp10s-77.imp"
if (OPC[I] != S) goto L_0095;
#line 1058 "test-new/nrimp10s-77.imp"
A[R] = 2 * I;
#line 1058 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1058 "test-new/nrimp10s-77.imp"
L_0095:;
// 1059 %REPEAT; ->FAIL
#line 1059 "test-new/nrimp10s-77.imp"
goto L_0093;
#line 1059 "test-new/nrimp10s-77.imp"
}
#line 1059 "test-new/nrimp10s-77.imp"
L_0094:;
#line 1059 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1060 BIP(1026): ! P(OP)=+,-,&,****,**,*,!!,!,
#line 1060 "test-new/nrimp10s-77.imp"
case_BIP_1026:;
// 1061 ! //,/,>>,<<,.,\\,\;
// 1062 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1062 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1063 ->FAIL %UNLESS 32<I<127 %AND 16_80000000>>((I-32)&31)&16_4237000A#0
#line 1063 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1063 "test-new/nrimp10s-77.imp"
int tmp;
#line 1063 "test-new/nrimp10s-77.imp"
if (32 >= (tmp = I)) goto L_008A;
// Double-sided test on I (Part II)
#line 1063 "test-new/nrimp10s-77.imp"
if (tmp >= 127) goto L_008A;
#line 1063 "test-new/nrimp10s-77.imp"
}
#line 1063 "test-new/nrimp10s-77.imp"
if ((unsigned int)-2147483648 >> (I - 32 & 31) & 1110900746 != 0) goto L_0096;
#line 1063 "test-new/nrimp10s-77.imp"
L_008A:;
#line 1063 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1063 "test-new/nrimp10s-77.imp"
L_0096:;
// 1064 Q=Q+1
#line 1064 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1065 %IF I='+' %THEN A(R)=1 %AND ->UPR
#line 1065 "test-new/nrimp10s-77.imp"
if (I != 43) goto L_0097;
#line 1065 "test-new/nrimp10s-77.imp"
A[R] = 1;
#line 1065 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1065 "test-new/nrimp10s-77.imp"
L_0097:;
// 1066 %IF I='-' %THEN A(R)=2 %AND ->UPR
#line 1066 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_0098;
#line 1066 "test-new/nrimp10s-77.imp"
A[R] = 2;
#line 1066 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1066 "test-new/nrimp10s-77.imp"
L_0098:;
// 1067 %IF I='&' %THEN A(R)=3 %AND ->UPR
#line 1067 "test-new/nrimp10s-77.imp"
if (I != 38) goto L_0099;
#line 1067 "test-new/nrimp10s-77.imp"
A[R] = 3;
#line 1067 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1067 "test-new/nrimp10s-77.imp"
L_0099:;
// 1068 J=CC(Q)
#line 1068 "test-new/nrimp10s-77.imp"
J = CC[Q];
// 1069 %IF I='*' %THEN %START
#line 1069 "test-new/nrimp10s-77.imp"
if (I != 42) goto L_009A;
// 1070 %IF J#I %THEN A(R)=6 %AND ->UPR
#line 1070 "test-new/nrimp10s-77.imp"
if (J == I) goto L_009B;
#line 1070 "test-new/nrimp10s-77.imp"
A[R] = 6;
#line 1070 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1070 "test-new/nrimp10s-77.imp"
L_009B:;
// 1071 %IF CC(Q+1)=I=CC(Q+2) %THEN A(R)=4 %AND Q=Q+3 %AND ->UPR
#line 1071 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1071 "test-new/nrimp10s-77.imp"
int tmp;
#line 1071 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != (tmp = I)) goto L_009C;
// Double-sided test on I (Part II)
#line 1071 "test-new/nrimp10s-77.imp"
if (tmp != CC[Q + 2]) goto L_009C;
#line 1071 "test-new/nrimp10s-77.imp"
}
#line 1071 "test-new/nrimp10s-77.imp"
A[R] = 4;
#line 1071 "test-new/nrimp10s-77.imp"
Q = Q + 3;
#line 1071 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1071 "test-new/nrimp10s-77.imp"
L_009C:;
// 1072 A(R)=5; Q=Q+1; ->UPR
#line 1072 "test-new/nrimp10s-77.imp"
A[R] = 5;
#line 1072 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1072 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1073 %FINISH
#line 1073 "test-new/nrimp10s-77.imp"
L_009A:;
// 1074 %IF I='/' %THEN %START
#line 1074 "test-new/nrimp10s-77.imp"
if (I != 47) goto L_009D;
// 1075 %IF J#I %THEN A(R)=10 %AND ->UPR
#line 1075 "test-new/nrimp10s-77.imp"
if (J == I) goto L_009E;
#line 1075 "test-new/nrimp10s-77.imp"
A[R] = 10;
#line 1075 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1075 "test-new/nrimp10s-77.imp"
L_009E:;
// 1076 A(R)=9; Q=Q+1; ->UPR
#line 1076 "test-new/nrimp10s-77.imp"
A[R] = 9;
#line 1076 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1076 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1077 %FINISH
#line 1077 "test-new/nrimp10s-77.imp"
L_009D:;
// 1078 %IF I='!' %THEN %START
#line 1078 "test-new/nrimp10s-77.imp"
if (I != 33) goto L_009F;
// 1079 %IF J#I %THEN A(R)=8 %AND ->UPR
#line 1079 "test-new/nrimp10s-77.imp"
if (J == I) goto L_00A0;
#line 1079 "test-new/nrimp10s-77.imp"
A[R] = 8;
#line 1079 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1079 "test-new/nrimp10s-77.imp"
L_00A0:;
// 1080 A(R)=7; Q=Q+1; ->UPR
#line 1080 "test-new/nrimp10s-77.imp"
A[R] = 7;
#line 1080 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1080 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1081 %FINISH
#line 1081 "test-new/nrimp10s-77.imp"
L_009F:;
// 1082 %IF I='.' %THEN A(R)=13 %AND ->UPR
#line 1082 "test-new/nrimp10s-77.imp"
if (I != 46) goto L_00A1;
#line 1082 "test-new/nrimp10s-77.imp"
A[R] = 13;
#line 1082 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1082 "test-new/nrimp10s-77.imp"
L_00A1:;
// 1083 %IF I=J='<' %THEN A(R)=12 %AND Q=Q+1 %AND ->UPR
#line 1083 "test-new/nrimp10s-77.imp"
{
// Double-sided test on J (Part I)
#line 1083 "test-new/nrimp10s-77.imp"
int tmp;
#line 1083 "test-new/nrimp10s-77.imp"
if (I != (tmp = J)) goto L_00A2;
// Double-sided test on J (Part II)
#line 1083 "test-new/nrimp10s-77.imp"
if (tmp != 60) goto L_00A2;
#line 1083 "test-new/nrimp10s-77.imp"
}
#line 1083 "test-new/nrimp10s-77.imp"
A[R] = 12;
#line 1083 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1083 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1083 "test-new/nrimp10s-77.imp"
L_00A2:;
// 1084 %IF I=J='>' %THEN A(R)=11 %AND Q=Q+1 %AND ->UPR
#line 1084 "test-new/nrimp10s-77.imp"
{
// Double-sided test on J (Part I)
#line 1084 "test-new/nrimp10s-77.imp"
int tmp;
#line 1084 "test-new/nrimp10s-77.imp"
if (I != (tmp = J)) goto L_00A3;
// Double-sided test on J (Part II)
#line 1084 "test-new/nrimp10s-77.imp"
if (tmp != 62) goto L_00A3;
#line 1084 "test-new/nrimp10s-77.imp"
}
#line 1084 "test-new/nrimp10s-77.imp"
A[R] = 11;
#line 1084 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1084 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1084 "test-new/nrimp10s-77.imp"
L_00A3:;
// 1085 %IF I='\' %THEN %START
#line 1085 "test-new/nrimp10s-77.imp"
if (I != 92) goto L_00A4;
// 1086 %IF J#I %THEN A(R)=15 %AND ->UPR
#line 1086 "test-new/nrimp10s-77.imp"
if (J == I) goto L_00A5;
#line 1086 "test-new/nrimp10s-77.imp"
A[R] = 15;
#line 1086 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1086 "test-new/nrimp10s-77.imp"
L_00A5:;
// 1087 Q=Q+1; A(R)=14; ->UPR
#line 1087 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1087 "test-new/nrimp10s-77.imp"
A[R] = 14;
#line 1087 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1088 %FINISH
#line 1088 "test-new/nrimp10s-77.imp"
L_00A4:;
// 1089 ->FAIL
#line 1089 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1090 BIP(1027): ! PHRASE CHECK UI
#line 1090 "test-new/nrimp10s-77.imp"
case_BIP_1027:;
// 1091 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1091 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1092 ->SUCC %IF TRTAB(I)=2 %OR I='-'
#line 1092 "test-new/nrimp10s-77.imp"
if (TRTAB[I] == 2) goto L_00A6;
#line 1092 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_00A7;
#line 1092 "test-new/nrimp10s-77.imp"
L_00A6:;
#line 1092 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 1092 "test-new/nrimp10s-77.imp"
L_00A7:;
// 1093 ->SUCC %IF 16_80000000>>(I&31)&16_14043000#0
#line 1093 "test-new/nrimp10s-77.imp"
if ((unsigned int)-2147483648 >> (I & 31) & 335818752 == 0) goto L_00A8;
#line 1093 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 1093 "test-new/nrimp10s-77.imp"
L_00A8:;
// 1094 ->FAIL
#line 1094 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1095 BIP(1028): ! P(+')=+,-,\,0
#line 1095 "test-new/nrimp10s-77.imp"
case_BIP_1028:;
// 1096 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1096 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1097 %IF I='\' %OR I=16_7E %THEN A(R)=3 %AND Q=Q+1 %AND ->UPR
#line 1097 "test-new/nrimp10s-77.imp"
if (I == 92) goto L_00A9;
#line 1097 "test-new/nrimp10s-77.imp"
if (I != 126) goto L_00AA;
#line 1097 "test-new/nrimp10s-77.imp"
L_00A9:;
#line 1097 "test-new/nrimp10s-77.imp"
A[R] = 3;
#line 1097 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1097 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1097 "test-new/nrimp10s-77.imp"
L_00AA:;
// 1098 %IF I='-' %THEN A(R)=2 %AND Q=Q+1 %AND ->UPR
#line 1098 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_00AB;
#line 1098 "test-new/nrimp10s-77.imp"
A[R] = 2;
#line 1098 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1098 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1098 "test-new/nrimp10s-77.imp"
L_00AB:;
// 1099 %IF I='+' %THEN A(R)=1 %AND Q=Q+1 %AND ->UPR
#line 1099 "test-new/nrimp10s-77.imp"
if (I != 43) goto L_00AC;
#line 1099 "test-new/nrimp10s-77.imp"
A[R] = 1;
#line 1099 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1099 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1099 "test-new/nrimp10s-77.imp"
L_00AC:;
// 1100 A(R)=4; ->UPR
#line 1100 "test-new/nrimp10s-77.imp"
A[R] = 4;
#line 1100 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1101 BIP(1029): ! PHRASE NOTE CYCLE
#line 1101 "test-new/nrimp10s-77.imp"
case_BIP_1029:;
// 1102 TOAR4(R,0)
#line 1102 "test-new/nrimp10s-77.imp"
TOAR4(R, 0);
// 1103 PUSH(SFS(LEVEL),2,R,LINE)
#line 1103 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &SFS[LEVEL], 2, R, LINE);
// 1104 R=R+4
#line 1104 "test-new/nrimp10s-77.imp"
R = R + 4;
// 1105 ->SUCC
#line 1105 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1106 BIP(1030): ! P(,')=',',0
#line 1106 "test-new/nrimp10s-77.imp"
case_BIP_1030:;
// 1107 !
// 1108 ! THIS IS VERY AWKWARD AS IT MEANS IT IS VERY TO HARD TO FIND
// 1109 ! THE END OF A PARAMETER LIST WITHOUT CHURNING. BY MAKING THIS A BIP
// 1110 ! WE CAN PEEP AHEAD FOR ')' AND FAIL HERE.
// 1111 !
// 1112 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1112 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1113 %IF I=')' %THEN ->FAIL
#line 1113 "test-new/nrimp10s-77.imp"
if (I != 41) goto L_00AD;
#line 1113 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1113 "test-new/nrimp10s-77.imp"
L_00AD:;
// 1114 %IF I=',' %THEN Q=Q+1
#line 1114 "test-new/nrimp10s-77.imp"
if (I != 44) goto L_00AE;
#line 1114 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1114 "test-new/nrimp10s-77.imp"
L_00AE:;
// 1115 ->SUCC
#line 1115 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1116 BIP(1031): ! PHRASE CHECKTYPE IE ENSURE
#line 1116 "test-new/nrimp10s-77.imp"
case_BIP_1031:;
// 1117 ! FIRST LETTER IS(B,H,I,L,R,S) &
// 1118 ! 3RD LETTER IS (A,L,N,R,T)
// 1119 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1119 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1120 ->FAIL %UNLESS I>128 %AND 16_80000000>>(I&31)&16_20C83000#0 %AND 16_80000000>>(CC(Q+2)&31)&16_400A2800#0
#line 1120 "test-new/nrimp10s-77.imp"
if (I <= 128) goto L_00AF;
#line 1120 "test-new/nrimp10s-77.imp"
if ((unsigned int)-2147483648 >> (I & 31) & 549990400 == 0) goto L_00AF;
#line 1120 "test-new/nrimp10s-77.imp"
if ((unsigned int)-2147483648 >> (CC[Q + 2] & 31) & 1074407424 != 0) goto L_00B0;
#line 1120 "test-new/nrimp10s-77.imp"
L_00AF:;
#line 1120 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1120 "test-new/nrimp10s-77.imp"
L_00B0:;
// 1121 ->SUCC
#line 1121 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1122 BIP(1032): ! PHRASE COMP1
#line 1122 "test-new/nrimp10s-77.imp"
case_BIP_1032:;
// 1123 BIP(1037): ! PHRASE COMP2(IS 2ND HALF OF DSIDED)
#line 1123 "test-new/nrimp10s-77.imp"
case_BIP_1037:;
// 1124 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1124 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1125 ->FAIL %UNLESS 32<I<=92 %AND 16_80000000>>(I&31)&16_1004000E#0
#line 1125 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1125 "test-new/nrimp10s-77.imp"
int tmp;
#line 1125 "test-new/nrimp10s-77.imp"
if (32 >= (tmp = I)) goto L_00B1;
// Double-sided test on I (Part II)
#line 1125 "test-new/nrimp10s-77.imp"
if (tmp > 92) goto L_00B1;
#line 1125 "test-new/nrimp10s-77.imp"
}
#line 1125 "test-new/nrimp10s-77.imp"
if ((unsigned int)-2147483648 >> (I & 31) & 268697614 != 0) goto L_00B2;
#line 1125 "test-new/nrimp10s-77.imp"
L_00B1:;
#line 1125 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1125 "test-new/nrimp10s-77.imp"
L_00B2:;
// 1126 ! '='=1,'>='=2,'>'=3
// 1127 ! '#' OR '\='=4,'<='=5,'<'=6
// 1128 ! 7UNUSED,'->'=8,'=='=9
// 1129 ! '##' OR '\==' =10
// 1130 %IF I='=' %THEN %START
#line 1130 "test-new/nrimp10s-77.imp"
if (I != 61) goto L_00B3;
// 1131 %IF CC(Q+1)=I %THEN J=9 %AND ->JOIN1
#line 1131 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != I) goto L_00B4;
#line 1131 "test-new/nrimp10s-77.imp"
J = 9;
#line 1131 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1131 "test-new/nrimp10s-77.imp"
L_00B4:;
// 1132 J=1; ->JOIN
#line 1132 "test-new/nrimp10s-77.imp"
J = 1;
#line 1132 "test-new/nrimp10s-77.imp"
goto U_100F;
// 1133 %FINISH
#line 1133 "test-new/nrimp10s-77.imp"
L_00B3:;
// 1134 %IF I='#' %THEN %START
#line 1134 "test-new/nrimp10s-77.imp"
if (I != 35) goto L_00B5;
// 1135 %IF CC(Q+1)=I %THEN J=10 %AND ->JOIN1
#line 1135 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != I) goto L_00B6;
#line 1135 "test-new/nrimp10s-77.imp"
J = 10;
#line 1135 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1135 "test-new/nrimp10s-77.imp"
L_00B6:;
// 1136 J=4; ->JOIN
#line 1136 "test-new/nrimp10s-77.imp"
J = 4;
#line 1136 "test-new/nrimp10s-77.imp"
goto U_100F;
// 1137 %FINISH
#line 1137 "test-new/nrimp10s-77.imp"
L_00B5:;
// 1138 %IF I='\' %AND CC(Q+1)='=' %THEN %START
#line 1138 "test-new/nrimp10s-77.imp"
if (I != 92) goto L_00B7;
#line 1138 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 61) goto L_00B7;
// 1139 Q=Q+1
#line 1139 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1140 %IF CC(Q+1)='=' %THEN J=10 %AND ->JOIN1
#line 1140 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 61) goto L_00B8;
#line 1140 "test-new/nrimp10s-77.imp"
J = 10;
#line 1140 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1140 "test-new/nrimp10s-77.imp"
L_00B8:;
// 1141 J=4; ->JOIN
#line 1141 "test-new/nrimp10s-77.imp"
J = 4;
#line 1141 "test-new/nrimp10s-77.imp"
goto U_100F;
// 1142 %FINISH
#line 1142 "test-new/nrimp10s-77.imp"
L_00B7:;
// 1143 %IF I='>' %THEN %START
#line 1143 "test-new/nrimp10s-77.imp"
if (I != 62) goto L_00B9;
// 1144 %IF CC(Q+1)='=' %THEN J=2 %AND ->JOIN1
#line 1144 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 61) goto L_00BA;
#line 1144 "test-new/nrimp10s-77.imp"
J = 2;
#line 1144 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1144 "test-new/nrimp10s-77.imp"
L_00BA:;
// 1145 J=3; ->JOIN
#line 1145 "test-new/nrimp10s-77.imp"
J = 3;
#line 1145 "test-new/nrimp10s-77.imp"
goto U_100F;
// 1146 %FINISH
#line 1146 "test-new/nrimp10s-77.imp"
L_00B9:;
// 1147 %IF I='<' %THEN %START
#line 1147 "test-new/nrimp10s-77.imp"
if (I != 60) goto L_00BB;
// 1148 %IF CC(Q+1)='=' %THEN J=5 %AND ->JOIN1
#line 1148 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 61) goto L_00BC;
#line 1148 "test-new/nrimp10s-77.imp"
J = 5;
#line 1148 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1148 "test-new/nrimp10s-77.imp"
L_00BC:;
// 1149 J=6; ->JOIN
#line 1149 "test-new/nrimp10s-77.imp"
J = 6;
#line 1149 "test-new/nrimp10s-77.imp"
goto U_100F;
// 1150 %FINISH
#line 1150 "test-new/nrimp10s-77.imp"
L_00BB:;
// 1151 %IF I='-' %AND CC(Q+1)='>' %THEN J=8 %AND ->JOIN1
#line 1151 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_00BD;
#line 1151 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 62) goto L_00BD;
#line 1151 "test-new/nrimp10s-77.imp"
J = 8;
#line 1151 "test-new/nrimp10s-77.imp"
goto U_100E;
#line 1151 "test-new/nrimp10s-77.imp"
L_00BD:;
// 1152 ->FAIL
#line 1152 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1153 JOIN1:Q=Q+1
#line 1153 "test-new/nrimp10s-77.imp"
U_100E:;
#line 1153 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1154 JOIN: Q=Q+1
#line 1154 "test-new/nrimp10s-77.imp"
U_100F:;
#line 1154 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1155 A(R)=J
#line 1155 "test-new/nrimp10s-77.imp"
A[R] = J;
// 1156 %IF ITEM=1032 %THEN SAVECOMP=J %AND ->UPR
#line 1156 "test-new/nrimp10s-77.imp"
if (ITEM != 1032) goto L_00BE;
#line 1156 "test-new/nrimp10s-77.imp"
SAVECOMP = J;
#line 1156 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1156 "test-new/nrimp10s-77.imp"
L_00BE:;
// 1157 ! SAVE J TO CHECK DSIDED
// 1158 %IF SAVECOMP>6 %OR J>6 %THEN Q=Q-1 %AND ->FAIL;! ILLEGAL DSIDED
#line 1158 "test-new/nrimp10s-77.imp"
if (SAVECOMP > 6) goto L_00BF;
#line 1158 "test-new/nrimp10s-77.imp"
if (J <= 6) goto L_00C0;
#line 1158 "test-new/nrimp10s-77.imp"
L_00BF:;
#line 1158 "test-new/nrimp10s-77.imp"
Q = Q - 1;
#line 1158 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1158 "test-new/nrimp10s-77.imp"
L_00C0:;
// 1159 ->UPR; ! NB OWNS WONT WORK IF
#line 1159 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1160 ! COND EXPRS ALLOWED AS THE
// 1161 ! CAN BE NESTED!
// 1162 BIP(1033): ! P(ASSOP)- ==,=,<-,->
#line 1162 "test-new/nrimp10s-77.imp"
case_BIP_1033:;
// 1163 I=CC(Q); ! OBTAIN CURRENT CHARACTER
#line 1163 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1164 %IF I='=' %THEN %START
#line 1164 "test-new/nrimp10s-77.imp"
if (I != 61) goto L_00C1;
// 1165 %IF CC(Q+1)='=' %THEN A(R)=1 %AND Q=Q+2 %AND ->UPR
#line 1165 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 61) goto L_00C2;
#line 1165 "test-new/nrimp10s-77.imp"
A[R] = 1;
#line 1165 "test-new/nrimp10s-77.imp"
Q = Q + 2;
#line 1165 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1165 "test-new/nrimp10s-77.imp"
L_00C2:;
// 1166 A(R)=2; Q=Q+1; ->UPR
#line 1166 "test-new/nrimp10s-77.imp"
A[R] = 2;
#line 1166 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1166 "test-new/nrimp10s-77.imp"
goto U_1005;
// 1167 %FINISH
#line 1167 "test-new/nrimp10s-77.imp"
L_00C1:;
// 1168 %IF I='<' %AND CC(Q+1)='-' %THEN A(R)=3 %AND Q=Q+2 %AND ->UPR
#line 1168 "test-new/nrimp10s-77.imp"
if (I != 60) goto L_00C3;
#line 1168 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 45) goto L_00C3;
#line 1168 "test-new/nrimp10s-77.imp"
A[R] = 3;
#line 1168 "test-new/nrimp10s-77.imp"
Q = Q + 2;
#line 1168 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1168 "test-new/nrimp10s-77.imp"
L_00C3:;
// 1169 %IF I='-' %AND CC(Q+1)='>' %THEN A(R)=4 %AND Q=Q+2 %AND ->UPR
#line 1169 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_00C4;
#line 1169 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] != 62) goto L_00C4;
#line 1169 "test-new/nrimp10s-77.imp"
A[R] = 4;
#line 1169 "test-new/nrimp10s-77.imp"
Q = Q + 2;
#line 1169 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1169 "test-new/nrimp10s-77.imp"
L_00C4:;
// 1170 ->FAIL
#line 1170 "test-new/nrimp10s-77.imp"
goto U_1009;
// 1171 BIP(1034): ! NOTE START
#line 1171 "test-new/nrimp10s-77.imp"
case_BIP_1034:;
// 1172 TOAR4(R,0); ! HOLE FOR FORWARD PTR
#line 1172 "test-new/nrimp10s-77.imp"
TOAR4(R, 0);
// 1173 PUSH(SFS(LEVEL),1,R,LINE)
#line 1173 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &SFS[LEVEL], 1, R, LINE);
// 1174 R=R+4
#line 1174 "test-new/nrimp10s-77.imp"
R = R + 4;
// 1175 ->SUCC
#line 1175 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1176 BIP(1035): ! NOTE FINISH
#line 1176 "test-new/nrimp10s-77.imp"
case_BIP_1035:;
// 1177 %IF SFS(LEVEL)=0 %THEN FAULT2(51,0,0) %AND ->SUCC
#line 1177 "test-new/nrimp10s-77.imp"
if (SFS[LEVEL] != 0) goto L_00C5;
#line 1177 "test-new/nrimp10s-77.imp"
FAULT2(51, 0, 0);
#line 1177 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 1177 "test-new/nrimp10s-77.imp"
L_00C5:;
// 1178 POP(SFS(LEVEL),I,J,K)
#line 1178 "test-new/nrimp10s-77.imp"
POP(/*?*/ &SFS[LEVEL], /*?*/ &I, /*?*/ &J, /*?*/ &K);
// 1179 %IF I=2 %THEN FAULT2(59,K,0)
#line 1179 "test-new/nrimp10s-77.imp"
if (I != 2) goto L_00C6;
#line 1179 "test-new/nrimp10s-77.imp"
FAULT2(59, K, 0);
#line 1179 "test-new/nrimp10s-77.imp"
L_00C6:;
// 1180 TOAR4(J,STARSTART)
#line 1180 "test-new/nrimp10s-77.imp"
TOAR4(J, STARSTART);
// 1181 ->SUCC
#line 1181 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1182 BIP(1036): ! NOTE REPEAT
#line 1182 "test-new/nrimp10s-77.imp"
case_BIP_1036:;
// 1183 %IF SFS(LEVEL)=0 %THEN FAULT2(1,0,0) %AND ->SUCC
#line 1183 "test-new/nrimp10s-77.imp"
if (SFS[LEVEL] != 0) goto L_00C7;
#line 1183 "test-new/nrimp10s-77.imp"
FAULT2(1, 0, 0);
#line 1183 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 1183 "test-new/nrimp10s-77.imp"
L_00C7:;
// 1184 POP(SFS(LEVEL),I,J,K)
#line 1184 "test-new/nrimp10s-77.imp"
POP(/*?*/ &SFS[LEVEL], /*?*/ &I, /*?*/ &J, /*?*/ &K);
// 1185 %IF I=1 %THEN FAULT2(52,K,0); ! START INSTEAD OF CYCLE
#line 1185 "test-new/nrimp10s-77.imp"
if (I != 1) goto L_00C8;
#line 1185 "test-new/nrimp10s-77.imp"
FAULT2(52, K, 0);
#line 1185 "test-new/nrimp10s-77.imp"
L_00C8:;
// 1186 TOAR4(J,STARSTART)
#line 1186 "test-new/nrimp10s-77.imp"
TOAR4(J, STARSTART);
// 1187 ->SUCC
#line 1187 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1188 BIP(1038): ! INCLUDE "FILE"
#line 1188 "test-new/nrimp10s-77.imp"
case_BIP_1038:;
// 1189 ->FAIL %IF VMEB=YES
#line 1189 "test-new/nrimp10s-77.imp"
if (0 != 1) goto L_00C9;
#line 1189 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1189 "test-new/nrimp10s-77.imp"
L_00C9:;
// 1190 I=CC(Q)
#line 1190 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1191 ->FAIL %UNLESS I=NL %OR I=';'
#line 1191 "test-new/nrimp10s-77.imp"
if (I == 10) goto L_00CA;
#line 1191 "test-new/nrimp10s-77.imp"
if (I == 59) goto L_00CA;
#line 1191 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1191 "test-new/nrimp10s-77.imp"
L_00CA:;
// 1192 Q=Q+1 %IF I=';'
#line 1192 "test-new/nrimp10s-77.imp"
if (I != 59) goto L_00CB;
#line 1192 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1192 "test-new/nrimp10s-77.imp"
L_00CB:;
// 1193 ->FAIL %UNLESS CTYPE=5
#line 1193 "test-new/nrimp10s-77.imp"
if (CTYPE == 5) goto L_00CC;
#line 1193 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1193 "test-new/nrimp10s-77.imp"
L_00CC:;
// 1194 PUSH(IHEAD,FILEADDR,FILEPTR,FILEEND)
#line 1194 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &IHEAD, FILEADDR, FILEPTR, FILEEND);
// 1195 CONSOURCE(STRING(ADDR(A(S))),FILEADDR);! DEPARTS IF FAILS
#line 1195 "test-new/nrimp10s-77.imp"
CONSOURCE(
#line 1195 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = *_imp_STRING(_imp_ADDR(/*?*/ &A[S])) /*q*/;
(_imp_string31 *)&tmp;
})
#line 1195 "test-new/nrimp10s-77.imp"
,
/*?*/ &FILEADDR);
// 1196 FILEPTR=FILEADDR+INTEGER(FILEADDR+4)
#line 1196 "test-new/nrimp10s-77.imp"
FILEPTR = FILEADDR + *_imp_INTEGER(FILEADDR + 4);
// 1197 FILEEND=FILEADDR+INTEGER(FILEADDR)
#line 1197 "test-new/nrimp10s-77.imp"
FILEEND = FILEADDR + *_imp_INTEGER(FILEADDR);
// 1198 ->SUCC
#line 1198 "test-new/nrimp10s-77.imp"
goto U_1006;
// 1199 %END; !OF ROUTINE 'COMPARE'
#line 1199 "test-new/nrimp10s-77.imp"
case_BIP_dispatch:
#line 1199 "test-new/nrimp10s-77.imp"
if (BIP_index < 999 || BIP_index > 1038)
_imp_signalf(6, 3, BIP_index, "->BIP(%d) out of bounds at %s line %d", BIP_index, BIP_file, BIP_line);
#line 1199 "test-new/nrimp10s-77.imp"
goto *BIP[BIP_index - 999];
#line 1199 "test-new/nrimp10s-77.imp"
case_BIP_missing:
_imp_signalf(8, 2, BIP_index, "switch jump to undefined label BIP(%d): at %s line %d", BIP_index, BIP_file,
BIP_line);
#line 1199 "test-new/nrimp10s-77.imp"
} /* end of COMPARE */
// 1200 %ROUTINE PNAME(%INTEGER MODE)
#line 1200 "test-new/nrimp10s-77.imp"
void PNAME(int MODE) {
// 1201 !***********************************************************************
// 1202 !* MODE=0 FOR OLD NAME(ALREADY IN DICT), MODE=1 FOR NEW NAME *
// 1203 !***********************************************************************
// 1204 %CONSTINTEGERARRAY HASH(0:7)=71,47,97,79,29,37,53,59;
#line 1204 "test-new/nrimp10s-77.imp"
const int HASH[8] = {71, 47, 97, 79, 29, 37, 53, 59};
// 1205 %INTEGER JJ, KK, LL, FQ, FS, T, S, I
#line 1205 "test-new/nrimp10s-77.imp"
int JJ;
#line 1205 "test-new/nrimp10s-77.imp"
int KK;
#line 1205 "test-new/nrimp10s-77.imp"
int LL;
#line 1205 "test-new/nrimp10s-77.imp"
int FQ;
#line 1205 "test-new/nrimp10s-77.imp"
int FS;
#line 1205 "test-new/nrimp10s-77.imp"
int T;
#line 1205 "test-new/nrimp10s-77.imp"
int S;
#line 1205 "test-new/nrimp10s-77.imp"
int I;
// 1206 %LONGINTEGER DRDES,ACCDES
#line 1206 "test-new/nrimp10s-77.imp"
long int DRDES;
#line 1206 "test-new/nrimp10s-77.imp"
long int ACCDES;
// 1207 HIT=0; FQ=Q; FS=CC(Q)
#line 1207 "test-new/nrimp10s-77.imp"
HIT = 0;
#line 1207 "test-new/nrimp10s-77.imp"
FQ = Q;
#line 1207 "test-new/nrimp10s-77.imp"
FS = CC[Q];
// 1208 %RETURN %UNLESS TRTAB(FS)=2 %AND M'"'#CC(Q+1)#M''''
#line 1208 "test-new/nrimp10s-77.imp"
if (TRTAB[FS] != 2) goto L_00CD;
#line 1208 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CC[Q + 1] (Part I)
#line 1208 "test-new/nrimp10s-77.imp"
unsigned char tmp;
#line 1208 "test-new/nrimp10s-77.imp"
if (34 == (tmp = CC[Q + 1])) goto L_00CD;
// Double-sided test on CC[Q + 1] (Part II)
#line 1208 "test-new/nrimp10s-77.imp"
if (tmp != 39) goto L_00CE;
#line 1208 "test-new/nrimp10s-77.imp"
}
#line 1208 "test-new/nrimp10s-77.imp"
L_00CD:;
#line 1208 "test-new/nrimp10s-77.imp"
return;
#line 1208 "test-new/nrimp10s-77.imp"
L_00CE:;
// 1209 ! 1ST CHAR MUST BE LETTER
// 1210 T=1
#line 1210 "test-new/nrimp10s-77.imp"
T = 1;
// 1211 LETT(NEXT+1)=FS; JJ=71*FS
#line 1211 "test-new/nrimp10s-77.imp"
LETT[NEXT + 1] = FS;
#line 1211 "test-new/nrimp10s-77.imp"
JJ = 71 * FS;
// 1212 ! %IF USE IMP=YES %THEN %START
// 1213 %CYCLE
#line 1213 "test-new/nrimp10s-77.imp"
L_00CF:;
// 1214 Q=Q+1
#line 1214 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1215 I=CC(Q)
#line 1215 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1216 %EXIT %IF TRTAB(I)=0
#line 1216 "test-new/nrimp10s-77.imp"
if (TRTAB[I] != 0) goto L_00D0;
#line 1216 "test-new/nrimp10s-77.imp"
goto L_00D1;
#line 1216 "test-new/nrimp10s-77.imp"
L_00D0:;
// 1217 JJ=JJ+HASH(T) %IF T<=7
#line 1217 "test-new/nrimp10s-77.imp"
if (T > 7) goto L_00D2;
#line 1217 "test-new/nrimp10s-77.imp"
JJ = JJ + HASH[T];
#line 1217 "test-new/nrimp10s-77.imp"
L_00D2:;
// 1218 T=T+1
#line 1218 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1219 LETT(NEXT+T)=I
#line 1219 "test-new/nrimp10s-77.imp"
LETT[NEXT + T] = I;
// 1220 %REPEAT
#line 1220 "test-new/nrimp10s-77.imp"
goto L_00CF;
#line 1220 "test-new/nrimp10s-77.imp"
L_00D1:;
// 1221 ! %FINISH %ELSE %START
// 1222 !CYC:
// 1223 ! *LB_Q
// 1224 ! *ADB_1
// 1225 ! *STB_Q
// 1226 ! *LB_(CC+%B)
// 1227 ! *LSS_(TRTAB+%B)
// 1228 ! *JAT_4,<EXIT>
// 1229 ! *STB_I
// 1230 ! *LSS_%B; ! I TO ACC
// 1231 ! *LB_T
// 1232 ! *CPB_7
// 1233 ! *JCC_2,<SKIP>
// 1234 ! *IMY_(HASH+%B)
// 1235 ! *IAD_JJ
// 1236 ! *ST_JJ
// 1237 !SKIP:
// 1238 ! *ADB_1
// 1239 ! *STB_T
// 1240 ! *LSS_I
// 1241 ! *ADB_NEXT
// 1242 ! *ST_(LETT+%B)
// 1243 ! *J_<CYC>
// 1244 !EXIT:
// 1245 ! %FINISH
// 1246 LETT(NEXT)=T; ! INSERT LENGTH
#line 1246 "test-new/nrimp10s-77.imp"
LETT[NEXT] = T;
// 1247 S=T+1
#line 1247 "test-new/nrimp10s-77.imp"
S = T + 1;
// 1248 FAULT(103,0) %IF NEXT+S>DSIZE;!DICTIONARY OVERFLOW
#line 1248 "test-new/nrimp10s-77.imp"
if (NEXT + S <= DSIZE) goto L_00D3;
#line 1248 "test-new/nrimp10s-77.imp"
FAULT(103, 0);
#line 1248 "test-new/nrimp10s-77.imp"
L_00D3:;
// 1249 JJ=(JJ+113*T)&NNAMES
#line 1249 "test-new/nrimp10s-77.imp"
JJ = JJ + 113 * T & NNAMES;
// 1250 ! %IF USE IMP=YES %THEN %START
// 1251 %CYCLE KK=JJ, 1, NNAMES
#line 1251 "test-new/nrimp10s-77.imp"
// %for KK = JJ, 1, NNAMES %cycle
#line 1251 "test-new/nrimp10s-77.imp"
{
int _control, _initial = JJ, _increment = 1, _final = NNAMES;
#line 1251 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle KK = JJ, 1, NNAMES");
_control = KK = _initial - _increment;
#line 1251 "test-new/nrimp10s-77.imp"
L_00D4:
#line 1251 "test-new/nrimp10s-77.imp"
if (KK != _control) _imp_signal(4, 2, 0, "Corrupt control variable KK");
#line 1251 "test-new/nrimp10s-77.imp"
if (KK == _final) goto L_00D5;
#line 1251 "test-new/nrimp10s-77.imp"
_control += _increment;
KK += _increment;
// 1252 LL=WORD(KK)
#line 1252 "test-new/nrimp10s-77.imp"
LL = WORD[KK];
// 1253 ->HOLE %IF LL=0; ! NAME NOT KNOWN
#line 1253 "test-new/nrimp10s-77.imp"
if (LL != 0) goto L_00D7;
#line 1253 "test-new/nrimp10s-77.imp"
goto U_1010;
#line 1253 "test-new/nrimp10s-77.imp"
L_00D7:;
// 1254 ->FND %IF STRING(ADDR(LETT(NEXT)))=STRING(ADDR(LETT(LL)))
#line 1254 "test-new/nrimp10s-77.imp"
if (_imp_strcmp((_imp_string *)_imp_STRING(_imp_ADDR(/*?*/ &LETT[NEXT])),
(_imp_string *)_imp_STRING(_imp_ADDR(/*?*/ &LETT[LL]))) != 0)
goto L_00D8;
#line 1254 "test-new/nrimp10s-77.imp"
goto U_1011;
#line 1254 "test-new/nrimp10s-77.imp"
L_00D8:;
// 1255 %REPEAT
#line 1255 "test-new/nrimp10s-77.imp"
goto L_00D4;
#line 1255 "test-new/nrimp10s-77.imp"
}
#line 1255 "test-new/nrimp10s-77.imp"
L_00D5:;
// 1256 %CYCLE KK=0,1,JJ
#line 1256 "test-new/nrimp10s-77.imp"
// %for KK = 0, 1, JJ %cycle
#line 1256 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = JJ;
#line 1256 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle KK = 0, 1, JJ");
_control = KK = _initial - _increment;
#line 1256 "test-new/nrimp10s-77.imp"
L_00D9:
#line 1256 "test-new/nrimp10s-77.imp"
if (KK != _control) _imp_signal(4, 2, 0, "Corrupt control variable KK");
#line 1256 "test-new/nrimp10s-77.imp"
if (KK == _final) goto L_00DA;
#line 1256 "test-new/nrimp10s-77.imp"
_control += _increment;
KK += _increment;
// 1257 LL=WORD(KK)
#line 1257 "test-new/nrimp10s-77.imp"
LL = WORD[KK];
// 1258 ->HOLE %IF LL=0; ! NAME NOT KNOWN
#line 1258 "test-new/nrimp10s-77.imp"
if (LL != 0) goto L_00DB;
#line 1258 "test-new/nrimp10s-77.imp"
goto U_1010;
#line 1258 "test-new/nrimp10s-77.imp"
L_00DB:;
// 1259 ->FND %IF STRING(ADDR(LETT(NEXT)))=STRING(ADDR(LETT(LL)))
#line 1259 "test-new/nrimp10s-77.imp"
if (_imp_strcmp((_imp_string *)_imp_STRING(_imp_ADDR(/*?*/ &LETT[NEXT])),
(_imp_string *)_imp_STRING(_imp_ADDR(/*?*/ &LETT[LL]))) != 0)
goto L_00DC;
#line 1259 "test-new/nrimp10s-77.imp"
goto U_1011;
#line 1259 "test-new/nrimp10s-77.imp"
L_00DC:;
// 1260 %REPEAT
#line 1260 "test-new/nrimp10s-77.imp"
goto L_00D9;
#line 1260 "test-new/nrimp10s-77.imp"
}
#line 1260 "test-new/nrimp10s-77.imp"
L_00DA:;
// 1261 ! %FINISH %ELSE %START
// 1262 ! *LDTB_16_18000000
// 1263 ! *LDB_S
// 1264 ! *LDA_LETT+4
// 1265 ! *STD_DRDES
// 1266 ! *INCA_NEXT
// 1267 ! *STD_ACCDES
// 1268 ! *LB_JJ
// 1269 !CYC1:
// 1270 ! *STB_KK
// 1271 ! *LB_(WORD+%B)
// 1272 ! *JAT_12,<HOLE>
// 1273 ! *LSD_ACCDES
// 1274 ! *LD_DRDES
// 1275 ! *INCA_%B
// 1276 ! *CPS_%L=%DR
// 1277 ! *JCC_8,<FND>
// 1278 ! *LB_KK
// 1279 ! *CPIB_NNAMES
// 1280 ! *JCC_7,<CYC1>
// 1281 ! *LB_0
// 1282 !CYC2:
// 1283 ! *STB_KK
// 1284 ! *LB_(WORD+%B)
// 1285 ! *JAT_12,<HOLE>
// 1286 ! *LSD_ACCDES
// 1287 ! *LD_DRDES
// 1288 ! *INCA_%B
// 1289 ! *CPS_%L=%DR
// 1290 ! *JCC_8,<FND>
// 1291 ! *LB_KK
// 1292 ! *CPIB_JJ
// 1293 ! *JCC_7,<CYC2>
// 1294 ! %FINISH
// 1295 FAULT(104, 0); ! TOO MANY NAMES
#line 1295 "test-new/nrimp10s-77.imp"
FAULT(104, 0);
// 1296 HOLE: %IF MODE=0 %THEN Q=FQ %AND %RETURN
#line 1296 "test-new/nrimp10s-77.imp"
U_1010:;
#line 1296 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_00DD;
#line 1296 "test-new/nrimp10s-77.imp"
Q = FQ;
#line 1296 "test-new/nrimp10s-77.imp"
return;
#line 1296 "test-new/nrimp10s-77.imp"
L_00DD:;
// 1297 WORD(KK)=NEXT; NEXT=NEXT+S
#line 1297 "test-new/nrimp10s-77.imp"
WORD[KK] = NEXT;
#line 1297 "test-new/nrimp10s-77.imp"
NEXT = NEXT + S;
// 1298 FND: LASTAT=FQ; HIT=1; LASTNAME=KK
#line 1298 "test-new/nrimp10s-77.imp"
U_1011:;
#line 1298 "test-new/nrimp10s-77.imp"
LASTAT = FQ;
#line 1298 "test-new/nrimp10s-77.imp"
HIT = 1;
#line 1298 "test-new/nrimp10s-77.imp"
LASTNAME = KK;
// 1299 A(R+1)<-LASTNAME
#line 1299 "test-new/nrimp10s-77.imp"
A[R + 1] = (unsigned char)(LASTNAME);
// 1300 A(R)=LASTNAME>>8; R=R+2
#line 1300 "test-new/nrimp10s-77.imp"
A[R] = (unsigned int)LASTNAME >> 8;
#line 1300 "test-new/nrimp10s-77.imp"
R = R + 2;
// 1301 LASTEND=Q
#line 1301 "test-new/nrimp10s-77.imp"
LASTEND = Q;
// 1302 %END
#line 1302 "test-new/nrimp10s-77.imp"
return;
#line 1302 "test-new/nrimp10s-77.imp"
} /* end of PNAME */
// ?ACCDES unused
// ?DRDES unused
// 1303
// 1304
// 1305 %ROUTINE CONST(%INTEGER MODE)
#line 1305 "test-new/nrimp10s-77.imp"
void CONST(int MODE) {
// 1306 !***********************************************************************
// 1307 !* SYNTAX CHECK AND EVALUATE ALL THE FORMS OF IMP CONSTANT *
// 1308 !* MODE=0 FOR INTEGER CONSTANTS #0 FOR ANY SORT OF CONSTANT *
// 1309 !***********************************************************************
// 1310 %INTEGER Z, DOTSEEN, EBCDIC, FS, CPREC, RR, S, T, SS
#line 1310 "test-new/nrimp10s-77.imp"
int Z;
#line 1310 "test-new/nrimp10s-77.imp"
int DOTSEEN;
#line 1310 "test-new/nrimp10s-77.imp"
int EBCDIC;
#line 1310 "test-new/nrimp10s-77.imp"
int FS;
#line 1310 "test-new/nrimp10s-77.imp"
int CPREC;
#line 1310 "test-new/nrimp10s-77.imp"
int RR;
#line 1310 "test-new/nrimp10s-77.imp"
int S;
#line 1310 "test-new/nrimp10s-77.imp"
int T;
#line 1310 "test-new/nrimp10s-77.imp"
int SS;
// 1311 {%LONG}%LONGREAL X,CVALUE,DUMMY
#line 1311 "test-new/nrimp10s-77.imp"
double X;
#line 1311 "test-new/nrimp10s-77.imp"
double CVALUE;
#line 1311 "test-new/nrimp10s-77.imp"
double DUMMY;
// 1312 %CONST{%LONG}%LONGREAL TEN=10.0 {R'41A00000000000000000000000000000'
#line 1312 "test-new/nrimp10s-77.imp"
const double TEN = 10.0;
// 1313 CPREC=5; RR=R; R=R+1
#line 1313 "test-new/nrimp10s-77.imp"
CPREC = 5;
#line 1313 "test-new/nrimp10s-77.imp"
RR = R;
#line 1313 "test-new/nrimp10s-77.imp"
R = R + 1;
// 1314 DOTSEEN=0; HIT=0
#line 1314 "test-new/nrimp10s-77.imp"
DOTSEEN = 0;
#line 1314 "test-new/nrimp10s-77.imp"
HIT = 0;
// 1315 CVALUE=0; DUMMY=0; FS=CC(Q)
#line 1315 "test-new/nrimp10s-77.imp"
CVALUE = 0;
#line 1315 "test-new/nrimp10s-77.imp"
DUMMY = 0;
#line 1315 "test-new/nrimp10s-77.imp"
FS = CC[Q];
// 1316 S=0; ->N %IF M'0'<=FS<=M'9'
#line 1316 "test-new/nrimp10s-77.imp"
S = 0;
#line 1316 "test-new/nrimp10s-77.imp"
{
// Double-sided test on FS (Part I)
#line 1316 "test-new/nrimp10s-77.imp"
int tmp;
#line 1316 "test-new/nrimp10s-77.imp"
if (48 > (tmp = FS)) goto L_00DE;
// Double-sided test on FS (Part II)
#line 1316 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_00DE;
#line 1316 "test-new/nrimp10s-77.imp"
}
#line 1316 "test-new/nrimp10s-77.imp"
goto U_1012;
#line 1316 "test-new/nrimp10s-77.imp"
L_00DE:;
// 1317 ->DOT %IF FS='.' %AND MODE=0 %AND '0'<=CC(Q+1)<='9'
#line 1317 "test-new/nrimp10s-77.imp"
if (FS != 46) goto L_00DF;
#line 1317 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_00DF;
#line 1317 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CC[Q + 1] (Part I)
#line 1317 "test-new/nrimp10s-77.imp"
unsigned char tmp;
#line 1317 "test-new/nrimp10s-77.imp"
if (48 > (tmp = CC[Q + 1])) goto L_00DF;
// Double-sided test on CC[Q + 1] (Part II)
#line 1317 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_00DF;
#line 1317 "test-new/nrimp10s-77.imp"
}
#line 1317 "test-new/nrimp10s-77.imp"
goto U_1013;
#line 1317 "test-new/nrimp10s-77.imp"
L_00DF:;
// 1318 ! 1 DIDT MIN
// 1319 CTYPE=1; EBCDIC=0
#line 1319 "test-new/nrimp10s-77.imp"
CTYPE = 1;
#line 1319 "test-new/nrimp10s-77.imp"
EBCDIC = 0;
// 1320 ->QUOTE %IF FS=M''''
#line 1320 "test-new/nrimp10s-77.imp"
if (FS != 39) goto L_00E0;
#line 1320 "test-new/nrimp10s-77.imp"
goto U_1004;
#line 1320 "test-new/nrimp10s-77.imp"
L_00E0:;
// 1321 ->STR2 %IF FS=34
#line 1321 "test-new/nrimp10s-77.imp"
if (FS != 34) goto L_00E1;
#line 1321 "test-new/nrimp10s-77.imp"
goto U_1005;
#line 1321 "test-new/nrimp10s-77.imp"
L_00E1:;
// 1322 ->NOTQUOTE %UNLESS CC(Q+1)=M''''; Q=Q+2
#line 1322 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] == 39) goto L_00E2;
#line 1322 "test-new/nrimp10s-77.imp"
goto U_1006;
#line 1322 "test-new/nrimp10s-77.imp"
L_00E2:;
#line 1322 "test-new/nrimp10s-77.imp"
Q = Q + 2;
// 1323 ->HEX %IF FS='X'
#line 1323 "test-new/nrimp10s-77.imp"
if (FS != 88) goto L_00E3;
#line 1323 "test-new/nrimp10s-77.imp"
goto U_1007;
#line 1323 "test-new/nrimp10s-77.imp"
L_00E3:;
// 1324 ->MULT %IF FS='M'
#line 1324 "test-new/nrimp10s-77.imp"
if (FS != 77) goto L_00E4;
#line 1324 "test-new/nrimp10s-77.imp"
goto U_1008;
#line 1324 "test-new/nrimp10s-77.imp"
L_00E4:;
// 1325 ->BIN %IF FS=M'B'
#line 1325 "test-new/nrimp10s-77.imp"
if (FS != 66) goto L_00E5;
#line 1325 "test-new/nrimp10s-77.imp"
goto U_1009;
#line 1325 "test-new/nrimp10s-77.imp"
L_00E5:;
// 1326 ->RHEX %IF FS='R' %AND MODE=0
#line 1326 "test-new/nrimp10s-77.imp"
if (FS != 82) goto L_00E6;
#line 1326 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_00E6;
#line 1326 "test-new/nrimp10s-77.imp"
goto U_100A;
#line 1326 "test-new/nrimp10s-77.imp"
L_00E6:;
// 1327 ->OCT %IF FS='K'
#line 1327 "test-new/nrimp10s-77.imp"
if (FS != 75) goto L_00E7;
#line 1327 "test-new/nrimp10s-77.imp"
goto U_100B;
#line 1327 "test-new/nrimp10s-77.imp"
L_00E7:;
// 1328 %IF FS='C' %THEN EBCDIC=1 %AND ->MULT
#line 1328 "test-new/nrimp10s-77.imp"
if (FS != 67) goto L_00E8;
#line 1328 "test-new/nrimp10s-77.imp"
EBCDIC = 1;
#line 1328 "test-new/nrimp10s-77.imp"
goto U_1008;
#line 1328 "test-new/nrimp10s-77.imp"
L_00E8:;
// 1329 %IF FS='D' %AND MODE=0 %THEN %START
#line 1329 "test-new/nrimp10s-77.imp"
if (FS != 68) goto L_00E9;
#line 1329 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_00E9;
// 1330 CPREC=7
#line 1330 "test-new/nrimp10s-77.imp"
CPREC = 7;
// 1331 %IF M'0'<=CC(Q)<=M'9' %THEN ->N
#line 1331 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CC[Q] (Part I)
#line 1331 "test-new/nrimp10s-77.imp"
unsigned char tmp;
#line 1331 "test-new/nrimp10s-77.imp"
if (48 > (tmp = CC[Q])) goto L_00EA;
// Double-sided test on CC[Q] (Part II)
#line 1331 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_00EA;
#line 1331 "test-new/nrimp10s-77.imp"
}
#line 1331 "test-new/nrimp10s-77.imp"
goto U_1012;
#line 1331 "test-new/nrimp10s-77.imp"
L_00EA:;
// 1332 %IF CC(Q)='.' %THEN ->DOT
#line 1332 "test-new/nrimp10s-77.imp"
if (CC[Q] != 46) goto L_00EB;
#line 1332 "test-new/nrimp10s-77.imp"
goto U_1013;
#line 1332 "test-new/nrimp10s-77.imp"
L_00EB:;
// 1333 %FINISH
#line 1333 "test-new/nrimp10s-77.imp"
L_00E9:;
// 1334 Q=Q-2; %RETURN
#line 1334 "test-new/nrimp10s-77.imp"
Q = Q - 2;
#line 1334 "test-new/nrimp10s-77.imp"
return;
// 1335 QUOTE: ! SINGLE CH BETWEEN QUOTES
#line 1335 "test-new/nrimp10s-77.imp"
U_1004:;
// 1336 %IF CC(Q+2)=M'''' %THEN %START
#line 1336 "test-new/nrimp10s-77.imp"
if (CC[Q + 2] != 39) goto L_00EC;
// 1337 S=CC(Q+1)
#line 1337 "test-new/nrimp10s-77.imp"
S = CC[Q + 1];
// 1338 Q=Q+3
#line 1338 "test-new/nrimp10s-77.imp"
Q = Q + 3;
// 1339 %IF S#M'''' %THEN ->IEND
#line 1339 "test-new/nrimp10s-77.imp"
if (S == 39) goto L_00ED;
#line 1339 "test-new/nrimp10s-77.imp"
goto U_100C;
#line 1339 "test-new/nrimp10s-77.imp"
L_00ED:;
// 1340 %IF CC(Q)=M'''' %THEN Q=Q+1 %AND ->IEND
#line 1340 "test-new/nrimp10s-77.imp"
if (CC[Q] != 39) goto L_00EE;
#line 1340 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1340 "test-new/nrimp10s-77.imp"
goto U_100C;
#line 1340 "test-new/nrimp10s-77.imp"
L_00EE:;
// 1341 %FINISH
#line 1341 "test-new/nrimp10s-77.imp"
L_00EC:;
// 1342 %RETURN; ! NOT VALID
#line 1342 "test-new/nrimp10s-77.imp"
return;
// 1343 NOTQUOTE: ! CHECK FOR E"...."
#line 1343 "test-new/nrimp10s-77.imp"
U_1006:;
// 1344 %RETURN %UNLESS FS='E' %AND CC(Q+1)=M'"'
#line 1344 "test-new/nrimp10s-77.imp"
if (FS != 69) goto L_00D6;
#line 1344 "test-new/nrimp10s-77.imp"
if (CC[Q + 1] == 34) goto L_00EF;
#line 1344 "test-new/nrimp10s-77.imp"
L_00D6:;
#line 1344 "test-new/nrimp10s-77.imp"
return;
#line 1344 "test-new/nrimp10s-77.imp"
L_00EF:;
// 1345 EBCDIC=1; Q=Q+1
#line 1345 "test-new/nrimp10s-77.imp"
EBCDIC = 1;
#line 1345 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1346 STR2: ! DOUBLE QUOTED STRING
#line 1346 "test-new/nrimp10s-77.imp"
U_1005:;
// 1347 A(RR)=16_35; TEXTTEXT(EBCDIC)
#line 1347 "test-new/nrimp10s-77.imp"
A[RR] = 53;
#line 1347 "test-new/nrimp10s-77.imp"
TEXTTEXT(EBCDIC);
// 1348 CTYPE=5; %RETURN
#line 1348 "test-new/nrimp10s-77.imp"
CTYPE = 5;
#line 1348 "test-new/nrimp10s-77.imp"
return;
// 1349 HEX: T=0; ! HEX CONSTANTS
#line 1349 "test-new/nrimp10s-77.imp"
U_1007:;
#line 1349 "test-new/nrimp10s-77.imp"
T = 0;
// 1350 %CYCLE
#line 1350 "test-new/nrimp10s-77.imp"
L_00F0:;
// 1351 I=CC(Q); Q=Q+1
#line 1351 "test-new/nrimp10s-77.imp"
I = CC[Q];
#line 1351 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1352 %EXIT %IF I=M''''
#line 1352 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_00F1;
#line 1352 "test-new/nrimp10s-77.imp"
goto L_00F2;
#line 1352 "test-new/nrimp10s-77.imp"
L_00F1:;
// 1353 T=T+1
#line 1353 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1354 %RETURN %UNLESS ('0'<=I<='9' %OR 'A'<=I<='F') %AND T<17
#line 1354 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1354 "test-new/nrimp10s-77.imp"
int tmp;
#line 1354 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_00F3;
// Double-sided test on I (Part II)
#line 1354 "test-new/nrimp10s-77.imp"
if (tmp <= 57) goto L_00F4;
#line 1354 "test-new/nrimp10s-77.imp"
}
#line 1354 "test-new/nrimp10s-77.imp"
L_00F3:;
#line 1354 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1354 "test-new/nrimp10s-77.imp"
int tmp;
#line 1354 "test-new/nrimp10s-77.imp"
if (65 > (tmp = I)) goto L_0091;
// Double-sided test on I (Part II)
#line 1354 "test-new/nrimp10s-77.imp"
if (tmp > 70) goto L_0091;
#line 1354 "test-new/nrimp10s-77.imp"
}
#line 1354 "test-new/nrimp10s-77.imp"
L_00F4:;
#line 1354 "test-new/nrimp10s-77.imp"
if (T < 17) goto L_00F5;
#line 1354 "test-new/nrimp10s-77.imp"
L_0091:;
#line 1354 "test-new/nrimp10s-77.imp"
return;
#line 1354 "test-new/nrimp10s-77.imp"
L_00F5:;
// 1355 %IF T=9 %THEN SS=S %AND S=0
#line 1355 "test-new/nrimp10s-77.imp"
if (T != 9) goto L_00F6;
#line 1355 "test-new/nrimp10s-77.imp"
SS = S;
#line 1355 "test-new/nrimp10s-77.imp"
S = 0;
#line 1355 "test-new/nrimp10s-77.imp"
L_00F6:;
// 1356 S=S<<4+I&15+9*I>>6
#line 1356 "test-new/nrimp10s-77.imp"
S = (S << 4) + (I & 15) + 9 * ((unsigned int)I >> 6);
// 1357 %REPEAT
#line 1357 "test-new/nrimp10s-77.imp"
goto L_00F0;
#line 1357 "test-new/nrimp10s-77.imp"
L_00F2:;
// 1358 %IF T>8 %START
#line 1358 "test-new/nrimp10s-77.imp"
if (T <= 8) goto L_00F7;
// 1359 Z=4*(T-8)
#line 1359 "test-new/nrimp10s-77.imp"
Z = 4 * (T - 8);
// 1360 S=S!(SS<<Z)
#line 1360 "test-new/nrimp10s-77.imp"
S = S | SS << Z;
// 1361 SS=SS>>(32-Z); CPREC=6
#line 1361 "test-new/nrimp10s-77.imp"
SS = (unsigned int)SS >> 32 - Z;
#line 1361 "test-new/nrimp10s-77.imp"
CPREC = 6;
// 1362 %FINISH
#line 1362 "test-new/nrimp10s-77.imp"
L_00F7:;
// 1363 IEND: %IF CPREC=6 %THEN TOAR4(R,SS) %AND R=R+4
#line 1363 "test-new/nrimp10s-77.imp"
U_100C:;
#line 1363 "test-new/nrimp10s-77.imp"
if (CPREC != 6) goto L_00F8;
#line 1363 "test-new/nrimp10s-77.imp"
TOAR4(R, SS);
#line 1363 "test-new/nrimp10s-77.imp"
R = R + 4;
#line 1363 "test-new/nrimp10s-77.imp"
L_00F8:;
// 1364 %IF CPREC=5 %AND 0<=S<=16_7FFF %START
#line 1364 "test-new/nrimp10s-77.imp"
if (CPREC != 5) goto L_00F9;
#line 1364 "test-new/nrimp10s-77.imp"
{
// Double-sided test on S (Part I)
#line 1364 "test-new/nrimp10s-77.imp"
int tmp;
#line 1364 "test-new/nrimp10s-77.imp"
if (0 > (tmp = S)) goto L_00F9;
// Double-sided test on S (Part II)
#line 1364 "test-new/nrimp10s-77.imp"
if (tmp > 32767) goto L_00F9;
#line 1364 "test-new/nrimp10s-77.imp"
}
// 1365 CPREC=4; TOAR2(R,S); R=R+2
#line 1365 "test-new/nrimp10s-77.imp"
CPREC = 4;
#line 1365 "test-new/nrimp10s-77.imp"
TOAR2(R, S);
#line 1365 "test-new/nrimp10s-77.imp"
R = R + 2;
// 1366 %FINISH %ELSE TOAR4(R,S) %AND R=R+4
#line 1366 "test-new/nrimp10s-77.imp"
goto L_00FA;
#line 1366 "test-new/nrimp10s-77.imp"
L_00F9:;
#line 1366 "test-new/nrimp10s-77.imp"
TOAR4(R, S);
#line 1366 "test-new/nrimp10s-77.imp"
R = R + 4;
#line 1366 "test-new/nrimp10s-77.imp"
L_00FA:;
// 1367 HIT=1 %UNLESS MODE#0 %AND CPREC=6
#line 1367 "test-new/nrimp10s-77.imp"
if (MODE == 0) goto L_00FB;
#line 1367 "test-new/nrimp10s-77.imp"
if (CPREC == 6) goto L_00FC;
#line 1367 "test-new/nrimp10s-77.imp"
L_00FB:;
#line 1367 "test-new/nrimp10s-77.imp"
HIT = 1;
#line 1367 "test-new/nrimp10s-77.imp"
L_00FC:;
// 1368 A(RR)=CPREC<<4!CTYPE
#line 1368 "test-new/nrimp10s-77.imp"
A[RR] = CPREC << 4 | CTYPE;
// 1369 %RETURN
#line 1369 "test-new/nrimp10s-77.imp"
return;
// 1370 RHEX: ! REAL HEX CONSTANTS
#line 1370 "test-new/nrimp10s-77.imp"
U_100A:;
// 1371 T=0
#line 1371 "test-new/nrimp10s-77.imp"
T = 0;
// 1372 %CYCLE
#line 1372 "test-new/nrimp10s-77.imp"
L_00FD:;
// 1373 I=CC(Q); Q=Q+1
#line 1373 "test-new/nrimp10s-77.imp"
I = CC[Q];
#line 1373 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1374 %IF T&7=0 %AND T#0 %START
#line 1374 "test-new/nrimp10s-77.imp"
if (T & 7 != 0) goto L_00FE;
#line 1374 "test-new/nrimp10s-77.imp"
if (T == 0) goto L_00FE;
// 1375 TOAR4(R,S); R=R+4; S=0
#line 1375 "test-new/nrimp10s-77.imp"
TOAR4(R, S);
#line 1375 "test-new/nrimp10s-77.imp"
R = R + 4;
#line 1375 "test-new/nrimp10s-77.imp"
S = 0;
// 1376 %FINISH
#line 1376 "test-new/nrimp10s-77.imp"
L_00FE:;
// 1377 %EXIT %IF I=M''''; T=T+1
#line 1377 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_00FF;
#line 1377 "test-new/nrimp10s-77.imp"
goto L_0100;
#line 1377 "test-new/nrimp10s-77.imp"
L_00FF:;
#line 1377 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1378 %RETURN %UNLESS '0'<=I<='9' %OR 'A'<=I<='F'
#line 1378 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1378 "test-new/nrimp10s-77.imp"
int tmp;
#line 1378 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_0101;
// Double-sided test on I (Part II)
#line 1378 "test-new/nrimp10s-77.imp"
if (tmp <= 57) goto L_0102;
#line 1378 "test-new/nrimp10s-77.imp"
}
#line 1378 "test-new/nrimp10s-77.imp"
L_0101:;
#line 1378 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1378 "test-new/nrimp10s-77.imp"
int tmp;
#line 1378 "test-new/nrimp10s-77.imp"
if (65 > (tmp = I)) goto L_0103;
// Double-sided test on I (Part II)
#line 1378 "test-new/nrimp10s-77.imp"
if (tmp <= 70) goto L_0102;
#line 1378 "test-new/nrimp10s-77.imp"
}
#line 1378 "test-new/nrimp10s-77.imp"
L_0103:;
#line 1378 "test-new/nrimp10s-77.imp"
return;
#line 1378 "test-new/nrimp10s-77.imp"
L_0102:;
// 1379 S=S<<4+I&15+9*I>>6
#line 1379 "test-new/nrimp10s-77.imp"
S = (S << 4) + (I & 15) + 9 * ((unsigned int)I >> 6);
// 1380 %REPEAT
#line 1380 "test-new/nrimp10s-77.imp"
goto L_00FD;
#line 1380 "test-new/nrimp10s-77.imp"
L_0100:;
// 1381 %RETURN %UNLESS T=8 %OR T=16 %OR T=32
#line 1381 "test-new/nrimp10s-77.imp"
if (T == 8) goto L_0104;
#line 1381 "test-new/nrimp10s-77.imp"
if (T == 16) goto L_0104;
#line 1381 "test-new/nrimp10s-77.imp"
if (T == 32) goto L_0104;
#line 1381 "test-new/nrimp10s-77.imp"
return;
#line 1381 "test-new/nrimp10s-77.imp"
L_0104:;
// 1382 %IF T=32 %THEN CPREC=7 %ELSE CPREC=4+T//8
#line 1382 "test-new/nrimp10s-77.imp"
if (T != 32) goto L_0105;
#line 1382 "test-new/nrimp10s-77.imp"
CPREC = 7;
#line 1382 "test-new/nrimp10s-77.imp"
goto L_0106;
#line 1382 "test-new/nrimp10s-77.imp"
L_0105:;
#line 1382 "test-new/nrimp10s-77.imp"
CPREC = 4 + ((long)T / (long)8);
#line 1382 "test-new/nrimp10s-77.imp"
L_0106:;
// 1383 A(RR)=CPREC<<4!2
#line 1383 "test-new/nrimp10s-77.imp"
A[RR] = CPREC << 4 | 2;
// 1384 HIT=1; %RETURN
#line 1384 "test-new/nrimp10s-77.imp"
HIT = 1;
#line 1384 "test-new/nrimp10s-77.imp"
return;
// 1385 OCT: ! OCTAL CONSTANTS
#line 1385 "test-new/nrimp10s-77.imp"
U_100B:;
// 1386 T=0
#line 1386 "test-new/nrimp10s-77.imp"
T = 0;
// 1387 %CYCLE
#line 1387 "test-new/nrimp10s-77.imp"
L_0107:;
// 1388 I=CC(Q); Q=Q+1; T=T+1
#line 1388 "test-new/nrimp10s-77.imp"
I = CC[Q];
#line 1388 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1388 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1389 %EXIT %IF I=M''''
#line 1389 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_0108;
#line 1389 "test-new/nrimp10s-77.imp"
goto L_0109;
#line 1389 "test-new/nrimp10s-77.imp"
L_0108:;
// 1390 %RETURN %UNLESS '0'<=I<='7' %AND T<12
#line 1390 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1390 "test-new/nrimp10s-77.imp"
int tmp;
#line 1390 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_010A;
// Double-sided test on I (Part II)
#line 1390 "test-new/nrimp10s-77.imp"
if (tmp > 55) goto L_010A;
#line 1390 "test-new/nrimp10s-77.imp"
}
#line 1390 "test-new/nrimp10s-77.imp"
if (T < 12) goto L_010B;
#line 1390 "test-new/nrimp10s-77.imp"
L_010A:;
#line 1390 "test-new/nrimp10s-77.imp"
return;
#line 1390 "test-new/nrimp10s-77.imp"
L_010B:;
// 1391 S=S<<3!(I&7)
#line 1391 "test-new/nrimp10s-77.imp"
S = S << 3 | I & 7;
// 1392 %REPEAT
#line 1392 "test-new/nrimp10s-77.imp"
goto L_0107;
#line 1392 "test-new/nrimp10s-77.imp"
L_0109:;
// 1393 ->IEND
#line 1393 "test-new/nrimp10s-77.imp"
goto U_100C;
// 1394 MULT: T=0; ! MULTIPLE CONSTANTS
#line 1394 "test-new/nrimp10s-77.imp"
U_1008:;
#line 1394 "test-new/nrimp10s-77.imp"
T = 0;
// 1395 %CYCLE
#line 1395 "test-new/nrimp10s-77.imp"
L_010C:;
// 1396 I=CC(Q); Q=Q+1; T=T+1
#line 1396 "test-new/nrimp10s-77.imp"
I = CC[Q];
#line 1396 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1396 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1397 %IF I=M'''' %THEN %START
#line 1397 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_010D;
// 1398 %IF CC(Q)#M'''' %THEN %EXIT %ELSE Q=Q+1
#line 1398 "test-new/nrimp10s-77.imp"
if (CC[Q] == 39) goto L_010E;
#line 1398 "test-new/nrimp10s-77.imp"
goto L_010F;
#line 1398 "test-new/nrimp10s-77.imp"
L_010E:;
#line 1398 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1399 %FINISH
#line 1399 "test-new/nrimp10s-77.imp"
L_010D:;
// 1400 %RETURN %IF T>=5
#line 1400 "test-new/nrimp10s-77.imp"
if (T < 5) goto L_0110;
#line 1400 "test-new/nrimp10s-77.imp"
return;
#line 1400 "test-new/nrimp10s-77.imp"
L_0110:;
// 1401 %IF EBCDIC#0 %THEN I=ITOETAB(I)
#line 1401 "test-new/nrimp10s-77.imp"
if (EBCDIC == 0) goto L_0111;
#line 1401 "test-new/nrimp10s-77.imp"
I = ITOETAB[I];
#line 1401 "test-new/nrimp10s-77.imp"
L_0111:;
// 1402 S=S<<8!I
#line 1402 "test-new/nrimp10s-77.imp"
S = S << 8 | I;
// 1403 %REPEAT
#line 1403 "test-new/nrimp10s-77.imp"
goto L_010C;
#line 1403 "test-new/nrimp10s-77.imp"
L_010F:;
// 1404 ->IEND
#line 1404 "test-new/nrimp10s-77.imp"
goto U_100C;
// 1405 BIN: T=0; ! BINARY CONST
#line 1405 "test-new/nrimp10s-77.imp"
U_1009:;
#line 1405 "test-new/nrimp10s-77.imp"
T = 0;
// 1406 %CYCLE
#line 1406 "test-new/nrimp10s-77.imp"
L_0112:;
// 1407 I=CC(Q); Q=Q+1; T=T+1
#line 1407 "test-new/nrimp10s-77.imp"
I = CC[Q];
#line 1407 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1407 "test-new/nrimp10s-77.imp"
T = T + 1;
// 1408 %EXIT %IF I=M''''
#line 1408 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_0113;
#line 1408 "test-new/nrimp10s-77.imp"
goto L_0114;
#line 1408 "test-new/nrimp10s-77.imp"
L_0113:;
// 1409 %RETURN %UNLESS '0'<=I<='1' %AND T<33
#line 1409 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1409 "test-new/nrimp10s-77.imp"
int tmp;
#line 1409 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_0115;
// Double-sided test on I (Part II)
#line 1409 "test-new/nrimp10s-77.imp"
if (tmp > 49) goto L_0115;
#line 1409 "test-new/nrimp10s-77.imp"
}
#line 1409 "test-new/nrimp10s-77.imp"
if (T < 33) goto L_0116;
#line 1409 "test-new/nrimp10s-77.imp"
L_0115:;
#line 1409 "test-new/nrimp10s-77.imp"
return;
#line 1409 "test-new/nrimp10s-77.imp"
L_0116:;
// 1410 S=S<<1!I&1
#line 1410 "test-new/nrimp10s-77.imp"
S = S << 1 | I & 1;
// 1411 %REPEAT
#line 1411 "test-new/nrimp10s-77.imp"
goto L_0112;
#line 1411 "test-new/nrimp10s-77.imp"
L_0114:;
// 1412 ->IEND
#line 1412 "test-new/nrimp10s-77.imp"
goto U_100C;
// 1413 N: ! CONSTANT STARTS WITH DIGIT
#line 1413 "test-new/nrimp10s-77.imp"
U_1012:;
// 1414 I=CC(Q)
#line 1414 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1415 {%UNTIL I<M'0' %OR I>M'9'} %CYCLE
#line 1415 "test-new/nrimp10s-77.imp"
L_0117:;
// 1416 CVALUE=TEN*CVALUE+(I&15)
#line 1416 "test-new/nrimp10s-77.imp"
CVALUE = TEN * CVALUE + (I & 15);
// 1417 Q=Q+1; I=CC(Q); ! ONTO NEXT CHAR
#line 1417 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1417 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1418 %REPEAT %UNTIL I<M'0' %OR I>M'9'
#line 1418 "test-new/nrimp10s-77.imp"
if (I < 48) goto L_0118;
#line 1418 "test-new/nrimp10s-77.imp"
if (I > 57) goto L_0118;
#line 1418 "test-new/nrimp10s-77.imp"
goto L_0117;
#line 1418 "test-new/nrimp10s-77.imp"
L_0118:;
// 1419 ->ALPHA %UNLESS MODE=0 %AND I='.'
#line 1419 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_0119;
#line 1419 "test-new/nrimp10s-77.imp"
if (I == 46) goto L_011A;
#line 1419 "test-new/nrimp10s-77.imp"
L_0119:;
#line 1419 "test-new/nrimp10s-77.imp"
goto U_100D;
#line 1419 "test-new/nrimp10s-77.imp"
L_011A:;
// 1420 DOT: Q=Q+1; X=TEN; I=CC(Q)
#line 1420 "test-new/nrimp10s-77.imp"
U_1013:;
#line 1420 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1420 "test-new/nrimp10s-77.imp"
X = TEN;
#line 1420 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1421 DOTSEEN=1; ! CONSTANT HAS DECIMAL POINT
#line 1421 "test-new/nrimp10s-77.imp"
DOTSEEN = 1;
// 1422 %WHILE M'0'<=I<=M'9' %CYCLE
#line 1422 "test-new/nrimp10s-77.imp"
L_011B:;
#line 1422 "test-new/nrimp10s-77.imp"
{
// Double-sided test on I (Part I)
#line 1422 "test-new/nrimp10s-77.imp"
int tmp;
#line 1422 "test-new/nrimp10s-77.imp"
if (48 > (tmp = I)) goto L_011C;
// Double-sided test on I (Part II)
#line 1422 "test-new/nrimp10s-77.imp"
if (tmp > 57) goto L_011C;
#line 1422 "test-new/nrimp10s-77.imp"
}
// 1423 CVALUE=CVALUE+(I&15)/X
#line 1423 "test-new/nrimp10s-77.imp"
CVALUE = CVALUE + (double)((I & 15) / X);
// 1424 X=TEN*X; Q=Q+1; I=CC(Q)
#line 1424 "test-new/nrimp10s-77.imp"
X = TEN * X;
#line 1424 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1424 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1425 %REPEAT
#line 1425 "test-new/nrimp10s-77.imp"
goto L_011B;
#line 1425 "test-new/nrimp10s-77.imp"
L_011C:;
// 1426 ALPHA: ! TEST FOR EXPONENT
#line 1426 "test-new/nrimp10s-77.imp"
U_100D:;
// 1427 %IF MODE=0 %AND CC(Q)='@' %THEN %START
#line 1427 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_011D;
#line 1427 "test-new/nrimp10s-77.imp"
if (CC[Q] != 64) goto L_011D;
// 1428 Q=Q+1; X=CVALUE
#line 1428 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1428 "test-new/nrimp10s-77.imp"
X = CVALUE;
// 1429 Z=1; I=CC(Q)
#line 1429 "test-new/nrimp10s-77.imp"
Z = 1;
#line 1429 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1430 %IF I='-' %THEN Z=-1
#line 1430 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_011E;
#line 1430 "test-new/nrimp10s-77.imp"
Z = -1;
#line 1430 "test-new/nrimp10s-77.imp"
L_011E:;
// 1431 %IF I='+' %OR I='-' %THEN Q=Q+1
#line 1431 "test-new/nrimp10s-77.imp"
if (I == 43) goto L_011F;
#line 1431 "test-new/nrimp10s-77.imp"
if (I != 45) goto L_0120;
#line 1431 "test-new/nrimp10s-77.imp"
L_011F:;
#line 1431 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1431 "test-new/nrimp10s-77.imp"
L_0120:;
// 1432 CONST(2)
#line 1432 "test-new/nrimp10s-77.imp"
CONST(2);
// 1433 %IF HIT=0 %THEN %RETURN
#line 1433 "test-new/nrimp10s-77.imp"
if (HIT != 0) goto L_0121;
#line 1433 "test-new/nrimp10s-77.imp"
return;
#line 1433 "test-new/nrimp10s-77.imp"
L_0121:;
// 1434 HIT=0
#line 1434 "test-new/nrimp10s-77.imp"
HIT = 0;
// 1435 R=RR+1
#line 1435 "test-new/nrimp10s-77.imp"
R = RR + 1;
// 1436 %IF A(R)>>4#4 %THEN %RETURN; ! EXPONENT MUST BE HALFINTEGER
#line 1436 "test-new/nrimp10s-77.imp"
if ((unsigned int)A[R] >> 4 == 4) goto L_0122;
#line 1436 "test-new/nrimp10s-77.imp"
return;
#line 1436 "test-new/nrimp10s-77.imp"
L_0122:;
// 1437 S=FROM AR2(R+1)*Z
#line 1437 "test-new/nrimp10s-77.imp"
S = FROMAR2(R + 1) * Z;
// 1438 %IF S=-99 %THEN CVALUE=0 %ELSE %START
#line 1438 "test-new/nrimp10s-77.imp"
if (S != -99) goto L_0123;
#line 1438 "test-new/nrimp10s-77.imp"
CVALUE = 0;
#line 1438 "test-new/nrimp10s-77.imp"
goto L_0124;
#line 1438 "test-new/nrimp10s-77.imp"
L_0123:;
// 1439 ! %IF USE IMP=NO %THEN %START
// 1440 ! *MPSR_16_8080; ! MASK OUT REAL OVERFLOW
// 1441 ! %FINISH
// 1442 %WHILE S>0 %CYCLE
#line 1442 "test-new/nrimp10s-77.imp"
L_0125:;
#line 1442 "test-new/nrimp10s-77.imp"
if (S <= 0) goto L_0126;
// 1443 S=S-1
#line 1443 "test-new/nrimp10s-77.imp"
S = S - 1;
// 1444 CVALUE=CVALUE*TEN
#line 1444 "test-new/nrimp10s-77.imp"
CVALUE = CVALUE * TEN;
// 1445 ! %IF USE IMP=NO %THEN %START
// 1446 ! *JAT_15,<FAIL>
// 1447 ! %FINISH
// 1448 %REPEAT
#line 1448 "test-new/nrimp10s-77.imp"
goto L_0125;
#line 1448 "test-new/nrimp10s-77.imp"
L_0126:;
// 1449 %WHILE S<0 %AND CVALUE#0 %CYCLE
#line 1449 "test-new/nrimp10s-77.imp"
L_0127:;
#line 1449 "test-new/nrimp10s-77.imp"
if (S >= 0) goto L_0128;
#line 1449 "test-new/nrimp10s-77.imp"
if (CVALUE == 0) goto L_0128;
// 1450 S=S+1
#line 1450 "test-new/nrimp10s-77.imp"
S = S + 1;
// 1451 CVALUE=CVALUE/TEN
#line 1451 "test-new/nrimp10s-77.imp"
CVALUE = (double)(CVALUE / TEN);
// 1452 %REPEAT
#line 1452 "test-new/nrimp10s-77.imp"
goto L_0127;
#line 1452 "test-new/nrimp10s-77.imp"
L_0128:;
// 1453 %FINISH
#line 1453 "test-new/nrimp10s-77.imp"
L_0124:;
// 1454 %FINISH
#line 1454 "test-new/nrimp10s-77.imp"
L_011D:;
// 1455 ! SEE IF IT IS INTEGER
// 1456 %IF FS='D' %THEN %START
#line 1456 "test-new/nrimp10s-77.imp"
if (FS != 68) goto L_0129;
// 1457 I=CC(Q)
#line 1457 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1458 %IF I='''' %THEN Q=Q+1 %ELSE %RETURN
#line 1458 "test-new/nrimp10s-77.imp"
if (I != 39) goto L_012A;
#line 1458 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1458 "test-new/nrimp10s-77.imp"
goto L_012B;
#line 1458 "test-new/nrimp10s-77.imp"
L_012A:;
#line 1458 "test-new/nrimp10s-77.imp"
return;
#line 1458 "test-new/nrimp10s-77.imp"
L_012B:;
// 1459 DOTSEEN=1; ! ENSURE NOT TAKEN AS INTEGER
#line 1459 "test-new/nrimp10s-77.imp"
DOTSEEN = 1;
// 1460 %FINISH
#line 1460 "test-new/nrimp10s-77.imp"
L_0129:;
// 1461 %IF DOTSEEN=1 %OR CVALUE>IMAX %OR FRACPT(CVALUE)#0 %THEN CTYPE=2 %ELSE CTYPE=1 %AND S=INT(CVALUE)
#line 1461 "test-new/nrimp10s-77.imp"
if (DOTSEEN == 1) goto L_012C;
#line 1461 "test-new/nrimp10s-77.imp"
if (CVALUE > IMAX) goto L_012C;
#line 1461 "test-new/nrimp10s-77.imp"
if (FRACPT(CVALUE) == 0) goto L_012D;
#line 1461 "test-new/nrimp10s-77.imp"
L_012C:;
#line 1461 "test-new/nrimp10s-77.imp"
CTYPE = 2;
#line 1461 "test-new/nrimp10s-77.imp"
goto L_012E;
#line 1461 "test-new/nrimp10s-77.imp"
L_012D:;
#line 1461 "test-new/nrimp10s-77.imp"
CTYPE = 1;
#line 1461 "test-new/nrimp10s-77.imp"
S = _imp_INT(CVALUE);
#line 1461 "test-new/nrimp10s-77.imp"
L_012E:;
// 1462 %IF CTYPE=1 %THEN ->IEND
#line 1462 "test-new/nrimp10s-77.imp"
if (CTYPE != 1) goto L_012F;
#line 1462 "test-new/nrimp10s-77.imp"
goto U_100C;
#line 1462 "test-new/nrimp10s-77.imp"
L_012F:;
// 1463 %IF CPREC=5 %THEN CPREC=6; ! NO 32 BIT REAL CONSTS
#line 1463 "test-new/nrimp10s-77.imp"
if (CPREC != 5) goto L_0130;
#line 1463 "test-new/nrimp10s-77.imp"
CPREC = 6;
#line 1463 "test-new/nrimp10s-77.imp"
L_0130:;
// 1464 %IF CPREC=6 %THEN %START
#line 1464 "test-new/nrimp10s-77.imp"
if (CPREC != 6) goto L_0131;
// 1465 ! %IF USE IMP=NO %THEN %START; ! SOFTWARE ROUND IN MC CODE ONLY
// 1466 ! *LSD_CVALUE
// 1467 ! *AND_16_FF00000000000000
// 1468 ! *SLSD_CVALUE+8
// 1469 ! *AND_16_0080000000000000
// 1470 ! *LUH_%TOS
// 1471 ! *RAD_CVALUE
// 1472 ! *ST_CVALUE
// 1473 ! %FINISH
// 1474 %FINISH
#line 1474 "test-new/nrimp10s-77.imp"
L_0131:;
// 1475 TOAR8(R,CVALUE); R=R+8
#line 1475 "test-new/nrimp10s-77.imp"
TOAR8(R, CVALUE);
#line 1475 "test-new/nrimp10s-77.imp"
R = R + 8;
// 1476 %IF CPREC=7 %THEN TOAR8(R,LONGREAL(ADDR(CVALUE)+8)) %AND R=R+8
#line 1476 "test-new/nrimp10s-77.imp"
if (CPREC != 7) goto L_0132;
#line 1476 "test-new/nrimp10s-77.imp"
TOAR8(R, *_imp_LONGREAL(_imp_ADDR(/*?*/ &CVALUE) + 8));
#line 1476 "test-new/nrimp10s-77.imp"
R = R + 8;
#line 1476 "test-new/nrimp10s-77.imp"
L_0132:;
// 1477 A(RR)=CPREC<<4+CTYPE
#line 1477 "test-new/nrimp10s-77.imp"
A[RR] = (CPREC << 4) + CTYPE;
// 1478 HIT=1
#line 1478 "test-new/nrimp10s-77.imp"
HIT = 1;
// 1479 FAIL: %END
#line 1479 "test-new/nrimp10s-77.imp"
U_100E:;
#line 1479 "test-new/nrimp10s-77.imp"
return;
#line 1479 "test-new/nrimp10s-77.imp"
} /* end of CONST */
// ?FAIL unused
// 1480 %ROUTINE TEXTTEXT(%INTEGER EBCDIC)
#line 1480 "test-new/nrimp10s-77.imp"
void TEXTTEXT(int EBCDIC) {
// 1481 !***********************************************************************
// 1482 !* PROCESSES TEXT BETWEEN DOUBLE QUOTES AND STORES IN ISO OR EBCDIC *
// 1483 !***********************************************************************
// 1484 %INTEGER J, II
#line 1484 "test-new/nrimp10s-77.imp"
int J;
#line 1484 "test-new/nrimp10s-77.imp"
int II;
// 1485 %CONSTINTEGER QU='"'
// 1486 I=CC(Q)
#line 1486 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1487 S=R+4; R=R+5; HIT=0
#line 1487 "test-new/nrimp10s-77.imp"
S = R + 4;
#line 1487 "test-new/nrimp10s-77.imp"
R = R + 5;
#line 1487 "test-new/nrimp10s-77.imp"
HIT = 0;
// 1488 %RETURN %UNLESS I=QU; ! FAIL UNLESS INITIAL QUOTE
#line 1488 "test-new/nrimp10s-77.imp"
if (I == 34) goto L_0133;
#line 1488 "test-new/nrimp10s-77.imp"
return;
#line 1488 "test-new/nrimp10s-77.imp"
L_0133:;
// 1489 Q=Q+1
#line 1489 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1490 %CYCLE
#line 1490 "test-new/nrimp10s-77.imp"
L_0134:;
// 1491 I=CC(Q)
#line 1491 "test-new/nrimp10s-77.imp"
I = CC[Q];
// 1492 %IF EBCDIC#0 %THEN II=ITOETAB(I) %ELSE II=I
#line 1492 "test-new/nrimp10s-77.imp"
if (EBCDIC == 0) goto L_0135;
#line 1492 "test-new/nrimp10s-77.imp"
II = ITOETAB[I];
#line 1492 "test-new/nrimp10s-77.imp"
goto L_0136;
#line 1492 "test-new/nrimp10s-77.imp"
L_0135:;
#line 1492 "test-new/nrimp10s-77.imp"
II = I;
#line 1492 "test-new/nrimp10s-77.imp"
L_0136:;
// 1493 A(R)=II; R=R+1
#line 1493 "test-new/nrimp10s-77.imp"
A[R] = II;
#line 1493 "test-new/nrimp10s-77.imp"
R = R + 1;
// 1494 %IF I=QU %THEN %START
#line 1494 "test-new/nrimp10s-77.imp"
if (I != 34) goto L_0137;
// 1495 Q=Q+1
#line 1495 "test-new/nrimp10s-77.imp"
Q = Q + 1;
// 1496 %IF CC(Q)#QU %THEN %EXIT
#line 1496 "test-new/nrimp10s-77.imp"
if (CC[Q] == 34) goto L_0138;
#line 1496 "test-new/nrimp10s-77.imp"
goto L_0139;
#line 1496 "test-new/nrimp10s-77.imp"
L_0138:;
// 1497 %FINISH
#line 1497 "test-new/nrimp10s-77.imp"
L_0137:;
// 1498 %IF I=10 %THEN READLINE(1,QU) %ELSE Q=Q+1
#line 1498 "test-new/nrimp10s-77.imp"
if (I != 10) goto L_013A;
#line 1498 "test-new/nrimp10s-77.imp"
READLINE(1, 34);
#line 1498 "test-new/nrimp10s-77.imp"
goto L_013B;
#line 1498 "test-new/nrimp10s-77.imp"
L_013A:;
#line 1498 "test-new/nrimp10s-77.imp"
Q = Q + 1;
#line 1498 "test-new/nrimp10s-77.imp"
L_013B:;
// 1499 FAULT(106,0) %IF R-S>256
#line 1499 "test-new/nrimp10s-77.imp"
if (R - S <= 256) goto L_013C;
#line 1499 "test-new/nrimp10s-77.imp"
FAULT(106, 0);
#line 1499 "test-new/nrimp10s-77.imp"
L_013C:;
// 1500 %REPEAT
#line 1500 "test-new/nrimp10s-77.imp"
goto L_0134;
#line 1500 "test-new/nrimp10s-77.imp"
L_0139:;
// 1501 R=R-1; J=R-S-1
#line 1501 "test-new/nrimp10s-77.imp"
R = R - 1;
#line 1501 "test-new/nrimp10s-77.imp"
J = R - S - 1;
// 1502 A(S)=J; HIT=1
#line 1502 "test-new/nrimp10s-77.imp"
A[S] = J;
#line 1502 "test-new/nrimp10s-77.imp"
HIT = 1;
// 1503 %END
#line 1503 "test-new/nrimp10s-77.imp"
return;
#line 1503 "test-new/nrimp10s-77.imp"
} /* end of TEXTTEXT */
// 1504 BEND:%END; ! OF BLOCK CONTAINING PASS 1
#line 1504 "test-new/nrimp10s-77.imp"
U_1000:;
#line 1504 "test-new/nrimp10s-77.imp"
goto end_1001;
#line 1504 "test-new/nrimp10s-77.imp"
end_1001:;
#line 1504 "test-new/nrimp10s-77.imp"
}
// 1505 %IF LEVEL>1 %THEN FAULT(15, 0)
#line 1505 "test-new/nrimp10s-77.imp"
if (LEVEL <= 1) goto L_013D;
#line 1505 "test-new/nrimp10s-77.imp"
FAULT(15, 0);
#line 1505 "test-new/nrimp10s-77.imp"
L_013D:;
// 1506 I=0
#line 1506 "test-new/nrimp10s-77.imp"
I = 0;
// 1507 NEWLINE
#line 1507 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
// 1508 %IF FAULTY=0 %THEN %START
#line 1508 "test-new/nrimp10s-77.imp"
if (FAULTY != 0) goto L_013E;
// 1509 WRITE(LINE, 5)
#line 1509 "test-new/nrimp10s-77.imp"
_imp_WRITE(LINE, 5);
// 1510 PRINT STRING(" LINES ANALYSED IN")
#line 1510 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" LINES ANALYSED IN"));
// 1511 WRITE(INT(1000*(CPUTIME-CTIME)),5)
#line 1511 "test-new/nrimp10s-77.imp"
_imp_WRITE(_imp_INT(1000 * (CPUTIME() - CTIME)), 5);
// 1512 PRINT STRING(" MSECS - SIZE=")
#line 1512 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" MSECS - SIZE="));
// 1513 WRITE(P1SIZE, 5)
#line 1513 "test-new/nrimp10s-77.imp"
_imp_WRITE(P1SIZE, 5);
// 1514 %IF LINE>90 %AND LIST#0 %THEN NEWPAGE %ELSE NEWLINE
#line 1514 "test-new/nrimp10s-77.imp"
if (LINE <= 90) goto L_013F;
#line 1514 "test-new/nrimp10s-77.imp"
if (LIST == 0) goto L_013F;
#line 1514 "test-new/nrimp10s-77.imp"
NEWPAGE();
#line 1514 "test-new/nrimp10s-77.imp"
goto L_0140;
#line 1514 "test-new/nrimp10s-77.imp"
L_013F:;
#line 1514 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
#line 1514 "test-new/nrimp10s-77.imp"
L_0140:;
// 1515 %FINISH %ELSE %START
#line 1515 "test-new/nrimp10s-77.imp"
goto L_0141;
#line 1515 "test-new/nrimp10s-77.imp"
L_013E:;
// 1516 PRINTSTRING("CODE GENERATION NOT ATTEMPTED
#line 1516 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("CODE GENERATION NOT ATTEMPTED\n"));
// 1517+ ")
// 1518 COMREG(24)=8
#line 1518 "test-new/nrimp10s-77.imp"
*COMREG(24) = 8;
// 1519 COMREG(47)=FAULTY
#line 1519 "test-new/nrimp10s-77.imp"
*COMREG(47) = FAULTY;
// 1520 %STOP
#line 1520 "test-new/nrimp10s-77.imp"
_imp_stop(0);
// 1521 %FINISH
#line 1521 "test-new/nrimp10s-77.imp"
L_0141:;
// 1522 %BEGIN
#line 1522 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 1523 !***********************************************************************
// 1524 !* SECOND OR CODE GENERATING PASS *
// 1525 !***********************************************************************
// 1526 %INTEGERARRAY REGISTER, GRUSE, GRAT, GRINF1, GRINF2, OLINK(0:7)
#line 1526 "test-new/nrimp10s-77.imp"
int REGISTER[8];
#line 1526 "test-new/nrimp10s-77.imp"
int GRUSE[8];
#line 1526 "test-new/nrimp10s-77.imp"
int GRAT[8];
#line 1526 "test-new/nrimp10s-77.imp"
int GRINF1[8];
#line 1526 "test-new/nrimp10s-77.imp"
int GRINF2[8];
#line 1526 "test-new/nrimp10s-77.imp"
int OLINK[8];
// 1527 %BYTEINTEGERARRAY CODE, GLABUF(0:268)
#line 1527 "test-new/nrimp10s-77.imp"
unsigned char CODE[269];
#line 1527 "test-new/nrimp10s-77.imp"
unsigned char GLABUF[269];
// 1528 %INTEGERARRAY PLABS, DESADS, PLINK(0:31)
#line 1528 "test-new/nrimp10s-77.imp"
int PLABS[32];
#line 1528 "test-new/nrimp10s-77.imp"
int DESADS[32];
#line 1528 "test-new/nrimp10s-77.imp"
int PLINK[32];
// 1529 %INTEGERARRAY SET, STACKBASE, RAL, FLAG, L, M, NMDECS, ONWORD, ONINF,{%C
#line 1529 "test-new/nrimp10s-77.imp"
int SET[32];
#line 1529 "test-new/nrimp10s-77.imp"
int STACKBASE[32];
#line 1529 "test-new/nrimp10s-77.imp"
int RAL[32];
#line 1529 "test-new/nrimp10s-77.imp"
int FLAG[32];
#line 1529 "test-new/nrimp10s-77.imp"
int L[32];
#line 1529 "test-new/nrimp10s-77.imp"
int M[32];
#line 1529 "test-new/nrimp10s-77.imp"
int NMDECS[32];
#line 1529 "test-new/nrimp10s-77.imp"
int ONWORD[32];
#line 1529 "test-new/nrimp10s-77.imp"
int ONINF[32];
#line 1529 "test-new/nrimp10s-77.imp"
int JUMP[32];
#line 1529 "test-new/nrimp10s-77.imp"
int LABEL[32];
#line 1529 "test-new/nrimp10s-77.imp"
int JROUND[32];
#line 1529 "test-new/nrimp10s-77.imp"
int DIAGINF[32];
#line 1529 "test-new/nrimp10s-77.imp"
int DISPLAY[32];
#line 1529 "test-new/nrimp10s-77.imp"
int AUXSBASE[32];
#line 1529 "test-new/nrimp10s-77.imp"
int NAMES[32];
// 1530+ JUMP, LABEL, JROUND, DIAGINF, DISPLAY, {%C
// 1531+ AUXSBASE, NAMES (0:MAXLEVELS)
// 1532 %INTEGERARRAY AVL WSP(0:4,0:MAXLEVELS)
#line 1532 "test-new/nrimp10s-77.imp"
int AVLWSP[5][32];
// 1533 %recordformat rcf(%integerarray val(0:12* 2047 {NNAMES})) { unfortunately we can't have a dynamically-sized array in a record. Largest possible is 2047.
#line 1533 "test-new/nrimp10s-77.imp"
struct RCF {
union {
struct {
#line 1533 "test-new/nrimp10s-77.imp"
int VAL[24565];
#line 1533 "test-new/nrimp10s-77.imp"
};
};
};
// 1534 %record (rcf) %name CTABLE
#line 1534 "test-new/nrimp10s-77.imp"
struct RCF *CTABLE;
#line 1534 "test-new/nrimp10s-77.imp"
auto void CNOP(int I, int J);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PCLOD(int FROM, int TO);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PCONST(int WORD);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PSF1(int OPCODE, int K, int N);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PF1(int OPCODE, int KP, int KPP, int N);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PSORLF1(int OPCODE, int KP, int KPP, int N);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PF2(int OPCODE, int H, int Q, int N, int MASK, int FILLER);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PF3(int OPCODE, int MASK, int KPPP, int N);
#line 1534 "test-new/nrimp10s-77.imp"
auto void NOTECREF(int CA, int N);
#line 1534 "test-new/nrimp10s-77.imp"
auto int PARAMDES(int PREC);
#line 1534 "test-new/nrimp10s-77.imp"
auto int MAPDES(int PREC);
#line 1534 "test-new/nrimp10s-77.imp"
auto int SPECIALCONSTS(int WHICH);
#line 1534 "test-new/nrimp10s-77.imp"
auto void STORECONST(int *D, int L, int AD);
#line 1534 "test-new/nrimp10s-77.imp"
auto void DUMPCONSTS(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PLANT(int HALFWORD);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PLUG(int AREA, int AT, int VALUE, int BYTES);
#line 1534 "test-new/nrimp10s-77.imp"
auto void CODEOUT(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PROLOGUE(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void EPILOGUE(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void COMPILEASTMNT(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void CSS(int P);
#line 1534 "test-new/nrimp10s-77.imp"
auto void LOADDATA(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void ABORT(void);
#line 1534 "test-new/nrimp10s-77.imp"
auto void PRINTUSE(void);
// 1535 {%INTEGERARRAYFORMAT CF(0:12*NNAMES) - Imp77 doesn't support ARRAY() mapping.
// 1536 {%INTEGERARRAY(1)%NAME CTABLE
// 1537 %ROUTINESPEC CNOP(%INTEGER I, J)
// 1538 %ROUTINESPEC PCLOD(%INTEGER FROM, TO)
// 1539 %ROUTINESPEC PCONST(%INTEGER X)
// 1540 %ROUTINESPEC PSF1(%INTEGER OPCODE,K,N)
// 1541 %ROUTINESPEC PF1(%INTEGER OPCODE,KP,KPP,N)
// 1542 %ROUTINESPEC PSORLF1(%INTEGER OPCODE,KP,KPP,N)
// 1543 %ROUTINESPEC PF2(%INTEGER OPCODE,H,Q,N,MASK,FILLER)
// 1544 %ROUTINESPEC PF3(%INTEGER OPCODE,MASK,KPPP,N)
// 1545 %ROUTINESPEC NOTE CREF(%INTEGER CA,VAL)
// 1546 %INTEGERFNSPEC PARAM DES(%INTEGER PREC)
// 1547 %INTEGERFNSPEC MAPDES(%INTEGER PREC)
// 1548 %INTEGERFNSPEC SPECIAL CONSTS(%INTEGER WHICH)
// 1549 %ROUTINESPEC STORE CONST(%INTEGERNAME D,%INTEGER L,AD)
// 1550 %ROUTINESPEC DUMP CONSTS
// 1551 %ROUTINESPEC PLANT(%INTEGER VALUE)
// 1552 %ROUTINESPEC PLUG(%INTEGER I, J, K, BYTES)
// 1553 %ROUTINESPEC CODEOUT
// 1554 %ROUTINESPEC PROLOGUE
// 1555 %ROUTINESPEC EPILOGUE
// 1556 %ROUTINESPEC COMPILE A STMNT
// 1557 %ROUTINESPEC CSS(%INTEGER P)
// 1558 %ROUTINESPEC LOAD DATA
// 1559 %ROUTINESPEC ABORT
// 1560 !*DELSTART
// 1561 %ROUTINESPEC PRINT USE
// 1562 !*DELEND
// 1563 %CYCLE I=0,1,7
#line 1563 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 7 %cycle
#line 1563 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 7;
#line 1563 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 7");
_control = I = _initial - _increment;
#line 1563 "test-new/nrimp10s-77.imp"
L_0142:
#line 1563 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1563 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0143;
#line 1563 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 1564 REGISTER(I)=0; GRUSE(I)=0; GRINF1(I)=0; GRAT(I)=0
#line 1564 "test-new/nrimp10s-77.imp"
REGISTER[I] = 0;
#line 1564 "test-new/nrimp10s-77.imp"
GRUSE[I] = 0;
#line 1564 "test-new/nrimp10s-77.imp"
GRINF1[I] = 0;
#line 1564 "test-new/nrimp10s-77.imp"
GRAT[I] = 0;
// 1565 GRINF2(I)=0
#line 1565 "test-new/nrimp10s-77.imp"
GRINF2[I] = 0;
// 1566 %REPEAT
#line 1566 "test-new/nrimp10s-77.imp"
goto L_0142;
#line 1566 "test-new/nrimp10s-77.imp"
}
#line 1566 "test-new/nrimp10s-77.imp"
L_0143:;
// 1567 %CYCLE I=0, 1, MAXLEVELS
#line 1567 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 31 %cycle
#line 1567 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 31;
#line 1567 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 31");
_control = I = _initial - _increment;
#line 1567 "test-new/nrimp10s-77.imp"
L_0145:
#line 1567 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1567 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0146;
#line 1567 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// ?Non-local
// 1568 SET(I)=0; STACKBASE(I)=0; RAL(I)=0
#line 1568 "test-new/nrimp10s-77.imp"
SET[I] = 0;
#line 1568 "test-new/nrimp10s-77.imp"
STACKBASE[I] = 0;
#line 1568 "test-new/nrimp10s-77.imp"
RAL[I] = 0;
// 1569 JUMP(I)=0; JROUND(I)=0
#line 1569 "test-new/nrimp10s-77.imp"
JUMP[I] = 0;
#line 1569 "test-new/nrimp10s-77.imp"
JROUND[I] = 0;
// 1570 LABEL(I)=0; FLAG(I)=0
#line 1570 "test-new/nrimp10s-77.imp"
LABEL[I] = 0;
#line 1570 "test-new/nrimp10s-77.imp"
FLAG[I] = 0;
// 1571 L(I)=0; M(I)=0; DIAGINF(I)=0
#line 1571 "test-new/nrimp10s-77.imp"
L[I] = 0;
#line 1571 "test-new/nrimp10s-77.imp"
M[I] = 0;
#line 1571 "test-new/nrimp10s-77.imp"
DIAGINF[I] = 0;
// 1572 DISPLAY(I)=0; ONWORD(I)=0; ONINF(I)=0
#line 1572 "test-new/nrimp10s-77.imp"
DISPLAY[I] = 0;
#line 1572 "test-new/nrimp10s-77.imp"
ONWORD[I] = 0;
#line 1572 "test-new/nrimp10s-77.imp"
ONINF[I] = 0;
// 1573 NAMES(I)=-1
#line 1573 "test-new/nrimp10s-77.imp"
NAMES[I] = -1;
// 1574 %CYCLE J=0,1,4
#line 1574 "test-new/nrimp10s-77.imp"
// %for J = 0, 1, 4 %cycle
#line 1574 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 4;
#line 1574 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 0, 1, 4");
_control = J = _initial - _increment;
#line 1574 "test-new/nrimp10s-77.imp"
L_0147:
#line 1574 "test-new/nrimp10s-77.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 1574 "test-new/nrimp10s-77.imp"
if (J == _final) goto L_0148;
#line 1574 "test-new/nrimp10s-77.imp"
_control += _increment;
J += _increment;
// ?Non-local
// 1575 AVL WSP(J,I)=0
#line 1575 "test-new/nrimp10s-77.imp"
AVLWSP[J][I] = 0;
// 1576 %REPEAT
#line 1576 "test-new/nrimp10s-77.imp"
goto L_0147;
#line 1576 "test-new/nrimp10s-77.imp"
}
#line 1576 "test-new/nrimp10s-77.imp"
L_0148:;
// 1577 %REPEAT
#line 1577 "test-new/nrimp10s-77.imp"
goto L_0145;
#line 1577 "test-new/nrimp10s-77.imp"
}
#line 1577 "test-new/nrimp10s-77.imp"
L_0146:;
// 1578 {CTABLE==ARRAY(ADDR(ASLIST(1)),CF)
// 1579 CTABLE==RECORD(ADDR(ASLIST(1)))
#line 1579 "test-new/nrimp10s-77.imp"
CTABLE = (struct RCF *)_imp_RECORD(_imp_ADDR(/*?*/ &ASLIST[1]));
// 1580 CONST HOLE=0
#line 1580 "test-new/nrimp10s-77.imp"
CONSTHOLE = 0;
// 1581 PROLOGUE
#line 1581 "test-new/nrimp10s-77.imp"
PROLOGUE();
// 1582 LINE=0
#line 1582 "test-new/nrimp10s-77.imp"
LINE = 0;
// 1583 NEXTP=1; LEVEL=1; STMTS=0
#line 1583 "test-new/nrimp10s-77.imp"
NEXTP = 1;
#line 1583 "test-new/nrimp10s-77.imp"
LEVEL = 1;
#line 1583 "test-new/nrimp10s-77.imp"
STMTS = 0;
// 1584 RLEVEL=0; RBASE=0
#line 1584 "test-new/nrimp10s-77.imp"
RLEVEL = 0;
#line 1584 "test-new/nrimp10s-77.imp"
RBASE = 0;
// 1585 %WHILE A(NEXTP+3)!A(NEXTP+4)#0 %CYCLE
#line 1585 "test-new/nrimp10s-77.imp"
L_014A:;
#line 1585 "test-new/nrimp10s-77.imp"
if (A[NEXTP + 3] | A[NEXTP + 4] == 0) goto L_014B;
// 1586 COMPILE A STMNT
#line 1586 "test-new/nrimp10s-77.imp"
COMPILEASTMNT();
// 1587 %REPEAT
#line 1587 "test-new/nrimp10s-77.imp"
goto L_014A;
#line 1587 "test-new/nrimp10s-77.imp"
L_014B:;
// 1588 LINE=99999
#line 1588 "test-new/nrimp10s-77.imp"
LINE = 99999;
// 1589 EPILOGUE
#line 1589 "test-new/nrimp10s-77.imp"
EPILOGUE();
// 1590 LOAD DATA
#line 1590 "test-new/nrimp10s-77.imp"
LOADDATA();
// 1591 %STOP
#line 1591 "test-new/nrimp10s-77.imp"
_imp_stop(0);
// 1592 %ROUTINE COMPILE A STMNT
#line 1592 "test-new/nrimp10s-77.imp"
void COMPILEASTMNT(void) {
// 1593 %INTEGER I
#line 1593 "test-new/nrimp10s-77.imp"
int I;
// 1594 !*DELSTART
// 1595 %IF DCOMP#0 %AND CA>CABUF %THEN CODEOUT %AND PRINTUSE
#line 1595 "test-new/nrimp10s-77.imp"
if (DCOMP == 0) goto L_014C;
#line 1595 "test-new/nrimp10s-77.imp"
if (CA <= CABUF) goto L_014C;
#line 1595 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1595 "test-new/nrimp10s-77.imp"
PRINTUSE();
#line 1595 "test-new/nrimp10s-77.imp"
L_014C:;
// 1596 !*DELEND
// 1597 I=NEXTP
#line 1597 "test-new/nrimp10s-77.imp"
I = NEXTP;
// 1598 NEXTP=NEXTP+A(NEXTP)<<16+A(NEXTP+1)<<8+A(NEXTP+2)
#line 1598 "test-new/nrimp10s-77.imp"
NEXTP = NEXTP + (A[NEXTP] << 16) + (A[NEXTP + 1] << 8) + A[NEXTP + 2];
// 1599 LINE=A(I+3)<<8+A(I+4)
#line 1599 "test-new/nrimp10s-77.imp"
LINE = (A[I + 3] << 8) + A[I + 4];
// 1600 STMTS=STMTS+1
#line 1600 "test-new/nrimp10s-77.imp"
STMTS = STMTS + 1;
// 1601 CSS(I+5)
#line 1601 "test-new/nrimp10s-77.imp"
CSS(I + 5);
// 1602 ! CHECK ASL %IF LINE&7=0
// 1603 %END
#line 1603 "test-new/nrimp10s-77.imp"
return;
#line 1603 "test-new/nrimp10s-77.imp"
} /* end of COMPILEASTMNT */
// 1604 %ROUTINE LOAD DATA
#line 1604 "test-new/nrimp10s-77.imp"
void LOADDATA(void) {
// 1605 !***********************************************************************
// 1606 !* PASS INFORMATION TO LPUT TO ENABLE IT TO GENERATE THE *
// 1607 !* LOADER DATA AND COMPLETE THE PROGRAM FILE. *
// 1608 !***********************************************************************
// 1609 %INTEGER LANGFLAG,PARMS
#line 1609 "test-new/nrimp10s-77.imp"
int LANGFLAG;
#line 1609 "test-new/nrimp10s-77.imp"
int PARMS;
// 1610 GLACA=(GLACA+7)&(-8)
#line 1610 "test-new/nrimp10s-77.imp"
GLACA = GLACA + 7 & -8;
// 1611 USTPTR=(USTPTR+7)&(-8)
#line 1611 "test-new/nrimp10s-77.imp"
USTPTR = USTPTR + 7 & -8;
// 1612 CODE OUT
#line 1612 "test-new/nrimp10s-77.imp"
CODEOUT();
// 1613 CNOP(0, 8)
#line 1613 "test-new/nrimp10s-77.imp"
CNOP(0, 8);
// 1614 DUMP CONSTS
#line 1614 "test-new/nrimp10s-77.imp"
DUMPCONSTS();
// 1615 %IF PARMTRACE=0 %THEN LANGFLAG=6 %ELSE LANGFLAG=1
#line 1615 "test-new/nrimp10s-77.imp"
if (PARMTRACE != 0) goto L_014D;
#line 1615 "test-new/nrimp10s-77.imp"
LANGFLAG = 6;
#line 1615 "test-new/nrimp10s-77.imp"
goto L_014E;
#line 1615 "test-new/nrimp10s-77.imp"
L_014D:;
#line 1615 "test-new/nrimp10s-77.imp"
LANGFLAG = 1;
#line 1615 "test-new/nrimp10s-77.imp"
L_014E:;
// 1616 LANGFLAG=LANGFLAG<<24
#line 1616 "test-new/nrimp10s-77.imp"
LANGFLAG = LANGFLAG << 24;
// 1617 PARMS=(PARMDIAG<<1!PARMLINE)<<1!PARMTRACE
#line 1617 "test-new/nrimp10s-77.imp"
PARMS = (PARMDIAG << 1 | PARMLINE) << 1 | PARMTRACE;
// 1618 FIXED GLA(4)=LANGFLAG!1<<16!(CPRMODE&1)<<8!PARMS;! LANG RLSE & MAINPROG
#line 1618 "test-new/nrimp10s-77.imp"
FIXEDGLA[4] = LANGFLAG | 1 << 16 | (CPRMODE & 1) << 8 | PARMS;
// 1619 I=GLACA-GLACABUF
#line 1619 "test-new/nrimp10s-77.imp"
I = GLACA - GLACABUF;
// 1620 %IF INHCODE=0 %THEN %START
#line 1620 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_014F;
// 1621 LPUT(2, I, GLACABUF, ADDR(GLABUF(0))) %UNLESS I=0
#line 1621 "test-new/nrimp10s-77.imp"
if (I == 0) goto L_0150;
#line 1621 "test-new/nrimp10s-77.imp"
LPUT(2, I, GLACABUF, _imp_ADDR(/*?*/ &GLABUF[0]));
#line 1621 "test-new/nrimp10s-77.imp"
L_0150:;
// 1622 ! BACK OF GLAP
// 1623 LPUT(2, FIXEDGLALEN, 0, ADDR(FIXED GLA(0)));! FRONT OF GLAP
#line 1623 "test-new/nrimp10s-77.imp"
LPUT(2, 48, 0, _imp_ADDR(/*?*/ &FIXEDGLA[0]));
// 1624 LPUT(19,2,8,5); ! RELOCATE GLA ST ADDRESS
#line 1624 "test-new/nrimp10s-77.imp"
LPUT(19, 2, 8, 5);
// 1625 LPUT(19,2,12,4); ! RELOCATE CODE ST ADDRESS
#line 1625 "test-new/nrimp10s-77.imp"
LPUT(19, 2, 12, 4);
// 1626 I=16_E2E2E2E2
#line 1626 "test-new/nrimp10s-77.imp"
I = -488447262;
// 1627 LPUT(4, 4, SSTL, ADDR(I))
#line 1627 "test-new/nrimp10s-77.imp"
LPUT(4, 4, SSTL, _imp_ADDR(/*?*/ &I));
// 1628 !
// 1629 %FINISH
#line 1629 "test-new/nrimp10s-77.imp"
L_014F:;
// 1630 SSTL=(SSTL+11)&(-8)
#line 1630 "test-new/nrimp10s-77.imp"
SSTL = SSTL + 11 & -8;
// 1631 PRINTSTRING("
#line 1631 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("\nCODE"));
// 1632+ CODE")
// 1633 WRITE(CA, 6); PRINTSTRING(" BYTES GLAP")
#line 1633 "test-new/nrimp10s-77.imp"
_imp_WRITE(CA, 6);
#line 1633 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" BYTES GLAP"));
// 1634 WRITE(GLACA, 3); PRINTSTRING("+")
#line 1634 "test-new/nrimp10s-77.imp"
_imp_WRITE(GLACA, 3);
#line 1634 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("+"));
// 1635 WRITE(USTPTR, 1); PRINTSTRING(" BYTES DIAG TABLES")
#line 1635 "test-new/nrimp10s-77.imp"
_imp_WRITE(USTPTR, 1);
#line 1635 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" BYTES DIAG TABLES"));
// 1636 WRITE(SSTL, 3); PRINTSTRING(" BYTES
#line 1636 "test-new/nrimp10s-77.imp"
_imp_WRITE(SSTL, 3);
#line 1636 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" BYTES\nTOTAL"));
// 1637+ TOTAL")
// 1638 REGISTER(0)=CA; REGISTER(1)=GLACA
#line 1638 "test-new/nrimp10s-77.imp"
REGISTER[0] = CA;
#line 1638 "test-new/nrimp10s-77.imp"
REGISTER[1] = GLACA;
// 1639 REGISTER(2)=0
#line 1639 "test-new/nrimp10s-77.imp"
REGISTER[2] = 0;
// 1640 REGISTER(3)=SSTL
#line 1640 "test-new/nrimp10s-77.imp"
REGISTER[3] = SSTL;
// 1641 REGISTER(4)=USTPTR
#line 1641 "test-new/nrimp10s-77.imp"
REGISTER[4] = USTPTR;
// 1642 K=CA+GLACA+SSTL+USTPTR; REGISTER(5)=K
#line 1642 "test-new/nrimp10s-77.imp"
K = CA + GLACA + SSTL + USTPTR;
#line 1642 "test-new/nrimp10s-77.imp"
REGISTER[5] = K;
// 1643 WRITE(K, 5); PRINTSTRING(" BYTES")
#line 1643 "test-new/nrimp10s-77.imp"
_imp_WRITE(K, 5);
#line 1643 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" BYTES"));
// 1644 NEWLINE; PRINT CH(13); ! MARKER FOR COMP TO PRINT
#line 1644 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
#line 1644 "test-new/nrimp10s-77.imp"
PRINTCH(13);
// 1645 !SUMMARY
// 1646 %IF FAULTY=0 %THEN %START
#line 1646 "test-new/nrimp10s-77.imp"
if (FAULTY != 0) goto L_0151;
// 1647 WRITE(STMTS, 7); PRINTSTRING(" STATEMENTS COMPILED IN")
#line 1647 "test-new/nrimp10s-77.imp"
_imp_WRITE(STMTS, 7);
#line 1647 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" STATEMENTS COMPILED IN"));
// 1648 WRITE(INT(1000*(CPUTIME-CTIME)),5)
#line 1648 "test-new/nrimp10s-77.imp"
_imp_WRITE(_imp_INT(1000 * (CPUTIME() - CTIME)), 5);
// 1649 PRINTSTRING(" MSECS")
#line 1649 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" MSECS"));
// 1650 COMREG(47)=STMTS; ! NO OF STMTS FOR COMPER
#line 1650 "test-new/nrimp10s-77.imp"
*COMREG(47) = STMTS;
// 1651 %FINISH %ELSE %START
#line 1651 "test-new/nrimp10s-77.imp"
goto L_0152;
#line 1651 "test-new/nrimp10s-77.imp"
L_0151:;
// 1652 PRINTSTRING("PROGRAM CONTAINS"); WRITE(FAULTY, 2)
#line 1652 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("PROGRAM CONTAINS"));
#line 1652 "test-new/nrimp10s-77.imp"
_imp_WRITE(FAULTY, 2);
// 1653 PRINTSTRING(" FAULT"); PRINTSYMBOL('S') %IF FAULTY>1
#line 1653 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal(" FAULT"));
#line 1653 "test-new/nrimp10s-77.imp"
if (FAULTY <= 1) goto L_0153;
#line 1653 "test-new/nrimp10s-77.imp"
_imp_PRINTSYMBOL(83);
#line 1653 "test-new/nrimp10s-77.imp"
L_0153:;
// 1654 COMREG(47)=FAULTY; ! NO OF FAULTS FOR COMPER
#line 1654 "test-new/nrimp10s-77.imp"
*COMREG(47) = FAULTY;
// 1655 %FINISH
#line 1655 "test-new/nrimp10s-77.imp"
L_0152:;
// 1656 NEWLINES(2)
#line 1656 "test-new/nrimp10s-77.imp"
_imp_NEWLINES(2);
// 1657 NEWLINE
#line 1657 "test-new/nrimp10s-77.imp"
_imp_NEWLINE();
// 1658 I=0; I=8 %IF FAULTY#0
#line 1658 "test-new/nrimp10s-77.imp"
I = 0;
#line 1658 "test-new/nrimp10s-77.imp"
if (FAULTY == 0) goto L_0154;
#line 1658 "test-new/nrimp10s-77.imp"
I = 8;
#line 1658 "test-new/nrimp10s-77.imp"
L_0154:;
// 1659 COMREG(24)=I
#line 1659 "test-new/nrimp10s-77.imp"
*COMREG(24) = I;
// 1660 %IF INHCODE=0 %THEN LPUT(7, 24, 0, ADDR(REGISTER(0)))
#line 1660 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0155;
#line 1660 "test-new/nrimp10s-77.imp"
LPUT(7, 24, 0, _imp_ADDR(/*?*/ ®ISTER[0]));
#line 1660 "test-new/nrimp10s-77.imp"
L_0155:;
// 1661 ! SUMMARY INFO..REGISTER AS BUF
// 1662 PPROFILE
#line 1662 "test-new/nrimp10s-77.imp"
PPROFILE();
// 1663 %STOP
#line 1663 "test-new/nrimp10s-77.imp"
_imp_stop(0);
// 1664 %END
#line 1664 "test-new/nrimp10s-77.imp"
} /* end of LOADDATA */
// 1665 !
// 1666 !***********************************************************************
// 1667 !* IMP CODE PLANTING ROUTINES *
// 1668 !* CODE AND GLAP ARE PUT INTO THE BUFFERS 'CODE,GLABUF(0:268)' *
// 1669 !* BY A NUMBER OF TRIVIAL ROUTINES.LPUT IS CALLED TO ADD THE *
// 1670 !* BUFFER TO THE OUTPUT FILE. THE BUFFERS ARE BASICALLY 0:255 *
// 1671 !* WITH A 12-BYTE MARGIN TO MINIMISE THE NUMBER OF TESTS FOR *
// 1672 !* THE BUFFER FULL CONDITION *
// 1673 !* *
// 1674 !* PPCURR(GLACURR) IS THE BUFFER POINTER *
// 1675 !* CA(GLACA) IS THE RELATIVE ADDRESS OF THE NEXT BYTE *
// 1676 !* CABUF(GLACABUF) IS CA(GLACA) FOR START OF BUFFER *
// 1677 !***********************************************************************
// 1678 !*DELSTART
// 1679 %ROUTINE RECODE(%INTEGER S,F,AD)
#line 1679 "test-new/nrimp10s-77.imp"
void RECODE(int S, int F, int AD) {
// 1680 %IF S#F %START
#line 1680 "test-new/nrimp10s-77.imp"
if (S == F) goto L_0156;
// 1681 PRINTSTRING("
#line 1681 "test-new/nrimp10s-77.imp"
_imp_PRINTSTRING(_imp_str_literal("\nCODE FOR LINE"));
// 1682+ CODE FOR LINE"); WRITE(LINE,5)
#line 1682 "test-new/nrimp10s-77.imp"
_imp_WRITE(LINE, 5);
// 1683 NCODE(S,F,AD)
#line 1683 "test-new/nrimp10s-77.imp"
NCODE(S, F, AD);
// 1684 %FINISH
#line 1684 "test-new/nrimp10s-77.imp"
L_0156:;
// 1685 %END
#line 1685 "test-new/nrimp10s-77.imp"
return;
#line 1685 "test-new/nrimp10s-77.imp"
} /* end of RECODE */
// 1686 !*DELEND
// 1687 %ROUTINE CODEOUT
#line 1687 "test-new/nrimp10s-77.imp"
void CODEOUT(void) {
// 1688 %IF PPCURR>0 %THEN %START
#line 1688 "test-new/nrimp10s-77.imp"
if (PPCURR <= 0) goto L_0157;
// 1689 !*DELSTART
// 1690 RECODE(ADDR(CODE(0)), ADDR(CODE(PPCURR)), CABUF) %IF DCOMP#0
#line 1690 "test-new/nrimp10s-77.imp"
if (DCOMP == 0) goto L_0158;
#line 1690 "test-new/nrimp10s-77.imp"
RECODE(_imp_ADDR(/*?*/ &CODE[0]), _imp_ADDR(/*?*/ &CODE[PPCURR]), CABUF);
#line 1690 "test-new/nrimp10s-77.imp"
L_0158:;
// 1691 !*DELEND
// 1692 LPUT(1, PPCURR, CABUF, ADDR(CODE(0))) %IF INHCODE=0
#line 1692 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0159;
#line 1692 "test-new/nrimp10s-77.imp"
LPUT(1, PPCURR, CABUF, _imp_ADDR(/*?*/ &CODE[0]));
#line 1692 "test-new/nrimp10s-77.imp"
L_0159:;
// 1693 PPCURR=0; CABUF=CA
#line 1693 "test-new/nrimp10s-77.imp"
PPCURR = 0;
#line 1693 "test-new/nrimp10s-77.imp"
CABUF = CA;
// 1694 %FINISH
#line 1694 "test-new/nrimp10s-77.imp"
L_0157:;
// 1695 %END
#line 1695 "test-new/nrimp10s-77.imp"
return;
#line 1695 "test-new/nrimp10s-77.imp"
} /* end of CODEOUT */
// 1696 %ROUTINE PLANT(%INTEGER HALFWORD)
#line 1696 "test-new/nrimp10s-77.imp"
void PLANT(int HALFWORD) {
// 1697 !***********************************************************************
// 1698 !* ADD A HALF WORD OF BINARY TO THE BUFFER *
// 1699 !***********************************************************************
// 1700 ! %IF USE IMP=YES %THEN %START
// 1701 CODE(PPCURR)<-HALFWORD>>8
#line 1701 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = (unsigned char)((unsigned int)HALFWORD >> 8);
// 1702 CODE(PPCURR+1)<-HALFWORD
#line 1702 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = (unsigned char)(HALFWORD);
// 1703 PPCURR=PPCURR+2
#line 1703 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + 2;
// 1704 ! %FINISH %ELSE %START
// 1705 ! *LDA_CODE+4
// 1706 ! *LDTB_16_58000002
// 1707 ! *LB_PPCURR
// 1708 ! *LSS_HALFWORD
// 1709 ! *ST_(%DR+%B)
// 1710 ! *ADB_2
// 1711 ! *STB_PPCURR
// 1712 ! %FINISH
// 1713 CA=CA+2
#line 1713 "test-new/nrimp10s-77.imp"
CA = CA + 2;
// 1714 CODEOUT %IF PPCURR>=256
#line 1714 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_015A;
#line 1714 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1714 "test-new/nrimp10s-77.imp"
L_015A:;
// 1715 %END
#line 1715 "test-new/nrimp10s-77.imp"
return;
#line 1715 "test-new/nrimp10s-77.imp"
} /* end of PLANT */
// 1716 %ROUTINE PCONST(%INTEGER WORD)
#line 1716 "test-new/nrimp10s-77.imp"
void PCONST(int WORD) {
// 1717 !***********************************************************************
// 1718 !* ADD A WORD OF BINARY TO THE BUFFER *
// 1719 !***********************************************************************
// 1720 %INTEGER I
#line 1720 "test-new/nrimp10s-77.imp"
int I;
// 1721 ! %IF USE IMP=YES %THEN %START
// 1722 %CYCLE I=24,-8,0
#line 1722 "test-new/nrimp10s-77.imp"
// %for I = 24, -8, 0 %cycle
#line 1722 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 24, _increment = -8, _final = 0;
#line 1722 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 24, -8, 0");
_control = I = _initial - _increment;
#line 1722 "test-new/nrimp10s-77.imp"
L_015B:
#line 1722 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1722 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_015C;
#line 1722 "test-new/nrimp10s-77.imp"
_control += _increment;
I -= 8;
// 1723 CODE(PPCURR)=WORD>>I&255
#line 1723 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = (unsigned int)WORD >> I & 255;
// 1724 PPCURR=PPCURR+1
#line 1724 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + 1;
// 1725 %REPEAT
#line 1725 "test-new/nrimp10s-77.imp"
goto L_015B;
#line 1725 "test-new/nrimp10s-77.imp"
}
#line 1725 "test-new/nrimp10s-77.imp"
L_015C:;
// 1726 ! %FINISH %ELSE %START
// 1727 ! *LDA_CODE+4
// 1728 ! *LDTB_16_58000004
// 1729 ! *LSS_WORD
// 1730 ! *LB_PPCURR
// 1731 ! *ST_(%DR+%B)
// 1732 ! *ADB_4
// 1733 ! *STB_PPCURR
// 1734 ! %FINISH
// 1735 CA=CA+4
#line 1735 "test-new/nrimp10s-77.imp"
CA = CA + 4;
// 1736 CODE OUT %IF PPCURR>=256
#line 1736 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_015D;
#line 1736 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1736 "test-new/nrimp10s-77.imp"
L_015D:;
// 1737 %END
#line 1737 "test-new/nrimp10s-77.imp"
return;
#line 1737 "test-new/nrimp10s-77.imp"
} /* end of PCONST */
// 1738 %ROUTINE PSF1(%INTEGER OPCODE,K,N)
#line 1738 "test-new/nrimp10s-77.imp"
void PSF1(int OPCODE, int K, int N) {
// 1739 !***********************************************************************
// 1740 !* PLANT THE HALFWORD FORMS OF PRIMARY FORMAT NR INSTRNS *
// 1741 !* IF N IS TOO LARGE FOR THE SHORT FORM PF1 IS CALLED TO PLANT *
// 1742 !* THE CORRESPONDING LONG FORM *
// 1743 !***********************************************************************
// 1744 %INTEGER KPP
#line 1744 "test-new/nrimp10s-77.imp"
int KPP;
// 1745 ! ABORT %UNLESS 0<=K<=2 %AND OPCODE&1=0
// 1746 %IF (K=0 %AND -64<=N<=63) %OR (K#0 %AND 0<=N<=511) %START
#line 1746 "test-new/nrimp10s-77.imp"
if (K != 0) goto L_015E;
#line 1746 "test-new/nrimp10s-77.imp"
{
// Double-sided test on N (Part I)
#line 1746 "test-new/nrimp10s-77.imp"
int tmp;
#line 1746 "test-new/nrimp10s-77.imp"
if (-64 > (tmp = N)) goto L_015E;
// Double-sided test on N (Part II)
#line 1746 "test-new/nrimp10s-77.imp"
if (tmp <= 63) goto L_0144;
#line 1746 "test-new/nrimp10s-77.imp"
}
#line 1746 "test-new/nrimp10s-77.imp"
L_015E:;
#line 1746 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_015F;
#line 1746 "test-new/nrimp10s-77.imp"
{
// Double-sided test on N (Part I)
#line 1746 "test-new/nrimp10s-77.imp"
int tmp;
#line 1746 "test-new/nrimp10s-77.imp"
if (0 > (tmp = N)) goto L_015F;
// Double-sided test on N (Part II)
#line 1746 "test-new/nrimp10s-77.imp"
if (tmp > 511) goto L_015F;
#line 1746 "test-new/nrimp10s-77.imp"
}
#line 1746 "test-new/nrimp10s-77.imp"
L_0144:;
// 1747 %IF K#0 %THEN N=N//4
#line 1747 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_0160;
#line 1747 "test-new/nrimp10s-77.imp"
N = ((long)N / (long)4);
#line 1747 "test-new/nrimp10s-77.imp"
L_0160:;
// 1748 ! %IF USE IMP=YES %THEN %START
// 1749 CODE(PPCURR)=OPCODE!K>>1
#line 1749 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = OPCODE | (unsigned int)K >> 1;
// 1750 CODE(PPCURR+1)=(K&1)<<7!N&127
#line 1750 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = (K & 1) << 7 | N & 127;
// 1751 PPCURR=PPCURR+2
#line 1751 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + 2;
// 1752 ! %FINISH %ELSE %START
// 1753 ! *LSS_OPCODE
// 1754 ! *USH_1
// 1755 ! *OR_K
// 1756 ! *USH_7
// 1757 ! *SLSS_N
// 1758 ! *AND_127
// 1759 ! *LB_PPCURR
// 1760 ! *OR_%TOS
// 1761 ! *LDA_CODE+4
// 1762 ! *LDTB_16_58000002
// 1763 ! *ST_(%DR+%B)
// 1764 ! *ADB_2
// 1765 ! *STB_PPCURR
// 1766 ! %FINISH
// 1767 CA=CA+2
#line 1767 "test-new/nrimp10s-77.imp"
CA = CA + 2;
// 1768 CODEOUT %IF PPCURR>=256
#line 1768 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_0161;
#line 1768 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1768 "test-new/nrimp10s-77.imp"
L_0161:;
// 1769 %FINISH %ELSE %START
#line 1769 "test-new/nrimp10s-77.imp"
goto L_0162;
#line 1769 "test-new/nrimp10s-77.imp"
L_015F:;
// 1770 %IF K=0 %THEN KPP=0 %ELSE KPP=2
#line 1770 "test-new/nrimp10s-77.imp"
if (K != 0) goto L_0163;
#line 1770 "test-new/nrimp10s-77.imp"
KPP = 0;
#line 1770 "test-new/nrimp10s-77.imp"
goto L_0164;
#line 1770 "test-new/nrimp10s-77.imp"
L_0163:;
#line 1770 "test-new/nrimp10s-77.imp"
KPP = 2;
#line 1770 "test-new/nrimp10s-77.imp"
L_0164:;
// 1771 PF1(OPCODE,K>>1<<1,KPP,N)
#line 1771 "test-new/nrimp10s-77.imp"
PF1(OPCODE, (unsigned int)K >> 1 << 1, KPP, N);
// 1772 %FINISH
#line 1772 "test-new/nrimp10s-77.imp"
L_0162:;
// 1773 %END
#line 1773 "test-new/nrimp10s-77.imp"
return;
#line 1773 "test-new/nrimp10s-77.imp"
} /* end of PSF1 */
// 1774 %ROUTINE PF1(%INTEGER OPCODE,KP,KPP,N)
#line 1774 "test-new/nrimp10s-77.imp"
void PF1(int OPCODE, int KP, int KPP, int N) {
// 1775 !***********************************************************************
// 1776 !* PLANT THE NORMAL FORMS OF PRIMARY FORMAT INSTRNS(IE THOSE *
// 1777 !* WHICH DO NOT DEPEND ON THE SIZE OF N) *
// 1778 !***********************************************************************
// 1779 %INTEGER INC
#line 1779 "test-new/nrimp10s-77.imp"
int INC;
// 1780 ! ABORT %UNLESS 0<=KP<=3 %AND 0<=KPP<=7 %AND OPCODE&1=0
// 1781 INC=2
#line 1781 "test-new/nrimp10s-77.imp"
INC = 2;
// 1782 %IF KPP=PC %THEN %START
#line 1782 "test-new/nrimp10s-77.imp"
if (KPP != 4) goto L_0165;
// 1783 %IF N<0 %THEN N=N&16_7FFFFFFF %AND NOTE CREF(CA,N)
#line 1783 "test-new/nrimp10s-77.imp"
if (N >= 0) goto L_0166;
#line 1783 "test-new/nrimp10s-77.imp"
N = N & 2147483647;
#line 1783 "test-new/nrimp10s-77.imp"
NOTECREF(CA, N);
#line 1783 "test-new/nrimp10s-77.imp"
L_0166:;
// 1784 N=(N-CA)//2
#line 1784 "test-new/nrimp10s-77.imp"
N = ((long)(N - CA) / (long)2);
// 1785 %FINISH
#line 1785 "test-new/nrimp10s-77.imp"
L_0165:;
// 1786 %IF (1<<KPP)&B'101100'#0 %THEN N=N//4
#line 1786 "test-new/nrimp10s-77.imp"
if (1 << KPP & 44 == 0) goto L_0167;
#line 1786 "test-new/nrimp10s-77.imp"
N = ((long)N / (long)4);
#line 1786 "test-new/nrimp10s-77.imp"
L_0167:;
// 1787 ! %IF USE IMP=YES %THEN %START
// 1788 CODE(PPCURR)=OPCODE!1
#line 1788 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = OPCODE | 1;
// 1789 CODE(PPCURR+1)=16_80!KP<<5!KPP<<2!(N>>16&3)
#line 1789 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = 128 | KP << 5 | KPP << 2 | (unsigned int)N >> 16 & 3;
// 1790 CODE(PPCURR+2)=N>>8&255
#line 1790 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 2] = (unsigned int)N >> 8 & 255;
// 1791 CODE(PPCURR+3)=N&255
#line 1791 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 3] = N & 255;
// 1792 ! %FINISH %ELSE %START
// 1793 ! *LSS_OPCODE
// 1794 ! *USH_1
// 1795 ! *OR_3
// 1796 ! *USH_2
// 1797 ! *OR_KP
// 1798 ! *USH_3
// 1799 ! *OR_KPP
// 1800 ! *USH_18
// 1801 ! *SLSS_N
// 1802 ! *AND_16_3FFFF
// 1803 ! *OR_%TOS
// 1804 ! *LDTB_16_58000004
// 1805 ! *LDA_CODE+4
// 1806 ! *LB_PPCURR
// 1807 ! *ST_(%DR+%B)
// 1808 ! %FINISH
// 1809 %IF KPP<=5 %THEN INC=4
#line 1809 "test-new/nrimp10s-77.imp"
if (KPP > 5) goto L_0168;
#line 1809 "test-new/nrimp10s-77.imp"
INC = 4;
#line 1809 "test-new/nrimp10s-77.imp"
L_0168:;
// 1810 PPCURR=PPCURR+INC
#line 1810 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + INC;
// 1811 CA=CA+INC
#line 1811 "test-new/nrimp10s-77.imp"
CA = CA + INC;
// 1812 CODEOUT %IF PPCURR>=256
#line 1812 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_0169;
#line 1812 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1812 "test-new/nrimp10s-77.imp"
L_0169:;
// 1813 %END
#line 1813 "test-new/nrimp10s-77.imp"
return;
#line 1813 "test-new/nrimp10s-77.imp"
} /* end of PF1 */
// 1814 %ROUTINE PSORLF1(%INTEGER OPCODE,KP,KPP,N)
#line 1814 "test-new/nrimp10s-77.imp"
void PSORLF1(int OPCODE, int KP, int KPP, int N) {
// 1815 !***********************************************************************
// 1816 !* AS PF1 BUT CUT VALID FORMS TO SHORT FORM *
// 1817 !***********************************************************************
// 1818 %INTEGER INC
#line 1818 "test-new/nrimp10s-77.imp"
int INC;
// 1819 INC=2
#line 1819 "test-new/nrimp10s-77.imp"
INC = 2;
// 1820 %IF (KPP=0=KP %AND -64<=N<=63) %OR (KPP=LNB %AND KP&1=0 %AND 0<=N<=511) %START
#line 1820 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 1820 "test-new/nrimp10s-77.imp"
int tmp;
#line 1820 "test-new/nrimp10s-77.imp"
if (KPP != (tmp = 0)) goto L_016A;
// Double-sided test on 0 (Part II)
#line 1820 "test-new/nrimp10s-77.imp"
if (tmp != KP) goto L_016A;
#line 1820 "test-new/nrimp10s-77.imp"
}
#line 1820 "test-new/nrimp10s-77.imp"
{
// Double-sided test on N (Part I)
#line 1820 "test-new/nrimp10s-77.imp"
int tmp;
#line 1820 "test-new/nrimp10s-77.imp"
if (-64 > (tmp = N)) goto L_016A;
// Double-sided test on N (Part II)
#line 1820 "test-new/nrimp10s-77.imp"
if (tmp <= 63) goto L_016B;
#line 1820 "test-new/nrimp10s-77.imp"
}
#line 1820 "test-new/nrimp10s-77.imp"
L_016A:;
#line 1820 "test-new/nrimp10s-77.imp"
if (KPP != 2) goto L_016C;
#line 1820 "test-new/nrimp10s-77.imp"
if (KP & 1 != 0) goto L_016C;
#line 1820 "test-new/nrimp10s-77.imp"
{
// Double-sided test on N (Part I)
#line 1820 "test-new/nrimp10s-77.imp"
int tmp;
#line 1820 "test-new/nrimp10s-77.imp"
if (0 > (tmp = N)) goto L_016C;
// Double-sided test on N (Part II)
#line 1820 "test-new/nrimp10s-77.imp"
if (tmp > 511) goto L_016C;
#line 1820 "test-new/nrimp10s-77.imp"
}
#line 1820 "test-new/nrimp10s-77.imp"
L_016B:;
// 1821 %IF KPP=LNB %THEN KP=1+KP>>1
#line 1821 "test-new/nrimp10s-77.imp"
if (KPP != 2) goto L_016D;
#line 1821 "test-new/nrimp10s-77.imp"
KP = 1 + ((unsigned int)KP >> 1);
#line 1821 "test-new/nrimp10s-77.imp"
L_016D:;
// 1822 %IF KP#0 %THEN N=N//4
#line 1822 "test-new/nrimp10s-77.imp"
if (KP == 0) goto L_016E;
#line 1822 "test-new/nrimp10s-77.imp"
N = ((long)N / (long)4);
#line 1822 "test-new/nrimp10s-77.imp"
L_016E:;
// 1823 ! %IF USE IMP=YES %THEN %START
// 1824 CODE(PPCURR)=OPCODE!KP>>1
#line 1824 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = OPCODE | (unsigned int)KP >> 1;
// 1825 CODE(PPCURR+1)=(KP&1)<<7!(N&127)
#line 1825 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = (KP & 1) << 7 | N & 127;
// 1826 ! %FINISH %ELSE %START
// 1827 ! *LSS_OPCODE
// 1828 ! *USH_1
// 1829 ! *OR_KP
// 1830 ! *USH_7
// 1831 ! *SLSS_N
// 1832 ! *AND_127
// 1833 ! *LB_PPCURR
// 1834 ! *OR_%TOS
// 1835 ! *LDA_CODE+4
// 1836 ! *LDTB_16_58000002
// 1837 ! *ST_(%DR+%B)
// 1838 ! %FINISH
// 1839 %FINISH %ELSE %START
#line 1839 "test-new/nrimp10s-77.imp"
goto L_016F;
#line 1839 "test-new/nrimp10s-77.imp"
L_016C:;
// 1840 %IF KPP=PC %THEN %START
#line 1840 "test-new/nrimp10s-77.imp"
if (KPP != 4) goto L_0170;
// 1841 %IF N<0 %THEN N=N&16_7FFFFFFF %AND NOTE CREF(CA,N)
#line 1841 "test-new/nrimp10s-77.imp"
if (N >= 0) goto L_0171;
#line 1841 "test-new/nrimp10s-77.imp"
N = N & 2147483647;
#line 1841 "test-new/nrimp10s-77.imp"
NOTECREF(CA, N);
#line 1841 "test-new/nrimp10s-77.imp"
L_0171:;
// 1842 N=(N-CA)//2
#line 1842 "test-new/nrimp10s-77.imp"
N = ((long)(N - CA) / (long)2);
// 1843 %FINISH
#line 1843 "test-new/nrimp10s-77.imp"
L_0170:;
// 1844 %IF (1<<KPP)&B'101100'#0 %THEN N=N//4
#line 1844 "test-new/nrimp10s-77.imp"
if (1 << KPP & 44 == 0) goto L_0172;
#line 1844 "test-new/nrimp10s-77.imp"
N = ((long)N / (long)4);
#line 1844 "test-new/nrimp10s-77.imp"
L_0172:;
// 1845 ! %IF USE IMP=YES %THEN %START
// 1846 CODE(PPCURR)=OPCODE!1
#line 1846 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = OPCODE | 1;
// 1847 CODE(PPCURR+1)=((4!KP)<<3!KPP)<<2!(N>>16&3)
#line 1847 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = ((4 | KP) << 3 | KPP) << 2 | (unsigned int)N >> 16 & 3;
// 1848 CODE(PPCURR+2)=N>>8&255
#line 1848 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 2] = (unsigned int)N >> 8 & 255;
// 1849 CODE(PPCURR+3)=N&255
#line 1849 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 3] = N & 255;
// 1850 ! %FINISH %ELSE %START
// 1851 ! *LSS_OPCODE
// 1852 ! *USH_1
// 1853 ! *OR_3
// 1854 ! *USH_2
// 1855 ! *OR_KP
// 1856 ! *USH_3
// 1857 ! *OR_KPP
// 1858 ! *USH_18
// 1859 ! *SLSS_N
// 1860 ! *AND_16_3FFFF
// 1861 ! *OR_%TOS
// 1862 ! *LDTB_16_58000004
// 1863 ! *LDA_CODE+4
// 1864 ! *LB_PPCURR
// 1865 ! *ST_(%DR+%B)
// 1866 ! %FINISH
// 1867 %IF KPP<=5 %THEN INC=4
#line 1867 "test-new/nrimp10s-77.imp"
if (KPP > 5) goto L_0173;
#line 1867 "test-new/nrimp10s-77.imp"
INC = 4;
#line 1867 "test-new/nrimp10s-77.imp"
L_0173:;
// 1868 %FINISH
#line 1868 "test-new/nrimp10s-77.imp"
L_016F:;
// 1869 CA=CA+INC; PPCURR=PPCURR+INC
#line 1869 "test-new/nrimp10s-77.imp"
CA = CA + INC;
#line 1869 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + INC;
// 1870 CODEOUT %IF PPCURR>=256
#line 1870 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_0174;
#line 1870 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1870 "test-new/nrimp10s-77.imp"
L_0174:;
// 1871 %END
#line 1871 "test-new/nrimp10s-77.imp"
return;
#line 1871 "test-new/nrimp10s-77.imp"
} /* end of PSORLF1 */
// 1872 %ROUTINE PF2(%INTEGER OPCODE,H,Q,N,MASK,FILLER)
#line 1872 "test-new/nrimp10s-77.imp"
void PF2(int OPCODE, int H, int Q, int N, int MASK, int FILLER) {
// 1873 !***********************************************************************
// 1874 !* PLANT SECONDARY(STORE TO STORE) FORMAT INSTRNS *
// 1875 !* THESE MAY BE 16 OR 32 BIT DEPENDING ON Q *
// 1876 !***********************************************************************
// 1877 ! ABORT %UNLESS 0<=H<=1 %AND 0<=Q<=1 %AND 0<=N<=127 %AND OPCODE&1=0
// 1878 PLANT(OPCODE<<8!H<<8!Q<<7!N)
#line 1878 "test-new/nrimp10s-77.imp"
PLANT(OPCODE << 8 | H << 8 | Q << 7 | N);
// 1879 %IF Q#0 %THEN PLANT(MASK<<8!FILLER)
#line 1879 "test-new/nrimp10s-77.imp"
if (Q == 0) goto L_0175;
#line 1879 "test-new/nrimp10s-77.imp"
PLANT(MASK << 8 | FILLER);
#line 1879 "test-new/nrimp10s-77.imp"
L_0175:;
// 1880 %END
#line 1880 "test-new/nrimp10s-77.imp"
return;
#line 1880 "test-new/nrimp10s-77.imp"
} /* end of PF2 */
// 1881 %ROUTINE PF3(%INTEGER OPCODE,MASK,KPPP,N)
#line 1881 "test-new/nrimp10s-77.imp"
void PF3(int OPCODE, int MASK, int KPPP, int N) {
// 1882 !***********************************************************************
// 1883 !* PLANT THE TERTIARY(JUMP) FORMAT INSTRUCTIONS *
// 1884 !***********************************************************************
// 1885 ! ABORT %UNLESS 0<=MASK<=15 %AND 0<=KPPP<=7 %AND OPCODE&1=0
// 1886 %IF KPPP=PC %THEN %START
#line 1886 "test-new/nrimp10s-77.imp"
if (KPPP != 4) goto L_0176;
// 1887 %IF N<0 %THEN N=N&16_7FFFFFFF %AND NOTE CREF(CA,N)
#line 1887 "test-new/nrimp10s-77.imp"
if (N >= 0) goto L_0177;
#line 1887 "test-new/nrimp10s-77.imp"
N = N & 2147483647;
#line 1887 "test-new/nrimp10s-77.imp"
NOTECREF(CA, N);
#line 1887 "test-new/nrimp10s-77.imp"
L_0177:;
// 1888 N=(N-CA)//2
#line 1888 "test-new/nrimp10s-77.imp"
N = ((long)(N - CA) / (long)2);
// 1889 %FINISH
#line 1889 "test-new/nrimp10s-77.imp"
L_0176:;
// 1890 CODE(PPCURR)=OPCODE!MASK>>3&1
#line 1890 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = OPCODE | (unsigned int)MASK >> 3 & 1;
// 1891 CODE(PPCURR+1)=(MASK&7)<<5!KPPP<<2!(N>>16&3)
#line 1891 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = (MASK & 7) << 5 | KPPP << 2 | (unsigned int)N >> 16 & 3;
// 1892 PPCURR=PPCURR+2
#line 1892 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + 2;
// 1893 CA=CA+2
#line 1893 "test-new/nrimp10s-77.imp"
CA = CA + 2;
// 1894 %IF KPPP<=5 %THEN %START
#line 1894 "test-new/nrimp10s-77.imp"
if (KPPP > 5) goto L_0178;
// 1895 CODE(PPCURR)=N>>8&255
#line 1895 "test-new/nrimp10s-77.imp"
CODE[PPCURR] = (unsigned int)N >> 8 & 255;
// 1896 CODE(PPCURR+1)=N&255
#line 1896 "test-new/nrimp10s-77.imp"
CODE[PPCURR + 1] = N & 255;
// 1897 PPCURR=PPCURR+2; CA=CA+2
#line 1897 "test-new/nrimp10s-77.imp"
PPCURR = PPCURR + 2;
#line 1897 "test-new/nrimp10s-77.imp"
CA = CA + 2;
// 1898 %FINISH
#line 1898 "test-new/nrimp10s-77.imp"
L_0178:;
// 1899 CODEOUT %IF PPCURR>=256
#line 1899 "test-new/nrimp10s-77.imp"
if (PPCURR < 256) goto L_0179;
#line 1899 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1899 "test-new/nrimp10s-77.imp"
L_0179:;
// 1900 %END
#line 1900 "test-new/nrimp10s-77.imp"
return;
#line 1900 "test-new/nrimp10s-77.imp"
} /* end of PF3 */
// 1901 %ROUTINE NOTE CREF(%INTEGER CA,N)
#line 1901 "test-new/nrimp10s-77.imp"
void NOTECREF(int CA, int N) {
// 1902 !***********************************************************************
// 1903 !* NOTE THAT A (PC+N) INSTRUCTION HAS N RELATIVE TO CONST TABLE *
// 1904 !* NOT REATIVE TO CODE. REMEMBER THE ADDRESS OF THE INSTRUCTION *
// 1905 !* SO THAT AN LPUT(18) CORRECTION CAN BE MADE AT END OF COMPILATION *
// 1906 !***********************************************************************
// 1907 %RECORD(LISTF)%NAME CELL {(LISTF)
#line 1907 "test-new/nrimp10s-77.imp"
struct LISTF *CELL;
// 1908 CELL==ASLIST(CREFHEAD)
#line 1908 "test-new/nrimp10s-77.imp"
CELL = (struct LISTF *)/*?*/ &ASLIST[CREFHEAD];
// 1909 %IF CREFHEAD=0 %OR CELL_S3#0 %THEN PUSH(CREFHEAD,CA,0,0) %AND %RETURN
#line 1909 "test-new/nrimp10s-77.imp"
if (CREFHEAD == 0) goto L_017A;
#line 1909 "test-new/nrimp10s-77.imp"
if (CELL->S3 == 0) goto L_017B;
#line 1909 "test-new/nrimp10s-77.imp"
L_017A:;
#line 1909 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &CREFHEAD, CA, 0, 0);
#line 1909 "test-new/nrimp10s-77.imp"
return;
#line 1909 "test-new/nrimp10s-77.imp"
L_017B:;
// 1910 %IF CELL_S2=0 %THEN CELL_S2=CA %ELSE CELL_S3=CA
#line 1910 "test-new/nrimp10s-77.imp"
if (CELL->S2 != 0) goto L_017C;
#line 1910 "test-new/nrimp10s-77.imp"
CELL->S2 = CA;
#line 1910 "test-new/nrimp10s-77.imp"
goto L_017D;
#line 1910 "test-new/nrimp10s-77.imp"
L_017C:;
#line 1910 "test-new/nrimp10s-77.imp"
CELL->S3 = CA;
#line 1910 "test-new/nrimp10s-77.imp"
L_017D:;
// 1911 %END
#line 1911 "test-new/nrimp10s-77.imp"
return;
#line 1911 "test-new/nrimp10s-77.imp"
} /* end of NOTECREF */
// ?N unused
// 1912 %ROUTINE PCLOD(%INTEGER FROM, TO)
#line 1912 "test-new/nrimp10s-77.imp"
void PCLOD(int FROM, int TO) {
// 1913 !***********************************************************************
// 1914 !* PLANT A SERIES OF INTRUNS FROM ARRAY FIXED CODE *
// 1915 !***********************************************************************
// 1916 %INTEGER I
#line 1916 "test-new/nrimp10s-77.imp"
int I;
// 1917 !%CONSTINTEGERARRAY FIXED CODE(0:127)
// 1918 ! %CYCLE I=FROM, 1, TO
// 1919 ! PCONST(FIXED CODE(I))
// 1920 ! %REPEAT
// 1921 %END
#line 1921 "test-new/nrimp10s-77.imp"
return;
#line 1921 "test-new/nrimp10s-77.imp"
} /* end of PCLOD */
// ?I unused
// ?TO unused
// ?FROM unused
// 1922 %ROUTINE CNOP(%INTEGER I, J)
#line 1922 "test-new/nrimp10s-77.imp"
void CNOP(int I, int J) {
// 1923 PSF1(JUNC,0,1) %WHILE CA&(J-1)#I
#line 1923 "test-new/nrimp10s-77.imp"
L_017E:;
#line 1923 "test-new/nrimp10s-77.imp"
if (CA & J - 1 == I) goto L_017F;
#line 1923 "test-new/nrimp10s-77.imp"
PSF1(26, 0, 1);
#line 1923 "test-new/nrimp10s-77.imp"
goto L_017E;
#line 1923 "test-new/nrimp10s-77.imp"
L_017F:;
// 1924 %END
#line 1924 "test-new/nrimp10s-77.imp"
return;
#line 1924 "test-new/nrimp10s-77.imp"
} /* end of CNOP */
// 1925 %ROUTINE PGLA(%INTEGER BDRY, L, INF ADR)
#line 1925 "test-new/nrimp10s-77.imp"
void PGLA(int BDRY, int L, int INFADR) {
// 1926 %INTEGER I, J
#line 1926 "test-new/nrimp10s-77.imp"
int I;
#line 1926 "test-new/nrimp10s-77.imp"
int J;
// 1927 J=GLACA; GLACA=(J+BDRY-1)&(-BDRY)
#line 1927 "test-new/nrimp10s-77.imp"
J = GLACA;
#line 1927 "test-new/nrimp10s-77.imp"
GLACA = J + BDRY - 1 & -BDRY;
// 1928 GLACURR=GLACURR+GLACA-J; ! COMPLETE THE ROUNDING
#line 1928 "test-new/nrimp10s-77.imp"
GLACURR = GLACURR + GLACA - J;
// 1929 %IF L+GLACURR>256 %THEN %START
#line 1929 "test-new/nrimp10s-77.imp"
if (L + GLACURR <= 256) goto L_0180;
// 1930 %IF INHCODE=0 %THEN LPUT(2, GLACURR, GLACABUF, ADDR(GLABUF(0)))
#line 1930 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0181;
#line 1930 "test-new/nrimp10s-77.imp"
LPUT(2, GLACURR, GLACABUF, _imp_ADDR(/*?*/ &GLABUF[0]));
#line 1930 "test-new/nrimp10s-77.imp"
L_0181:;
// 1931 GLACURR=0; GLACABUF=GLACA
#line 1931 "test-new/nrimp10s-77.imp"
GLACURR = 0;
#line 1931 "test-new/nrimp10s-77.imp"
GLACABUF = GLACA;
// 1932 %FINISH
#line 1932 "test-new/nrimp10s-77.imp"
L_0180:;
// 1933 %CYCLE I=0,1,L-1
#line 1933 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, L - 1 %cycle
#line 1933 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = L - 1;
#line 1933 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, L - 1");
_control = I = _initial - _increment;
#line 1933 "test-new/nrimp10s-77.imp"
L_0182:
#line 1933 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1933 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0183;
#line 1933 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 1934 GLABUF(GLACURR+I)=BYTE INTEGER(I+INF ADR)
#line 1934 "test-new/nrimp10s-77.imp"
GLABUF[GLACURR + I] = *_imp_BYTEINTEGER(I + INFADR);
// 1935 %REPEAT
#line 1935 "test-new/nrimp10s-77.imp"
goto L_0182;
#line 1935 "test-new/nrimp10s-77.imp"
}
#line 1935 "test-new/nrimp10s-77.imp"
L_0183:;
// 1936 GLACA=GLACA+L; GLACURR=GLACURR+L
#line 1936 "test-new/nrimp10s-77.imp"
GLACA = GLACA + L;
#line 1936 "test-new/nrimp10s-77.imp"
GLACURR = GLACURR + L;
// 1937 %END
#line 1937 "test-new/nrimp10s-77.imp"
return;
#line 1937 "test-new/nrimp10s-77.imp"
} /* end of PGLA */
// 1938 %ROUTINE PLUG(%INTEGER AREA, AT, VALUE, BYTES)
#line 1938 "test-new/nrimp10s-77.imp"
void PLUG(int AREA, int AT, int VALUE, int BYTES) {
// 1939 !***********************************************************************
// 1940 !* WRITE UP TO ONE WORD INTO OBJECT FILE OUT OF SEQUENCE *
// 1941 !***********************************************************************
// 1942 %INTEGERNAME WCABUF
#line 1942 "test-new/nrimp10s-77.imp"
int *WCABUF;
// 1943 %INTEGER I, RELAD, BUFAD
#line 1943 "test-new/nrimp10s-77.imp"
int I;
#line 1943 "test-new/nrimp10s-77.imp"
int RELAD;
#line 1943 "test-new/nrimp10s-77.imp"
int BUFAD;
// 1944 WCABUF==CABUF; BUFAD=ADDR(CODE(0))
#line 1944 "test-new/nrimp10s-77.imp"
WCABUF = (int *)/*?*/ &CABUF;
#line 1944 "test-new/nrimp10s-77.imp"
BUFAD = _imp_ADDR(/*?*/ &CODE[0]);
// 1945 %IF AREA=2 %THEN WCABUF==GLACABUF %AND BUFAD=ADDR(GLABUF(0))
#line 1945 "test-new/nrimp10s-77.imp"
if (AREA != 2) goto L_0185;
#line 1945 "test-new/nrimp10s-77.imp"
WCABUF = (int *)/*?*/ &GLACABUF;
#line 1945 "test-new/nrimp10s-77.imp"
BUFAD = _imp_ADDR(/*?*/ &GLABUF[0]);
#line 1945 "test-new/nrimp10s-77.imp"
L_0185:;
// 1946 RELAD=AT-WCABUF
#line 1946 "test-new/nrimp10s-77.imp"
RELAD = AT - *WCABUF;
// 1947 %IF 0<=RELAD<=256 %AND AREA<=3 %THEN %START
#line 1947 "test-new/nrimp10s-77.imp"
{
// Double-sided test on RELAD (Part I)
#line 1947 "test-new/nrimp10s-77.imp"
int tmp;
#line 1947 "test-new/nrimp10s-77.imp"
if (0 > (tmp = RELAD)) goto L_0186;
// Double-sided test on RELAD (Part II)
#line 1947 "test-new/nrimp10s-77.imp"
if (tmp > 256) goto L_0186;
#line 1947 "test-new/nrimp10s-77.imp"
}
#line 1947 "test-new/nrimp10s-77.imp"
if (AREA > 3) goto L_0186;
// 1948 %CYCLE I=0,1,BYTES-1
#line 1948 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, BYTES - 1 %cycle
#line 1948 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = BYTES - 1;
#line 1948 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, BYTES - 1");
_control = I = _initial - _increment;
#line 1948 "test-new/nrimp10s-77.imp"
L_0187:
#line 1948 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 1948 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0188;
#line 1948 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 1949 BYTEINTEGER(RELAD+BUFAD+I)<-VALUE>>((BYTES-1-I)<<3)
#line 1949 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(RELAD + BUFAD + I) = (unsigned char)((unsigned int)VALUE >> (BYTES - 1 - I << 3));
// 1950 %REPEAT
#line 1950 "test-new/nrimp10s-77.imp"
goto L_0187;
#line 1950 "test-new/nrimp10s-77.imp"
}
#line 1950 "test-new/nrimp10s-77.imp"
L_0188:;
// 1951 %FINISH %ELSE %START
#line 1951 "test-new/nrimp10s-77.imp"
goto L_0189;
#line 1951 "test-new/nrimp10s-77.imp"
L_0186:;
// 1952 %IF RELAD=-2 %THEN CODEOUT
#line 1952 "test-new/nrimp10s-77.imp"
if (RELAD != -2) goto L_018A;
#line 1952 "test-new/nrimp10s-77.imp"
CODEOUT();
#line 1952 "test-new/nrimp10s-77.imp"
L_018A:;
// 1953 %IF INHCODE=0 %THEN LPUT(AREA,BYTES,AT,ADDR(VALUE)+4-BYTES)
#line 1953 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_018B;
#line 1953 "test-new/nrimp10s-77.imp"
LPUT(AREA, BYTES, AT, _imp_ADDR(/*?*/ &VALUE) + 4 - BYTES);
#line 1953 "test-new/nrimp10s-77.imp"
L_018B:;
// 1954 !*DELSTART
// 1955 NCODE(ADDR(VALUE)+4-BYTES,ADDR(VALUE)+4,AT) %IF DCOMP=1=AREA
#line 1955 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 1 (Part I)
#line 1955 "test-new/nrimp10s-77.imp"
int tmp;
#line 1955 "test-new/nrimp10s-77.imp"
if (DCOMP != (tmp = 1)) goto L_018C;
// Double-sided test on 1 (Part II)
#line 1955 "test-new/nrimp10s-77.imp"
if (tmp != AREA) goto L_018C;
#line 1955 "test-new/nrimp10s-77.imp"
}
#line 1955 "test-new/nrimp10s-77.imp"
NCODE(_imp_ADDR(/*?*/ &VALUE) + 4 - BYTES, _imp_ADDR(/*?*/ &VALUE) + 4, AT);
#line 1955 "test-new/nrimp10s-77.imp"
L_018C:;
// 1956 !*DELEND
// 1957 %FINISH
#line 1957 "test-new/nrimp10s-77.imp"
L_0189:;
// 1958 %END
#line 1958 "test-new/nrimp10s-77.imp"
return;
#line 1958 "test-new/nrimp10s-77.imp"
} /* end of PLUG */
// 1959
// 1960 %INTEGERFN PARAM DES(%INTEGER PREC)
#line 1960 "test-new/nrimp10s-77.imp"
int PARAMDES(int PREC) {
// 1961 !***********************************************************************
// 1962 !* SET UP BNDED L=1 DESRIPTOR FOR PASSING VARIABLE BY REFERENCE *
// 1963 !* ONLY THE TOP HALF IS SET UP *
// 1964 !***********************************************************************
// 1965 %INTEGER K,DES
#line 1965 "test-new/nrimp10s-77.imp"
int K;
#line 1965 "test-new/nrimp10s-77.imp"
int DES;
// 1966 K=DESADS(PREC)
#line 1966 "test-new/nrimp10s-77.imp"
K = DESADS[PREC];
// 1967 %RESULT=K %UNLESS K=0
#line 1967 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_018D;
#line 1967 "test-new/nrimp10s-77.imp"
return K;
#line 1967 "test-new/nrimp10s-77.imp"
L_018D:;
// 1968 %IF PREC=4 %THEN DES=16_58000002 %ELSE DES=PREC<<27!1
#line 1968 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_018E;
#line 1968 "test-new/nrimp10s-77.imp"
DES = 1476395010;
#line 1968 "test-new/nrimp10s-77.imp"
goto L_018F;
#line 1968 "test-new/nrimp10s-77.imp"
L_018E:;
#line 1968 "test-new/nrimp10s-77.imp"
DES = PREC << 27 | 1;
#line 1968 "test-new/nrimp10s-77.imp"
L_018F:;
// 1969 STORE CONST (K,4,ADDR(DES))
#line 1969 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &K, 4, _imp_ADDR(/*?*/ &DES));
// 1970 DESADS(PREC)=K
#line 1970 "test-new/nrimp10s-77.imp"
DESADS[PREC] = K;
// 1971 %RESULT=K
#line 1971 "test-new/nrimp10s-77.imp"
return K;
// 1972 %END
#line 1972 "test-new/nrimp10s-77.imp"
} /* end of PARAMDES */
// 1973 %INTEGERFN MAPDES(%INTEGER PREC)
#line 1973 "test-new/nrimp10s-77.imp"
int MAPDES(int PREC) {
// 1974 !***********************************************************************
// 1975 !* SET UP 8BIT ZERO ADDRESS UNSCALED BCI DESCRTR FOR MAPPING *
// 1976 !***********************************************************************
// 1977 %INTEGER K,DES0,DES1
#line 1977 "test-new/nrimp10s-77.imp"
int K;
#line 1977 "test-new/nrimp10s-77.imp"
int DES0;
#line 1977 "test-new/nrimp10s-77.imp"
int DES1;
// 1978 K=DESADS(PREC+8)
#line 1978 "test-new/nrimp10s-77.imp"
K = DESADS[PREC + 8];
// 1979 %RESULT=K %UNLESS K=0
#line 1979 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_0190;
#line 1979 "test-new/nrimp10s-77.imp"
return K;
#line 1979 "test-new/nrimp10s-77.imp"
L_0190:;
// 1980 %IF PREC=4 %THEN DES0=16_58000002 %ELSE DES0=16_03000000!PREC<<27
#line 1980 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_0191;
#line 1980 "test-new/nrimp10s-77.imp"
DES0 = 1476395010;
#line 1980 "test-new/nrimp10s-77.imp"
goto L_0192;
#line 1980 "test-new/nrimp10s-77.imp"
L_0191:;
#line 1980 "test-new/nrimp10s-77.imp"
DES0 = 50331648 | PREC << 27;
#line 1980 "test-new/nrimp10s-77.imp"
L_0192:;
// 1981 DES1=0; STORE CONST(K,8,ADDR(DES0))
#line 1981 "test-new/nrimp10s-77.imp"
DES1 = 0;
#line 1981 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &K, 8, _imp_ADDR(/*?*/ &DES0));
// 1982 DESADS(PREC+8)=K
#line 1982 "test-new/nrimp10s-77.imp"
DESADS[PREC + 8] = K;
// 1983 %RESULT=K
#line 1983 "test-new/nrimp10s-77.imp"
return K;
// 1984 %END
#line 1984 "test-new/nrimp10s-77.imp"
} /* end of MAPDES */
// 1985 %INTEGERFN SPECIAL CONSTS(%INTEGER WHICH)
#line 1985 "test-new/nrimp10s-77.imp"
int SPECIALCONSTS(int WHICH) {
// 1986 !***********************************************************************
// 1987 !* PUTS CERTAIN SPECIAL CONSTANTS INTO THE CONSTANT TABLE ON *
// 1988 !* DEMAND AND REMEMBERS THEIR POSN TO AVOID SEARCHONG *
// 1989 !***********************************************************************
// 1990 {%CONST}%ownINTEGERARRAY SCS(0:5) = 16_40800000,0,
#line 1990 "test-new/nrimp10s-77.imp"
static int SCS[6] = {1082130432, 0, 1091567616, 0, 1, 0};
// 1991+ 16_41100000,0,
// 1992+ 1,0;
// 1993 %INTEGER K
#line 1993 "test-new/nrimp10s-77.imp"
int K;
// 1994 K=DESADS(WHICH+16)
#line 1994 "test-new/nrimp10s-77.imp"
K = DESADS[WHICH + 16];
// 1995 %RESULT=K %UNLESS K=0
#line 1995 "test-new/nrimp10s-77.imp"
if (K == 0) goto L_0193;
#line 1995 "test-new/nrimp10s-77.imp"
return K;
#line 1995 "test-new/nrimp10s-77.imp"
L_0193:;
// 1996 STORE CONST(K,8,ADDR(SCS(2*WHICH)))
#line 1996 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &K, 8, _imp_ADDR(/*?*/ &SCS[2 * WHICH]));
// 1997 DESADS(WHICH+16)=K
#line 1997 "test-new/nrimp10s-77.imp"
DESADS[WHICH + 16] = K;
// 1998 %RESULT=K
#line 1998 "test-new/nrimp10s-77.imp"
return K;
// 1999 %END
#line 1999 "test-new/nrimp10s-77.imp"
} /* end of SPECIALCONSTS */
// 2000 %ROUTINE STORE CONST(%INTEGERNAME D, %INTEGER L, AD)
#line 2000 "test-new/nrimp10s-77.imp"
void STORECONST(int *D, int L, int AD) {
// 2001 !***********************************************************************
// 2002 !* PUT THE CONSTANT VAL OF LENGTH 'L' INTO THE CONSTANT TABLE *
// 2003 !* A CHECK IS MADE TO SEE IF THE CONSTANT HAS ALREADY *
// 2004 !* BEEN INSERTED IN WHICH CASE THE OLD COPY IS REUSED *
// 2005 !***********************************************************************
// 2006 %INTEGER I, J, K, C1, C2, C3, C4, LP
#line 2006 "test-new/nrimp10s-77.imp"
int I;
#line 2006 "test-new/nrimp10s-77.imp"
int J;
#line 2006 "test-new/nrimp10s-77.imp"
int K;
#line 2006 "test-new/nrimp10s-77.imp"
int C1;
#line 2006 "test-new/nrimp10s-77.imp"
int C2;
#line 2006 "test-new/nrimp10s-77.imp"
int C3;
#line 2006 "test-new/nrimp10s-77.imp"
int C4;
#line 2006 "test-new/nrimp10s-77.imp"
int LP;
// 2007 LP=L//4; C2=0; C3=0; C4=0
#line 2007 "test-new/nrimp10s-77.imp"
LP = ((long)L / (long)4);
#line 2007 "test-new/nrimp10s-77.imp"
C2 = 0;
#line 2007 "test-new/nrimp10s-77.imp"
C3 = 0;
#line 2007 "test-new/nrimp10s-77.imp"
C4 = 0;
// 2008 %CYCLE I=0,1,L-1
#line 2008 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, L - 1 %cycle
#line 2008 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = L - 1;
#line 2008 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, L - 1");
_control = I = _initial - _increment;
#line 2008 "test-new/nrimp10s-77.imp"
L_0194:
#line 2008 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2008 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0195;
#line 2008 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2009 BYTEINTEGER(ADDR(C1)+I)=BYTEINTEGER(AD+I)
#line 2009 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &C1) + I) = *_imp_BYTEINTEGER(AD + I);
// 2010 %REPEAT
#line 2010 "test-new/nrimp10s-77.imp"
goto L_0194;
#line 2010 "test-new/nrimp10s-77.imp"
}
#line 2010 "test-new/nrimp10s-77.imp"
L_0195:;
// 2011 %IF PARMOPT#0 %THEN ->SKIP
#line 2011 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_0196;
#line 2011 "test-new/nrimp10s-77.imp"
goto U_1014;
#line 2011 "test-new/nrimp10s-77.imp"
L_0196:;
// 2012 K=CONST BTM; ! AFTER STRINGS IN CTABLE
#line 2012 "test-new/nrimp10s-77.imp"
K = CONSTBTM;
// 2013 %IF L=4 %THEN %START
#line 2013 "test-new/nrimp10s-77.imp"
if (L != 4) goto L_0197;
// 2014 ! %IF USE IMP=YES %THEN %START
// 2015 %WHILE K<CONST PTR %CYCLE
#line 2015 "test-new/nrimp10s-77.imp"
L_0198:;
#line 2015 "test-new/nrimp10s-77.imp"
if (K >= CONSTPTR) goto L_0199;
// 2016 %IF CTABLE_val(K)=C1 %AND CONSTHOLE#K %THEN D=4*K!16_80000000 %AND %RETURN
#line 2016 "test-new/nrimp10s-77.imp"
if (CTABLE->VAL[K] != C1) goto L_019A;
#line 2016 "test-new/nrimp10s-77.imp"
if (CONSTHOLE == K) goto L_019A;
#line 2016 "test-new/nrimp10s-77.imp"
*D = 4 * K | -2147483648;
#line 2016 "test-new/nrimp10s-77.imp"
return;
#line 2016 "test-new/nrimp10s-77.imp"
L_019A:;
// 2017 K=K+1
#line 2017 "test-new/nrimp10s-77.imp"
K = K + 1;
// 2018 %REPEAT
#line 2018 "test-new/nrimp10s-77.imp"
goto L_0198;
#line 2018 "test-new/nrimp10s-77.imp"
L_0199:;
// 2019 ! %FINISH %ELSE %START
// 2020 ! *LD_CTABLE
// 2021 ! *LB_K
// 2022 ! *SBB_1
// 2023 ! *LSS_C1
// 2024 !AGN1:
// 2025 ! *ADB_1
// 2026 ! *CPB_CONSTPTR
// 2027 ! *JCC_10,<SKIP>
// 2028 ! *ICP_(%DR+%B)
// 2029 ! *JCC_7,<AGN1>
// 2030 ! *CPB_CONSTHOLE
// 2031 ! *JCC_8,<AGN1>
// 2032 ! *LSS_%B
// 2033 ! *IMY_4
// 2034 ! *OR_16_80000000
// 2035 ! *ST_(D)
// 2036 ! *EXIT_-64
// 2037 ! %FINISH
// 2038 %FINISH %ELSE %START
#line 2038 "test-new/nrimp10s-77.imp"
goto L_019B;
#line 2038 "test-new/nrimp10s-77.imp"
L_0197:;
// 2039 J=CONSTPTR-LP
#line 2039 "test-new/nrimp10s-77.imp"
J = CONSTPTR - LP;
// 2040 %WHILE K<=J %CYCLE
#line 2040 "test-new/nrimp10s-77.imp"
L_019C:;
#line 2040 "test-new/nrimp10s-77.imp"
if (K > J) goto L_019D;
// 2041 %IF CTABLE_val(K)=C1 %AND CTABLE_val(K+1)=C2 %AND (CONSTHOLE<K %OR CONSTHOLE>=K+LP) %START
#line 2041 "test-new/nrimp10s-77.imp"
if (CTABLE->VAL[K] != C1) goto L_019E;
#line 2041 "test-new/nrimp10s-77.imp"
if (CTABLE->VAL[K + 1] != C2) goto L_019E;
#line 2041 "test-new/nrimp10s-77.imp"
if (CONSTHOLE < K) goto L_019F;
#line 2041 "test-new/nrimp10s-77.imp"
if (CONSTHOLE < K + LP) goto L_019E;
#line 2041 "test-new/nrimp10s-77.imp"
L_019F:;
// 2042 %IF L=8 %OR (CTABLE_val(K+2)=C3 %AND CTABLE_val(K+3)=C4) %THEN D=4*K!16_80000000 %AND %RETURN
#line 2042 "test-new/nrimp10s-77.imp"
if (L == 8) goto L_01A0;
#line 2042 "test-new/nrimp10s-77.imp"
if (CTABLE->VAL[K + 2] != C3) goto L_01A1;
#line 2042 "test-new/nrimp10s-77.imp"
if (CTABLE->VAL[K + 3] != C4) goto L_01A1;
#line 2042 "test-new/nrimp10s-77.imp"
L_01A0:;
#line 2042 "test-new/nrimp10s-77.imp"
*D = 4 * K | -2147483648;
#line 2042 "test-new/nrimp10s-77.imp"
return;
#line 2042 "test-new/nrimp10s-77.imp"
L_01A1:;
// 2043 %FINISH
#line 2043 "test-new/nrimp10s-77.imp"
L_019E:;
// 2044 K=K+2
#line 2044 "test-new/nrimp10s-77.imp"
K = K + 2;
// 2045 %REPEAT
#line 2045 "test-new/nrimp10s-77.imp"
goto L_019C;
#line 2045 "test-new/nrimp10s-77.imp"
L_019D:;
// 2046 %FINISH
#line 2046 "test-new/nrimp10s-77.imp"
L_019B:;
// 2047 SKIP:
#line 2047 "test-new/nrimp10s-77.imp"
U_1014:;
// 2048 %IF L=4 %AND CONSTHOLE#0 %START
#line 2048 "test-new/nrimp10s-77.imp"
if (L != 4) goto L_01A2;
#line 2048 "test-new/nrimp10s-77.imp"
if (CONSTHOLE == 0) goto L_01A2;
// 2049 CTABLE_val(CONSTHOLE)=C1
#line 2049 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTHOLE] = C1;
// 2050 D=4*CONSTHOLE!16_80000000
#line 2050 "test-new/nrimp10s-77.imp"
*D = 4 * CONSTHOLE | -2147483648;
// 2051 CONSTHOLE=0
#line 2051 "test-new/nrimp10s-77.imp"
CONSTHOLE = 0;
// 2052 %RETURN
#line 2052 "test-new/nrimp10s-77.imp"
return;
// 2053 %FINISH
#line 2053 "test-new/nrimp10s-77.imp"
L_01A2:;
// 2054 %IF L>4 %AND CONST PTR&1#0 %THEN CONSTHOLE=CONST PTR %AND CONSTPTR=CONST PTR+1
#line 2054 "test-new/nrimp10s-77.imp"
if (L <= 4) goto L_01A3;
#line 2054 "test-new/nrimp10s-77.imp"
if (CONSTPTR & 1 == 0) goto L_01A3;
#line 2054 "test-new/nrimp10s-77.imp"
CONSTHOLE = CONSTPTR;
#line 2054 "test-new/nrimp10s-77.imp"
CONSTPTR = CONSTPTR + 1;
#line 2054 "test-new/nrimp10s-77.imp"
L_01A3:;
// 2055 D=4*CONST PTR!16_80000000
#line 2055 "test-new/nrimp10s-77.imp"
*D = 4 * CONSTPTR | -2147483648;
// 2056 CTABLE_val(CONSTPTR)=C1
#line 2056 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR] = C1;
// 2057 CTABLE_val(CONSTPTR+1)=C2
#line 2057 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR + 1] = C2;
// 2058 %IF L=16 %THEN CTABLE_val(CONSTPTR+2)=C3 %AND CTABLE_val(CONSTPTR+3)=C4
#line 2058 "test-new/nrimp10s-77.imp"
if (L != 16) goto L_01A4;
#line 2058 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR + 2] = C3;
#line 2058 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR + 3] = C4;
#line 2058 "test-new/nrimp10s-77.imp"
L_01A4:;
// 2059 CONST PTR=CONST PTR+LP
#line 2059 "test-new/nrimp10s-77.imp"
CONSTPTR = CONSTPTR + LP;
// 2060 %IF CONST PTR>CONST LIMIT %THEN FAULT(107,0)
#line 2060 "test-new/nrimp10s-77.imp"
if (CONSTPTR <= CONSTLIMIT) goto L_01A5;
#line 2060 "test-new/nrimp10s-77.imp"
FAULT(107, 0);
#line 2060 "test-new/nrimp10s-77.imp"
L_01A5:;
// 2061 %END
#line 2061 "test-new/nrimp10s-77.imp"
return;
#line 2061 "test-new/nrimp10s-77.imp"
} /* end of STORECONST */
// 2062 %ROUTINE GET ENV(%INTEGERNAME HEAD)
#line 2062 "test-new/nrimp10s-77.imp"
void GETENV(int *HEAD) {
// 2063 !***********************************************************************
// 2064 !* SAVE A COPY OF THE REGISTER STATE FOR FUTURE REFERENCE *
// 2065 !***********************************************************************
// 2066 %INTEGER I, USE
#line 2066 "test-new/nrimp10s-77.imp"
int I;
#line 2066 "test-new/nrimp10s-77.imp"
int USE;
// 2067 %CYCLE I=0, 1, 7
#line 2067 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 7 %cycle
#line 2067 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 7;
#line 2067 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 7");
_control = I = _initial - _increment;
#line 2067 "test-new/nrimp10s-77.imp"
L_01A6:
#line 2067 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2067 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01A7;
#line 2067 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2068 USE=GRUSE(I)&16_FF; ! MAIN USE ONLY
#line 2068 "test-new/nrimp10s-77.imp"
USE = GRUSE[I] & 255;
// 2069 PUSH(HEAD, GRINF1(I), GRAT(I), I<<8!USE) %IF USE#0
#line 2069 "test-new/nrimp10s-77.imp"
if (USE == 0) goto L_01A8;
#line 2069 "test-new/nrimp10s-77.imp"
PUSH(HEAD, GRINF1[I], GRAT[I], I << 8 | USE);
#line 2069 "test-new/nrimp10s-77.imp"
L_01A8:;
// 2070 %REPEAT
#line 2070 "test-new/nrimp10s-77.imp"
goto L_01A6;
#line 2070 "test-new/nrimp10s-77.imp"
}
#line 2070 "test-new/nrimp10s-77.imp"
L_01A7:;
// 2071 %END
#line 2071 "test-new/nrimp10s-77.imp"
return;
#line 2071 "test-new/nrimp10s-77.imp"
} /* end of GETENV */
// 2072 %ROUTINE RESTORE(%INTEGER HEAD)
#line 2072 "test-new/nrimp10s-77.imp"
void RESTORE(int HEAD) {
// 2073 !***********************************************************************
// 2074 !* RESET THE REGISTERS TO ENVIRONMENT IN LIST HEADED BY 'HEAD' *
// 2075 !***********************************************************************
// 2076 %INTEGER I, R, USE, INF, AT
#line 2076 "test-new/nrimp10s-77.imp"
int I;
#line 2076 "test-new/nrimp10s-77.imp"
int R;
#line 2076 "test-new/nrimp10s-77.imp"
int USE;
#line 2076 "test-new/nrimp10s-77.imp"
int INF;
#line 2076 "test-new/nrimp10s-77.imp"
int AT;
// 2077 %CYCLE I=0, 1, 7
#line 2077 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 7 %cycle
#line 2077 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 7;
#line 2077 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 7");
_control = I = _initial - _increment;
#line 2077 "test-new/nrimp10s-77.imp"
L_01A9:
#line 2077 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2077 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01AA;
#line 2077 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2078 %IF REGISTER(I)>=0 %THEN GRUSE(I)=0 %AND GRINF1(I)=0
#line 2078 "test-new/nrimp10s-77.imp"
if (REGISTER[I] < 0) goto L_01AB;
#line 2078 "test-new/nrimp10s-77.imp"
GRUSE[I] = 0;
#line 2078 "test-new/nrimp10s-77.imp"
GRINF1[I] = 0;
#line 2078 "test-new/nrimp10s-77.imp"
L_01AB:;
// 2079 %REPEAT
#line 2079 "test-new/nrimp10s-77.imp"
goto L_01A9;
#line 2079 "test-new/nrimp10s-77.imp"
}
#line 2079 "test-new/nrimp10s-77.imp"
L_01AA:;
// 2080 %WHILE HEAD#0 %CYCLE
#line 2080 "test-new/nrimp10s-77.imp"
L_01AC:;
#line 2080 "test-new/nrimp10s-77.imp"
if (HEAD == 0) goto L_01AD;
// 2081 POP(HEAD, INF, AT, I)
#line 2081 "test-new/nrimp10s-77.imp"
POP(/*?*/ &HEAD, /*?*/ &INF, /*?*/ &AT, /*?*/ &I);
// 2082 R=I>>8; USE=I&255
#line 2082 "test-new/nrimp10s-77.imp"
R = (unsigned int)I >> 8;
#line 2082 "test-new/nrimp10s-77.imp"
USE = I & 255;
// 2083 %IF REGISTER(R)>=0 %THEN GRUSE(R)=USE %AND GRINF1(R)=INF
#line 2083 "test-new/nrimp10s-77.imp"
if (REGISTER[R] < 0) goto L_01AE;
#line 2083 "test-new/nrimp10s-77.imp"
GRUSE[R] = USE;
#line 2083 "test-new/nrimp10s-77.imp"
GRINF1[R] = INF;
#line 2083 "test-new/nrimp10s-77.imp"
L_01AE:;
// 2084 GRAT(R)=AT
#line 2084 "test-new/nrimp10s-77.imp"
GRAT[R] = AT;
// 2085 %REPEAT
#line 2085 "test-new/nrimp10s-77.imp"
goto L_01AC;
#line 2085 "test-new/nrimp10s-77.imp"
L_01AD:;
// 2086 %END
#line 2086 "test-new/nrimp10s-77.imp"
return;
#line 2086 "test-new/nrimp10s-77.imp"
} /* end of RESTORE */
// 2087 %ROUTINE RELOCATE(%INTEGER GLARAD,VALUE,AREA)
#line 2087 "test-new/nrimp10s-77.imp"
void RELOCATE(int GLARAD, int VALUE, int AREA) {
// 2088 !***********************************************************************
// 2089 !* PLANTS A WORD IN THE GLA (IF GLARAD<0) AND ARRANGES TO *
// 2090 !* RELOCATE IT RELATIVE TO AN AREA(CODE=1,GLA=2,CST=4,GST=5 *
// 2091 !* IF THE RELOCATION IS RELATIVE TO SYMBOL TABLES THE WORD *
// 2092 !* CAN NOT BE RELOCATED TILL SIZE OF THE CODE(OR GLA) IS KNOWN *
// 2093 !***********************************************************************
// 2094 %IF GLARAD<0 %THEN PGLA(4,4,ADDR(VALUE)) %AND GLARAD=GLACA-4
#line 2094 "test-new/nrimp10s-77.imp"
if (GLARAD >= 0) goto L_01AF;
#line 2094 "test-new/nrimp10s-77.imp"
PGLA(4, 4, _imp_ADDR(/*?*/ &VALUE));
#line 2094 "test-new/nrimp10s-77.imp"
GLARAD = GLACA - 4;
#line 2094 "test-new/nrimp10s-77.imp"
L_01AF:;
// 2095 LPUT(19,2,GLARAD,AREA)
#line 2095 "test-new/nrimp10s-77.imp"
LPUT(19, 2, GLARAD, AREA);
// 2096 %END
#line 2096 "test-new/nrimp10s-77.imp"
return;
#line 2096 "test-new/nrimp10s-77.imp"
} /* end of RELOCATE */
// 2097 %ROUTINE GXREF(%STRING(31) NAME,%INTEGER MODE,XTRA,AT)
#line 2097 "test-new/nrimp10s-77.imp"
void GXREF(_imp_string31 NAME, int MODE, int XTRA, int AT) {
// 2098 !***********************************************************************
// 2099 !* ASK LPUT TO ARRANGE FOR A DOUBLE WORD AT 'AT' IN THE GLA *
// 2100 !* TO CONTAIN A DESCRIPTOR FOR NAME 'NAME'. *
// 2101 !* MODE=0 STATIC CODE XREF *
// 2102 !* MODE=1 DYNAMIC CODE XREF *
// 2103 !* MODE=2 DATA XREF XTRA=MINIMIUM LENGTH *
// 2104 !***********************************************************************
// 2105 %INTEGER LPUTNO
#line 2105 "test-new/nrimp10s-77.imp"
int LPUTNO;
// 2106 %IF MODE=2 %THEN LPUTNO=15 %ELSE LPUTNO=MODE+12
#line 2106 "test-new/nrimp10s-77.imp"
if (MODE != 2) goto L_01B0;
#line 2106 "test-new/nrimp10s-77.imp"
LPUTNO = 15;
#line 2106 "test-new/nrimp10s-77.imp"
goto L_01B1;
#line 2106 "test-new/nrimp10s-77.imp"
L_01B0:;
#line 2106 "test-new/nrimp10s-77.imp"
LPUTNO = MODE + 12;
#line 2106 "test-new/nrimp10s-77.imp"
L_01B1:;
// 2107 LPUT(LPUTNO,XTRA,AT,ADDR(NAME))
#line 2107 "test-new/nrimp10s-77.imp"
LPUT(LPUTNO, XTRA, AT, _imp_ADDR(/*?*/ &NAME));
// 2108 %END
#line 2108 "test-new/nrimp10s-77.imp"
return;
#line 2108 "test-new/nrimp10s-77.imp"
} /* end of GXREF */
// 2109 %ROUTINE CXREF(%STRING(255) NAME,%INTEGER MODE,XTRA,%INTEGERNAME AT)
#line 2109 "test-new/nrimp10s-77.imp"
void CXREF(_imp_string255 NAME, int MODE, int XTRA, int *AT) {
// 2110 !***********************************************************************
// 2111 !* CREATE A ZEROED AREA IN THE GLA AND CALL GXREF TO GET *
// 2112 !* IT FILLED AT LOAD TIME WITH INFORMATION ON AN EXTERNAL OBJECT *
// 2113 !* PARAMETERS ARE AS FOR GXREF. *
// 2114 !***********************************************************************
// 2115 %INTEGER Z1,Z2
#line 2115 "test-new/nrimp10s-77.imp"
int Z1;
#line 2115 "test-new/nrimp10s-77.imp"
int Z2;
// 2116 Z1=0; Z2=0
#line 2116 "test-new/nrimp10s-77.imp"
Z1 = 0;
#line 2116 "test-new/nrimp10s-77.imp"
Z2 = 0;
// 2117 PGLA(8,8,ADDR(Z1)); ! 2 ZERO WORDS
#line 2117 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &Z1));
// 2118 AT=GLACA-8
#line 2118 "test-new/nrimp10s-77.imp"
*AT = GLACA - 8;
// 2119 GXREF(NAME,MODE,XTRA,AT)
#line 2119 "test-new/nrimp10s-77.imp"
GXREF(
#line 2119 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = NAME /*q*/;
(_imp_string31 *)&tmp;
})
#line 2119 "test-new/nrimp10s-77.imp"
,
MODE, XTRA, *AT);
// 2120 %END
#line 2120 "test-new/nrimp10s-77.imp"
return;
#line 2120 "test-new/nrimp10s-77.imp"
} /* end of CXREF */
// 2121 %ROUTINE CODEDES(%INTEGERNAME AT)
#line 2121 "test-new/nrimp10s-77.imp"
void CODEDES(int *AT) {
// 2122 !***********************************************************************
// 2123 !* PUT A CODE DESCRIPTOR INTO THE PLT FOR USE BY DEFINE EP *
// 2124 !***********************************************************************
// 2125 %INTEGER DESC1,DESC2
#line 2125 "test-new/nrimp10s-77.imp"
int DESC1;
#line 2125 "test-new/nrimp10s-77.imp"
int DESC2;
// 2126 DESC1=16_E1000000; DESC2=0
#line 2126 "test-new/nrimp10s-77.imp"
DESC1 = -520093696;
#line 2126 "test-new/nrimp10s-77.imp"
DESC2 = 0;
// 2127 %IF CDCOUNT=0 %THEN FIXED GLA(0)=DESC1 %AND AT=0 %ELSE PGLA(8,8,ADDR(DESC1)) %AND AT=GLACA-8
#line 2127 "test-new/nrimp10s-77.imp"
if (CDCOUNT != 0) goto L_01B2;
#line 2127 "test-new/nrimp10s-77.imp"
FIXEDGLA[0] = DESC1;
#line 2127 "test-new/nrimp10s-77.imp"
*AT = 0;
#line 2127 "test-new/nrimp10s-77.imp"
goto L_01B3;
#line 2127 "test-new/nrimp10s-77.imp"
L_01B2:;
#line 2127 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &DESC1));
#line 2127 "test-new/nrimp10s-77.imp"
*AT = GLACA - 8;
#line 2127 "test-new/nrimp10s-77.imp"
L_01B3:;
// 2128 CDCOUNT=CDCOUNT+1
#line 2128 "test-new/nrimp10s-77.imp"
CDCOUNT = CDCOUNT + 1;
// 2129 %END
#line 2129 "test-new/nrimp10s-77.imp"
return;
#line 2129 "test-new/nrimp10s-77.imp"
} /* end of CODEDES */
// 2130 %ROUTINE DEFINE EP(%STRING(255)NAME, %INTEGER ADR,AT,MAIN)
#line 2130 "test-new/nrimp10s-77.imp"
void DEFINEEP(_imp_string255 NAME, int ADR, int AT, int MAIN) {
// 2131 !***********************************************************************
// 2132 !* AN EP CONSISTS OF A CODE DESCRIPTOR IN THE GLA(PLT) OF *
// 2133 !* FILE CONTAINING THE EP. LPUT IS TOLD ABOUT THIS AND THE LOADER*
// 2134 !* ARRANGES TO PUT A DESCRIPTOR-DESCRIPTOR TO THE CODE-DESC *
// 2135 !* IN THE GLA OF ANY FILE REFERENCES THIS EP. THIS FIRST WORD *
// 2136 !* OF ICLS PLT IS THE MAIN EP AND WE MIMIC THIS AS FAR AS POSS *
// 2137 !***********************************************************************
// 2138 %IF AT=0 %THEN FIXED GLA(1)=ADR %ELSE PLUG(2,AT+4,ADR,4)
#line 2138 "test-new/nrimp10s-77.imp"
if (AT != 0) goto L_01B4;
#line 2138 "test-new/nrimp10s-77.imp"
FIXEDGLA[1] = ADR;
#line 2138 "test-new/nrimp10s-77.imp"
goto L_01B5;
#line 2138 "test-new/nrimp10s-77.imp"
L_01B4:;
#line 2138 "test-new/nrimp10s-77.imp"
PLUG(2, AT + 4, ADR, 4);
#line 2138 "test-new/nrimp10s-77.imp"
L_01B5:;
// 2139 RELOCATE(AT+4,ADR,1)
#line 2139 "test-new/nrimp10s-77.imp"
RELOCATE(AT + 4, ADR, 1);
// 2140 LPUT(11,MAIN<<31!2,AT,ADDR(NAME)) %IF NAME#""
#line 2140 "test-new/nrimp10s-77.imp"
if (_imp_strcmp((_imp_string *)/*?*/ &NAME, (_imp_string *)/*?*/ _imp_str_literal_ptr("")) == 0) goto L_01B6;
#line 2140 "test-new/nrimp10s-77.imp"
LPUT(11, MAIN << 31 | 2, AT, _imp_ADDR(/*?*/ &NAME));
#line 2140 "test-new/nrimp10s-77.imp"
L_01B6:;
// 2141 %END
#line 2141 "test-new/nrimp10s-77.imp"
return;
#line 2141 "test-new/nrimp10s-77.imp"
} /* end of DEFINEEP */
// 2142 %ROUTINE PROLOGUE
#line 2142 "test-new/nrimp10s-77.imp"
void PROLOGUE(void) {
#line 2142 "test-new/nrimp10s-77.imp"
auto int STRINGIN(int POS);
#line 2142 "test-new/nrimp10s-77.imp"
auto void ERREXIT(int LAB, int ERRNO, int MODE);
// 2143 !***********************************************************************
// 2144 !* GENERATES THE SUBROUTINE THAT ALWAYS ARE REQUIRED ONTO THE *
// 2145 !* FRONT OF THE OBJECT PROGRAM WHERE THEY ARE DIRECTLY ADDRESABLE*
// 2146 !***********************************************************************
// 2147 %INTEGERFNSPEC STRINGIN(%INTEGER POS)
// 2148 %ROUTINESPEC ERR EXIT(%INTEGER A, B, C)
// 2149 %INTEGER I, K, L, STCA
#line 2149 "test-new/nrimp10s-77.imp"
int I;
#line 2149 "test-new/nrimp10s-77.imp"
int K;
#line 2149 "test-new/nrimp10s-77.imp"
int L;
#line 2149 "test-new/nrimp10s-77.imp"
int STCA;
// 2150 I=16_C2C2C2C2
#line 2150 "test-new/nrimp10s-77.imp"
I = -1027423550;
// 2151 LPUT(4,4,0,ADDR(I))
#line 2151 "test-new/nrimp10s-77.imp"
LPUT(4, 4, 0, _imp_ADDR(/*?*/ &I));
// 2152 SSTL=4
#line 2152 "test-new/nrimp10s-77.imp"
SSTL = 4;
// 2153 %CYCLE I=0, 1, 31
#line 2153 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 31 %cycle
#line 2153 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 31;
#line 2153 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 31");
_control = I = _initial - _increment;
#line 2153 "test-new/nrimp10s-77.imp"
L_01B7:
#line 2153 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2153 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01B8;
#line 2153 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2154 PLABS(I)=0; PLINK(I)=0
#line 2154 "test-new/nrimp10s-77.imp"
PLABS[I] = 0;
#line 2154 "test-new/nrimp10s-77.imp"
PLINK[I] = 0;
// 2155 DESADS(I)=0
#line 2155 "test-new/nrimp10s-77.imp"
DESADS[I] = 0;
// 2156 %REPEAT
#line 2156 "test-new/nrimp10s-77.imp"
goto L_01B7;
#line 2156 "test-new/nrimp10s-77.imp"
}
#line 2156 "test-new/nrimp10s-77.imp"
L_01B8:;
// 2157 !
// 2158 ! GENERATE THE FIXED-FLOAT CONSTANTS THAT MAY BE NEEDED
// 2159 !
// 2160 PLABS(1)=CA
#line 2160 "test-new/nrimp10s-77.imp"
PLABS[1] = CA;
// 2161 %CYCLE I=0, 1, 1
#line 2161 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 1 %cycle
#line 2161 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 1;
#line 2161 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 1");
_control = I = _initial - _increment;
#line 2161 "test-new/nrimp10s-77.imp"
L_01B9:
#line 2161 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2161 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01BA;
#line 2161 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2162 PCONST(UNASSPAT)
#line 2162 "test-new/nrimp10s-77.imp"
PCONST(-2122219135);
// 2163 %REPEAT
#line 2163 "test-new/nrimp10s-77.imp"
goto L_01B9;
#line 2163 "test-new/nrimp10s-77.imp"
}
#line 2163 "test-new/nrimp10s-77.imp"
L_01BA:;
// 2164 !
// 2165 ! GENERATE THE RUN TIME ERROR ROUTINE :-
// 2166 ! MDIAGS FOR NR IS %ROUTINE MDIAGS(%INT PC,LNB,ERROR,XTRA)
// 2167 ! PC IS A DUMMY (SEG FIELD ONLY USED) EXCEPT AFTER CONTINGENCY
// 2168 ! ON ENTRY TO THIS SUBROUTINE ERROR & XTRA ARE IN ACC AS 64 BIT INTEGER
// 2169 ! ENTRY HAS BEEN BY JLK SO RETURN ADDRESS STACKED
// 2170 !
// 2171 !RTF PRCL 4 TO PLANT PARAMS
// 2172 ! JLK +1 STACK DUMMY PC
// 2173 ! STLN TOS LNB AS SECOND PARAMETER
// 2174 ! ST TOS ERROR NO AS THIRD PARAM
// 2175 ! LXN (LNB+4) POINTER TO GLA
// 2176 ! RALN 9 TO STORED LNB
// 2177 ! CALL ((XNB+10)) VIA XREF=DESCRIPTOR-DESCRIPTOR
// 2178 ! J TOS BACK AFTER A MONITOR
// 2179 !
// 2180 PLABS(2)=CA
#line 2180 "test-new/nrimp10s-77.imp"
PLABS[2] = CA;
// 2181 PSF1(PRCL,0,4)
#line 2181 "test-new/nrimp10s-77.imp"
PSF1(24, 0, 4);
// 2182 PSF1(JLK,0,1)
#line 2182 "test-new/nrimp10s-77.imp"
PSF1(28, 0, 1);
// 2183 PF1(STLN,0,TOS,0)
#line 2183 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
// 2184 PF1(ST,0,TOS,0)
#line 2184 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 2185 PSF1(LXN,1,16)
#line 2185 "test-new/nrimp10s-77.imp"
PSF1(126, 1, 16);
// 2186 PSF1(RALN,0,9)
#line 2186 "test-new/nrimp10s-77.imp"
PSF1(108, 0, 9);
// 2187 PF1(CALL,2,XNB,40)
#line 2187 "test-new/nrimp10s-77.imp"
PF1(30, 2, 3, 40);
// 2188 PF1(JUNC,0,TOS,0)
#line 2188 "test-new/nrimp10s-77.imp"
PF1(26, 0, 6, 0);
// 2189 !
// 2190 ! SUBROUTINE TO CALL DEBUG ROUTINE(S#IMPMON) LINE NO IN ACC
// 2191 !
// 2192 ! PRCL 4
// 2193 ! ST TOS
// 2194 ! LXN (LNB+4)
// 2195 ! RALN 6
// 2196 ! CALL ((XNB+IMPMONEPDISP))
// 2197 ! JUNC TOS
// 2198 !
// 2199 %IF PARMDBUG#0 %THEN %START
#line 2199 "test-new/nrimp10s-77.imp"
if (PARMDBUG == 0) goto L_01BB;
// 2200 PLABS(3)=CA
#line 2200 "test-new/nrimp10s-77.imp"
PLABS[3] = CA;
// 2201 CXREF("S#IMPMON",PARMDYNAMIC,2,K)
#line 2201 "test-new/nrimp10s-77.imp"
CXREF(_imp_str_literal("S#IMPMON"), PARMDYNAMIC, 2, /*?*/ &K);
// 2202 PSF1(PRCL,0,4)
#line 2202 "test-new/nrimp10s-77.imp"
PSF1(24, 0, 4);
// 2203 PF1(ST,0,TOS,0)
#line 2203 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 2204 PSF1(LXN,1,16)
#line 2204 "test-new/nrimp10s-77.imp"
PSF1(126, 1, 16);
// 2205 PSF1(RALN,0,6)
#line 2205 "test-new/nrimp10s-77.imp"
PSF1(108, 0, 6);
// 2206 PF1(CALL,2,XNB,K)
#line 2206 "test-new/nrimp10s-77.imp"
PF1(30, 2, 3, K);
// 2207 PF1(JUNC,0,TOS,0)
#line 2207 "test-new/nrimp10s-77.imp"
PF1(26, 0, 6, 0);
// 2208 %FINISH
#line 2208 "test-new/nrimp10s-77.imp"
L_01BB:;
// 2209 !
// 2210 ! SUBROUTINE TO ADVANCE STACK FRONT BY B WORDS AND FILL WITH UNASSIGNED
// 2211 !
// 2212 ! JAT 12,*+13 B IS ZERO
// 2213 ! LSS TOS
// 2214 ! STSF TOS
// 2215 ! LDTB STRING DECRIPTOR SET UP DESCRIPTOR FOR MVL
// 2216 ! LDA TOS
// 2217 ! ASF B ADVANCE BY B WORDS
// 2218 ! MYB 4 CHANGE B TO BYTES
// 2219 ! LDB B AND MOVE TO BOUND FIELD
// 2220 ! MVL L=DR AND FILL WITH X80S
// 2221 ! ST TOS
// 2222 ! J TOS RETURN
// 2223 !
// 2224 %IF PARMCHK=1 %THEN %START; ! ONLY REQUIRED WITH CHKING
#line 2224 "test-new/nrimp10s-77.imp"
if (PARMCHK != 1) goto L_01BC;
// 2225 CNOP(0,4); K=CA
#line 2225 "test-new/nrimp10s-77.imp"
CNOP(0, 4);
#line 2225 "test-new/nrimp10s-77.imp"
K = CA;
// 2226 PCONST(16_58000000)
#line 2226 "test-new/nrimp10s-77.imp"
PCONST(1476395008);
// 2227 PLABS(4)=CA
#line 2227 "test-new/nrimp10s-77.imp"
PLABS[4] = CA;
// 2228 PF3(JAT,12,0,13)
#line 2228 "test-new/nrimp10s-77.imp"
PF3(4, 12, 0, 13);
// 2229 PF1(LSS,0,TOS,0)
#line 2229 "test-new/nrimp10s-77.imp"
PF1(98, 0, 6, 0);
// 2230 PF1(STSF,0,TOS,0)
#line 2230 "test-new/nrimp10s-77.imp"
PF1(94, 0, 6, 0);
// 2231 PF1(LDTB,0,PC,K)
#line 2231 "test-new/nrimp10s-77.imp"
PF1(116, 0, 4, K);
// 2232 PF1(LDA,0,TOS,0)
#line 2232 "test-new/nrimp10s-77.imp"
PF1(114, 0, 6, 0);
// 2233 PF1(ASF,0,BREG,0)
#line 2233 "test-new/nrimp10s-77.imp"
PF1(110, 0, 7, 0);
// 2234 PSF1(MYB,0,4)
#line 2234 "test-new/nrimp10s-77.imp"
PSF1(42, 0, 4);
// 2235 PF1(LDB,0,BREG,0)
#line 2235 "test-new/nrimp10s-77.imp"
PF1(118, 0, 7, 0);
// 2236 PF2(MVL,1,1,0,0,UNASSPAT&255)
#line 2236 "test-new/nrimp10s-77.imp"
PF2(176, 1, 1, 0, 0, -2122219135 & 255);
// 2237 PF1(ST,0,TOS,0)
#line 2237 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 2238 PF1(JUNC,0,TOS,0)
#line 2238 "test-new/nrimp10s-77.imp"
PF1(26, 0, 6, 0);
// 2239 %FINISH
#line 2239 "test-new/nrimp10s-77.imp"
L_01BC:;
// 2240 !
// 2241 ! SOME ERROR ROUTINES
// 2242 !
// 2243 ERR EXIT(5, 16_801, 0) %IF PARMOPT#0; ! UNASSIGNED VARIABLE
#line 2243 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_01BD;
#line 2243 "test-new/nrimp10s-77.imp"
ERREXIT(5, 2049, 0);
#line 2243 "test-new/nrimp10s-77.imp"
L_01BD:;
// 2244 ERR EXIT(6, 16_504, 0); ! SWITCH LABEL UNSET
#line 2244 "test-new/nrimp10s-77.imp"
ERREXIT(6, 1284, 0);
// 2245 ERR EXIT(7, 16_505, 1); ! ILLEGEAL EXPONENTIATION
#line 2245 "test-new/nrimp10s-77.imp"
ERREXIT(7, 1285, 1);
// 2246 ERR EXIT(8,16_201, 0) %IF PARMOPT#0; ! EXCESS BLOCKS
#line 2246 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_01BE;
#line 2246 "test-new/nrimp10s-77.imp"
ERREXIT(8, 513, 0);
#line 2246 "test-new/nrimp10s-77.imp"
L_01BE:;
// 2247 ERR EXIT(9, 16_601, 0); ! CAPACITY EXCEEDED
#line 2247 "test-new/nrimp10s-77.imp"
ERREXIT(9, 1537, 0);
// 2248 ERR EXIT(10,21, 0) ; ! NO RESULT
#line 2248 "test-new/nrimp10s-77.imp"
ERREXIT(10, 21, 0);
// 2249 ERR EXIT(11,16_501, 0) %IF PARMOPT#0; ! CYCLE NOT VALID
#line 2249 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_01BF;
#line 2249 "test-new/nrimp10s-77.imp"
ERREXIT(11, 1281, 0);
#line 2249 "test-new/nrimp10s-77.imp"
L_01BF:;
// 2250 ERR EXIT(12,16_701,0); ! RES FAILS
#line 2250 "test-new/nrimp10s-77.imp"
ERREXIT(12, 1793, 0);
// 2251 ERR EXIT(13,36,0) %IF PARMOPT#0; ! WRONG NO OF PARAMS
#line 2251 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_01C0;
#line 2251 "test-new/nrimp10s-77.imp"
ERREXIT(13, 36, 0);
#line 2251 "test-new/nrimp10s-77.imp"
L_01C0:;
// 2252 !
// 2253 ! PUT THE STRINGS ONTO THE FRONT OF CONSTANT AREA
// 2254 !
// 2255 CTABLE_val(0)=16_18000001
#line 2255 "test-new/nrimp10s-77.imp"
CTABLE->VAL[0] = 402653185;
// 2256 CTABLE_val(1)=4
#line 2256 "test-new/nrimp10s-77.imp"
CTABLE->VAL[1] = 4;
// 2257 STCA=8; L=ADDR(CTABLE_val(0))
#line 2257 "test-new/nrimp10s-77.imp"
STCA = 8;
#line 2257 "test-new/nrimp10s-77.imp"
L = _imp_ADDR(/*?*/ &CTABLE->VAL[0]);
// 2258 CONST PTR=2; ! IN CASE NO STRINGS
#line 2258 "test-new/nrimp10s-77.imp"
CONSTPTR = 2;
// 2259 %WHILE STRLINK#0 %CYCLE
#line 2259 "test-new/nrimp10s-77.imp"
L_01C1:;
#line 2259 "test-new/nrimp10s-77.imp"
if (STRLINK == 0) goto L_01C2;
// 2260 I=STRLINK; STRLINK=FROM AR4(I)
#line 2260 "test-new/nrimp10s-77.imp"
I = STRLINK;
#line 2260 "test-new/nrimp10s-77.imp"
STRLINK = FROMAR4(I);
// 2261 TO AR4(I,STRINGIN(I+4)); ! CHANGE LINK TO STRING ADDR
#line 2261 "test-new/nrimp10s-77.imp"
TOAR4(I, STRINGIN(I + 4));
// 2262 %REPEAT
#line 2262 "test-new/nrimp10s-77.imp"
goto L_01C1;
#line 2262 "test-new/nrimp10s-77.imp"
L_01C2:;
// 2263 STRLINK=16_80000000
#line 2263 "test-new/nrimp10s-77.imp"
STRLINK = -2147483648;
// 2264 CONST BTM=CONST PTR
#line 2264 "test-new/nrimp10s-77.imp"
CONSTBTM = CONSTPTR;
// 2265 %IF PARMOPT#0 %THEN CTABLE_val(CONST PTR)=M'IDIA' %AND CONST PTR=CONST PTR+1
#line 2265 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_01C3;
#line 2265 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR] = 1229211969;
#line 2265 "test-new/nrimp10s-77.imp"
CONSTPTR = CONSTPTR + 1;
#line 2265 "test-new/nrimp10s-77.imp"
L_01C3:;
// 2266 GXREF(MDEP,PARMDYNAMIC,2,40)
#line 2266 "test-new/nrimp10s-77.imp"
GXREF(
#line 2266 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string8) tmp = MDEP /*q*/;
(_imp_string31 *)&tmp;
})
#line 2266 "test-new/nrimp10s-77.imp"
,
PARMDYNAMIC, 2, 40);
// 2267 %IF PARMPROF#0 %THEN %START; ! ALLOCATE PROFILE COUNT AREA
#line 2267 "test-new/nrimp10s-77.imp"
if (PARMPROF == 0) goto L_01C4;
// 2268 I=16_38000001+LINE
#line 2268 "test-new/nrimp10s-77.imp"
I = 939524097 + LINE;
// 2269 K=8
#line 2269 "test-new/nrimp10s-77.imp"
K = 8;
// 2270 PARMPROF=GLACA
#line 2270 "test-new/nrimp10s-77.imp"
PARMPROF = GLACA;
// 2271 PGLA(4,8,ADDR(I))
#line 2271 "test-new/nrimp10s-77.imp"
PGLA(4, 8, _imp_ADDR(/*?*/ &I));
// 2272 K=0
#line 2272 "test-new/nrimp10s-77.imp"
K = 0;
// 2273 %CYCLE I=0,1,LINE
#line 2273 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, LINE %cycle
#line 2273 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = LINE;
#line 2273 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, LINE");
_control = I = _initial - _increment;
#line 2273 "test-new/nrimp10s-77.imp"
L_01C5:
#line 2273 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2273 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01C6;
#line 2273 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2274 PGLA(4,4,ADDR(K))
#line 2274 "test-new/nrimp10s-77.imp"
PGLA(4, 4, _imp_ADDR(/*?*/ &K));
// 2275 %REPEAT
#line 2275 "test-new/nrimp10s-77.imp"
goto L_01C5;
#line 2275 "test-new/nrimp10s-77.imp"
}
#line 2275 "test-new/nrimp10s-77.imp"
L_01C6:;
// 2276 LINE=0
#line 2276 "test-new/nrimp10s-77.imp"
LINE = 0;
// 2277 %FINISH
#line 2277 "test-new/nrimp10s-77.imp"
L_01C4:;
// 2278 LEVEL=1
#line 2278 "test-new/nrimp10s-77.imp"
LEVEL = 1;
// 2279 %CYCLE I=0,1,31
#line 2279 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 31 %cycle
#line 2279 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 31;
#line 2279 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 31");
_control = I = _initial - _increment;
#line 2279 "test-new/nrimp10s-77.imp"
L_01C7:
#line 2279 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 2279 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_01C8;
#line 2279 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 2280 %IF PLINK(I)#0 %THEN CLEAR LIST(PLINK(I))
#line 2280 "test-new/nrimp10s-77.imp"
if (PLINK[I] == 0) goto L_01C9;
#line 2280 "test-new/nrimp10s-77.imp"
CLEARLIST(/*?*/ &PLINK[I]);
#line 2280 "test-new/nrimp10s-77.imp"
L_01C9:;
// 2281 %REPEAT
#line 2281 "test-new/nrimp10s-77.imp"
goto L_01C7;
#line 2281 "test-new/nrimp10s-77.imp"
}
#line 2281 "test-new/nrimp10s-77.imp"
L_01C8:;
// 2282 %RETURN
#line 2282 "test-new/nrimp10s-77.imp"
return;
// 2283 %INTEGERFN STRINGIN(%INTEGER POS)
#line 2283 "test-new/nrimp10s-77.imp"
int STRINGIN(int POS) {
// 2284 !***********************************************************************
// 2285 !* PUT A STRING INTO THE CONSTANT AREA CHECKING FOR DUPLICATES *
// 2286 !***********************************************************************
// 2287 %INTEGER J,K,IND,HD
#line 2287 "test-new/nrimp10s-77.imp"
int J;
#line 2287 "test-new/nrimp10s-77.imp"
int K;
#line 2287 "test-new/nrimp10s-77.imp"
int IND;
#line 2287 "test-new/nrimp10s-77.imp"
int HD;
// 2288 %RECORD(LISTF)%NAME CELL{(LISTF)
#line 2288 "test-new/nrimp10s-77.imp"
struct LISTF *CELL;
// 2289 K=A(POS)
#line 2289 "test-new/nrimp10s-77.imp"
K = A[POS];
// 2290 %IF K=0 %THEN %RESULT=0
#line 2290 "test-new/nrimp10s-77.imp"
if (K != 0) goto L_01CA;
#line 2290 "test-new/nrimp10s-77.imp"
return 0;
#line 2290 "test-new/nrimp10s-77.imp"
L_01CA:;
// 2291 IND=K&31; HD=PLINK(IND)
#line 2291 "test-new/nrimp10s-77.imp"
IND = K & 31;
#line 2291 "test-new/nrimp10s-77.imp"
HD = PLINK[IND];
// 2292 %WHILE HD#0 %CYCLE
#line 2292 "test-new/nrimp10s-77.imp"
L_01CB:;
#line 2292 "test-new/nrimp10s-77.imp"
if (HD == 0) goto L_01CC;
// 2293 CELL==ASLIST(HD)
#line 2293 "test-new/nrimp10s-77.imp"
CELL = (struct LISTF *)/*?*/ &ASLIST[HD];
// 2294 %IF CELL_S1=K %AND STRING(L+CELL_S2)=STRING(ADDR(A(POS))) %THEN %RESULT=CELL_S2-4
#line 2294 "test-new/nrimp10s-77.imp"
if (CELL->S1 != K) goto L_01CD;
#line 2294 "test-new/nrimp10s-77.imp"
if (_imp_strcmp((_imp_string *)_imp_STRING(L + CELL->S2),
(_imp_string *)_imp_STRING(_imp_ADDR(/*?*/ &A[POS]))) != 0)
goto L_01CD;
#line 2294 "test-new/nrimp10s-77.imp"
return CELL->S2 - 4;
#line 2294 "test-new/nrimp10s-77.imp"
L_01CD:;
// 2295 HD=CELL_LINK
#line 2295 "test-new/nrimp10s-77.imp"
HD = CELL->LINK;
// 2296 %REPEAT
#line 2296 "test-new/nrimp10s-77.imp"
goto L_01CB;
#line 2296 "test-new/nrimp10s-77.imp"
L_01CC:;
// 2297 HD=STCA
#line 2297 "test-new/nrimp10s-77.imp"
HD = STCA;
// 2298 BYTEINTEGER(L+STCA)=K; STCA=STCA+1
#line 2298 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(L + STCA) = K;
#line 2298 "test-new/nrimp10s-77.imp"
STCA = STCA + 1;
// 2299 %CYCLE J=POS+1,1,POS+K
#line 2299 "test-new/nrimp10s-77.imp"
// %for J = POS + 1, 1, POS + K %cycle
#line 2299 "test-new/nrimp10s-77.imp"
{
int _control, _initial = POS + 1, _increment = 1, _final = POS + K;
#line 2299 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = POS + 1, 1, POS + K");
_control = J = _initial - _increment;
#line 2299 "test-new/nrimp10s-77.imp"
L_01CE:
#line 2299 "test-new/nrimp10s-77.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 2299 "test-new/nrimp10s-77.imp"
if (J == _final) goto L_01CF;
#line 2299 "test-new/nrimp10s-77.imp"
_control += _increment;
J += _increment;
// 2300 BYTE INTEGER(L+STCA)=A(J)
#line 2300 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(L + STCA) = A[J];
// 2301 STCA=STCA+1
#line 2301 "test-new/nrimp10s-77.imp"
STCA = STCA + 1;
// 2302 %REPEAT
#line 2302 "test-new/nrimp10s-77.imp"
goto L_01CE;
#line 2302 "test-new/nrimp10s-77.imp"
}
#line 2302 "test-new/nrimp10s-77.imp"
L_01CF:;
// 2303 CONST PTR=((STCA+7)&(-8))>>2
#line 2303 "test-new/nrimp10s-77.imp"
CONSTPTR = (unsigned int)(STCA + 7 & -8) >> 2;
// 2304 PUSH(PLINK(IND),K,HD,0)
#line 2304 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &PLINK[IND], K, HD, 0);
// 2305 %RESULT=HD-4
#line 2305 "test-new/nrimp10s-77.imp"
return HD - 4;
// 2306 %END
#line 2306 "test-new/nrimp10s-77.imp"
} /* end of STRINGIN */
// 2307 %ROUTINE ERR EXIT(%INTEGER LAB, ERRNO, MODE)
#line 2307 "test-new/nrimp10s-77.imp"
void ERREXIT(int LAB, int ERRNO, int MODE) {
// 2308 !***********************************************************************
// 2309 !* MODE=0 FOR DUMMY(ZERO) XTRA - MODE=1 XTRA IN BREG *
// 2310 !***********************************************************************
// 2311 PLABS(LAB)=CA
#line 2311 "test-new/nrimp10s-77.imp"
PLABS[LAB] = CA;
// 2312 %IF MODE=0 %THEN PSF1(LSS,0,0) %ELSE PF1(LSS,0,BREG,0)
#line 2312 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_01D0;
#line 2312 "test-new/nrimp10s-77.imp"
PSF1(98, 0, 0);
#line 2312 "test-new/nrimp10s-77.imp"
goto L_01D1;
#line 2312 "test-new/nrimp10s-77.imp"
L_01D0:;
#line 2312 "test-new/nrimp10s-77.imp"
PF1(98, 0, 7, 0);
#line 2312 "test-new/nrimp10s-77.imp"
L_01D1:;
// 2313 PSF1(LUH,0,ERRNO)
#line 2313 "test-new/nrimp10s-77.imp"
PSF1(106, 0, ERRNO);
// 2314 PSF1(JLK,0,(PLABS(2)-CA)//2)
#line 2314 "test-new/nrimp10s-77.imp"
PSF1(28, 0, ((long)(PLABS[2] - CA) / (long)2));
// 2315 %END
#line 2315 "test-new/nrimp10s-77.imp"
return;
#line 2315 "test-new/nrimp10s-77.imp"
} /* end of ERREXIT */
// 2316 %END
#line 2316 "test-new/nrimp10s-77.imp"
return;
#line 2316 "test-new/nrimp10s-77.imp"
} /* end of PROLOGUE */
// 2317 %ROUTINE CSS(%INTEGER P)
#line 2317 "test-new/nrimp10s-77.imp"
void CSS(int P) {
#line 2317 "test-new/nrimp10s-77.imp"
auto void MERGEINFO(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void REDUCEENV(int *HEAD);
#line 2317 "test-new/nrimp10s-77.imp"
auto void ENTERJUMP(int MASK, int LAB, int FLAGS);
#line 2317 "test-new/nrimp10s-77.imp"
auto int ENTERLAB(int LAB, int FLAGS);
#line 2317 "test-new/nrimp10s-77.imp"
auto void REMOVELAB(int LAB);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CEND(int KKK);
#line 2317 "test-new/nrimp10s-77.imp"
auto int CCOND(int CTO, int IU, int FARLAB);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CHECKSTOF(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto int REVERSE(int MASK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void SETLINE(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto int SETXORYNB(int WHICH, int RLEV);
#line 2317 "test-new/nrimp10s-77.imp"
auto int XORYNB(int USE, int INF);
#line 2317 "test-new/nrimp10s-77.imp"
auto void GETINACC(int REG, int SIZE, int ACCESS, int AREA, int DISP);
#line 2317 "test-new/nrimp10s-77.imp"
auto int AREACODE(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto int AREACODE2(int BS);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CUI(int CODE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void ASSIGN(int ASSOP, int P1);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CSTART(int CCRES, int CODE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CCYCBODY(int UA, int ELAB, int CLAB);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CLOOP(int ALT, int MARKC, int MARKUI);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CIFTHEN(int MARKIU, int MARKC, int MARKUI, int MARKE, int MARKR, int SKIP);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CREATEAH(int MODE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void TORP(int *HEAD, int *BOT, int *NOPS);
#line 2317 "test-new/nrimp10s-77.imp"
auto int INTEXP(int *VALUE);
#line 2317 "test-new/nrimp10s-77.imp"
auto int CONSTEXP(int PRECTYPE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CSEXP(int REG, int MODE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CSTREXP(int MODE, int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CRES(int LAB);
#line 2317 "test-new/nrimp10s-77.imp"
auto void EXPOP(int INHEAD, int REG, int NOPS, int MODE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void TESTAPP(int *NUM);
#line 2317 "test-new/nrimp10s-77.imp"
auto void SKIPEXP(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void SKIPAPP(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void NOAPP(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto int DOPEVECTOR(int TYPEP, int ELSIZE, int MODE, int IDEN, int *ASIZE, int *LB);
#line 2317 "test-new/nrimp10s-77.imp"
auto void DECLAREARRAYS(int FORMAT, int FINF);
#line 2317 "test-new/nrimp10s-77.imp"
auto void DECLARESCALARS(int PERMIT, int XTRA);
#line 2317 "test-new/nrimp10s-77.imp"
auto void MAKEDECS(int Q);
#line 2317 "test-new/nrimp10s-77.imp"
auto void SAVEAUXSTACK(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void RESETAUXSTACK(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CRSPEC(int M);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CFPLIST(int *OPHEAD, int *NPARMS);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CFPDEL(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CLT(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CQN(int P);
#line 2317 "test-new/nrimp10s-77.imp"
auto void GETWSP(int *PLACE, int SIZE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void RETURNWSP(int PLACE, int SIZE);
#line 2317 "test-new/nrimp10s-77.imp"
auto int TSEXP(int *VALUE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CRCALL(int RTNAME);
#line 2317 "test-new/nrimp10s-77.imp"
auto void NAMEOP(int Z, int REG, int SIZE, int NAMEP);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CNAME(int Z, int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CANAME(int ARRP, int BS, int DP);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CSNAME(int Z, int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void TESTASS(int REG, int TYPE, int SIZE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void COPYTAG(int KK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void REDUCETAG(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void REPLACETAG(int KK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void RTJUMP(int CODE, int *LINK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void STORETAG(int KK, int SLINK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void UNPACK(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void PACK(int *PTYPE);
#line 2317 "test-new/nrimp10s-77.imp"
auto void DIAGPOINTER(int LEVEL);
#line 2317 "test-new/nrimp10s-77.imp"
auto void RDISPLAY(int KK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void RHEAD(int KK);
#line 2317 "test-new/nrimp10s-77.imp"
auto void ODDALIGN(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto int PTROFFSET(int RLEV);
#line 2317 "test-new/nrimp10s-77.imp"
auto void PPJ(int MASK, int N);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CRFORMAT(int *OPHEAD);
#line 2317 "test-new/nrimp10s-77.imp"
auto int DISPLACEMENT(int LINK);
#line 2317 "test-new/nrimp10s-77.imp"
auto int COPYRECORDTAG(int *SUBS);
#line 2317 "test-new/nrimp10s-77.imp"
auto void SAVEIRS(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void COPYDR(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void BOOTOUT(int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void CHANGERD(int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void FORGET(int REG);
#line 2317 "test-new/nrimp10s-77.imp"
auto void REMEMBER(void);
#line 2317 "test-new/nrimp10s-77.imp"
auto void NOTEASSMENT(int REG, int ASSOP, int VAR);
// 2318 %ROUTINESPEC MERGE INFO
// 2319 %ROUTINESPEC REDUCE ENV(%INTEGERNAME HEAD)
// 2320 %ROUTINESPEC ENTER JUMP(%INTEGER MASK,STAD,FLAG)
// 2321 %INTEGERFNSPEC ENTER LAB(%INTEGER M,FLAG)
// 2322 %ROUTINESPEC REMOVE LAB(%INTEGER LAB)
// 2323 %ROUTINESPEC CEND(%INTEGER KKK)
// 2324 %INTEGERFNSPEC CCOND(%INTEGER CTO,A,B)
// 2325 %ROUTINESPEC CHECK STOF
// 2326 %INTEGERFNSPEC REVERSE(%INTEGER MASK)
// 2327 %ROUTINESPEC SET LINE
// 2328 %INTEGERFNSPEC SET XORYNB(%INTEGER WHICH,RLEVEL)
// 2329 %INTEGERFNSPEC XORYNB(%INTEGER USE,INF)
// 2330 %ROUTINESPEC GET IN ACC(%INTEGER ACC,SIZE,AC,AREA,DISP)
// 2331 %INTEGERFNSPEC AREA CODE
// 2332 %INTEGERFNSPEC AREA CODE2(%INTEGER BS)
// 2333 %ROUTINESPEC CUI(%INTEGER CODE)
// 2334 %ROUTINESPEC ASSIGN(%INTEGER A,B)
// 2335 %ROUTINESPEC CSTART(%INTEGER CCRES,MODE)
// 2336 %ROUTINESPEC CCYCBODY(%INTEGER UA,ELAB,CLAB)
// 2337 %ROUTINESPEC CLOOP(%INTEGER ALT,MARKC,MARKUI)
// 2338 %ROUTINESPEC CIFTHEN(%INTEGER MARKIU,MARKC,MARKUI,MARKE,MARKR,SKIP)
// 2339 %ROUTINESPEC CREATE AH(%INTEGER MODE)
// 2340 %ROUTINESPEC TORP(%INTEGERNAME HEAD,BOT,NOPS)
// 2341 %INTEGERFNSPEC INTEXP(%INTEGERNAME VALUE)
// 2342 %INTEGERFNSPEC CONSTEXP(%INTEGER PRECTYPE)
// 2343 %ROUTINESPEC CSEXP(%INTEGER REG,MODE)
// 2344 %ROUTINESPEC CSTREXP(%INTEGER A,B)
// 2345 %ROUTINESPEC CRES(%INTEGER LAB)
// 2346 %ROUTINESPEC EXPOP(%INTEGER A,B,C,D)
// 2347 %ROUTINESPEC TEST APP(%INTEGERNAME NUM)
// 2348 %ROUTINESPEC SKIP EXP
// 2349 %ROUTINESPEC SKIP APP
// 2350 %ROUTINESPEC NO APP
// 2351 %INTEGERFNSPEC DOPE VECTOR(%INTEGER A,B,MODE,ID,%INTEGERNAME C,D)
// 2352 %ROUTINESPEC DECLARE ARRAYS(%INTEGER A,B)
// 2353 %ROUTINESPEC DECLARE SCALARS(%INTEGER A,B)
// 2354 %ROUTINESPEC MAKE DECS(%INTEGER Q)
// 2355 %ROUTINESPEC SAVE AUX STACK
// 2356 %ROUTINESPEC RESET AUX STACK
// 2357 %ROUTINESPEC CRSPEC(%INTEGER M)
// 2358 %ROUTINESPEC CFPLIST(%INTEGERNAME A,B)
// 2359 %ROUTINESPEC CFPDEL
// 2360 %ROUTINESPEC CLT
// 2361 %ROUTINESPEC CQN(%INTEGER P)
// 2362 %ROUTINESPEC GET WSP(%INTEGERNAME PLACE,%INTEGER SIZE)
// 2363 %ROUTINESPEC RETURN WSP(%INTEGER PLACE,SIZE)
// 2364 %INTEGERFNSPEC TSEXP(%INTEGERNAME VALUE)
// 2365 %ROUTINESPEC CRCALL(%INTEGER RTNAME)
// 2366 %ROUTINESPEC NAMEOP(%INTEGER Z,REG,SIZE,NAMEP)
// 2367 %ROUTINESPEC CNAME(%INTEGER Z,REG)
// 2368 %ROUTINESPEC CANAME(%INTEGER Z,BS,DP)
// 2369 %ROUTINESPEC CSNAME(%INTEGER Z,REG)
// 2370 %ROUTINESPEC TEST ASS(%INTEGER REG,TYPE,SIZE)
// 2371 %ROUTINESPEC COPY TAG(%INTEGER KK)
// 2372 %ROUTINESPEC REDUCE TAG
// 2373 %ROUTINESPEC REPLACE TAG (%INTEGER KK)
// 2374 %ROUTINESPEC RT JUMP(%INTEGER CODE,%INTEGERNAME L)
// 2375 %ROUTINESPEC STORE TAG(%INTEGER KK,SLINK)
// 2376 %ROUTINESPEC UNPACK
// 2377 %ROUTINESPEC PACK(%INTEGERNAME PTYPE)
// 2378 %ROUTINESPEC DIAG POINTER(%INTEGER LEVEL)
// 2379 %ROUTINESPEC RDISPLAY(%INTEGER KK)
// 2380 %ROUTINESPEC RHEAD(%INTEGER KK)
// 2381 %ROUTINESPEC ODD ALIGN
// 2382 %INTEGERFNSPEC PTR OFFSET(%INTEGER RLEV)
// 2383 %ROUTINESPEC PPJ(%INTEGER MASK,N)
// 2384 %ROUTINESPEC CRFORMAT(%INTEGERNAME OPHEAD)
// 2385 %INTEGERFNSPEC DISPLACEMENT(%INTEGER LINK)
// 2386 %INTEGERFNSPEC COPY RECORD TAG(%INTEGERNAME SUBS)
// 2387 %ROUTINESPEC SAVE IRS
// 2388 %ROUTINESPEC COPY DR
// 2389 %ROUTINESPEC BOOT OUT(%INTEGER REG)
// 2390 %ROUTINESPEC CHANGE RD(%INTEGER REG)
// 2391 %ROUTINESPEC FORGET(%INTEGER REG)
// 2392 %ROUTINESPEC REMEMBER
// 2393 %ROUTINESPEC NOTE ASSMENT(%INTEGER REG,ASSOP,VAR)
// 2394 %SWITCH SW(1:24)
#line 2394 "test-new/nrimp10s-77.imp"
int SW_index;
#line 2394 "test-new/nrimp10s-77.imp"
int SW_line;
#line 2394 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 2394 "test-new/nrimp10s-77.imp"
static const void *SW[24] = {&&case_SW_1, &&case_SW_2, &&case_SW_3, &&case_SW_4, &&case_SW_5,
&&case_SW_6, &&case_SW_7, &&case_SW_8, &&case_SW_9, &&case_SW_10,
&&case_SW_11, &&case_SW_12, &&case_SW_13, &&case_SW_14, &&case_SW_15,
&&case_SW_16, &&case_SW_17, &&case_SW_18, &&case_SW_19, &&case_SW_20,
&&case_SW_21, &&case_SW_22, &&case_SW_23, &&case_SW_24};
// 2395 %RECORDFORMAT RD(%BYTEINTEGER UPTYPE,PTYPE,XB,FLAG,{%C
#line 2395 "test-new/nrimp10s-77.imp"
struct RD {
union {
struct {
#line 2395 "test-new/nrimp10s-77.imp"
unsigned char UPTYPE;
#line 2395 "test-new/nrimp10s-77.imp"
unsigned char PTYPE;
#line 2395 "test-new/nrimp10s-77.imp"
unsigned char XB;
#line 2395 "test-new/nrimp10s-77.imp"
unsigned char FLAG;
#line 2395 "test-new/nrimp10s-77.imp"
int D;
#line 2395 "test-new/nrimp10s-77.imp"
int XTRA;
#line 2395 "test-new/nrimp10s-77.imp"
};
};
};
// 2396+ %INTEGER D,XTRA)
// 2397 %INTEGER SNDISP,ACC,K,KFORM,STNAME,MIDCELL
#line 2397 "test-new/nrimp10s-77.imp"
int SNDISP;
#line 2397 "test-new/nrimp10s-77.imp"
int ACC;
#line 2397 "test-new/nrimp10s-77.imp"
int K;
#line 2397 "test-new/nrimp10s-77.imp"
int KFORM;
#line 2397 "test-new/nrimp10s-77.imp"
int STNAME;
#line 2397 "test-new/nrimp10s-77.imp"
int MIDCELL;
// 2398 %INTEGER TCELL,NUMMOD,JJ,JJJ,KK,QQ,MARKER,REPORTUI,XDISP,MASK, {%C
#line 2398 "test-new/nrimp10s-77.imp"
int TCELL;
#line 2398 "test-new/nrimp10s-77.imp"
int NUMMOD;
#line 2398 "test-new/nrimp10s-77.imp"
int JJ;
#line 2398 "test-new/nrimp10s-77.imp"
int JJJ;
#line 2398 "test-new/nrimp10s-77.imp"
int KK;
#line 2398 "test-new/nrimp10s-77.imp"
int QQ;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKER;
#line 2398 "test-new/nrimp10s-77.imp"
int REPORTUI;
#line 2398 "test-new/nrimp10s-77.imp"
int XDISP;
#line 2398 "test-new/nrimp10s-77.imp"
int MASK;
#line 2398 "test-new/nrimp10s-77.imp"
int BASE;
#line 2398 "test-new/nrimp10s-77.imp"
int AREA;
#line 2398 "test-new/nrimp10s-77.imp"
int ACCESS;
#line 2398 "test-new/nrimp10s-77.imp"
int DISP;
#line 2398 "test-new/nrimp10s-77.imp"
int EXTRN;
#line 2398 "test-new/nrimp10s-77.imp"
int CURRINST;
#line 2398 "test-new/nrimp10s-77.imp"
int VALUE;
#line 2398 "test-new/nrimp10s-77.imp"
int STRINGL;
#line 2398 "test-new/nrimp10s-77.imp"
int PTYPE;
#line 2398 "test-new/nrimp10s-77.imp"
int I;
#line 2398 "test-new/nrimp10s-77.imp"
int J;
#line 2398 "test-new/nrimp10s-77.imp"
int OLDI;
#line 2398 "test-new/nrimp10s-77.imp"
int USEBITS;
#line 2398 "test-new/nrimp10s-77.imp"
int TWSPHEAD;
#line 2398 "test-new/nrimp10s-77.imp"
int KKK;
#line 2398 "test-new/nrimp10s-77.imp"
int STRFNRES;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKIU;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKUI;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKC;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKE;
#line 2398 "test-new/nrimp10s-77.imp"
int MARKR;
// 2399+ BASE,AREA,ACCESS,DISP,EXTRN, CURR INST,VALUE,STRINGL, {%C
// 2400+ PTYPE,I,J,OLDI,USEBITS,TWSPHEAD,KKK,STRFNRES, {%C
// 2401+ MARKIU,MARKUI,MARKC,MARKE,MARKR
// 2402 %INTEGER LITL,ROUT,NAM,ARR,PREC,TYPE
#line 2402 "test-new/nrimp10s-77.imp"
int LITL;
#line 2402 "test-new/nrimp10s-77.imp"
int ROUT;
#line 2402 "test-new/nrimp10s-77.imp"
int NAM;
#line 2402 "test-new/nrimp10s-77.imp"
int ARR;
#line 2402 "test-new/nrimp10s-77.imp"
int PREC;
#line 2402 "test-new/nrimp10s-77.imp"
int TYPE;
// 2403 %RECORD (RD) EXPOPND{(RD); ! RESULT RECORD FOR EXPOP
#line 2403 "test-new/nrimp10s-77.imp"
struct RD EXPOPND;
// 2404 CURR INST=0
#line 2404 "test-new/nrimp10s-77.imp"
CURRINST = 0;
// 2405 TWSPHEAD=0
#line 2405 "test-new/nrimp10s-77.imp"
TWSPHEAD = 0;
// 2406 %INTEGERARRAY SGRUSE,SGRINF(0:7)
#line 2406 "test-new/nrimp10s-77.imp"
int SGRUSE[8];
#line 2406 "test-new/nrimp10s-77.imp"
int SGRINF[8];
// 2407 ->SW(A(P))
#line 2407 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = A[P];
goto case_SW_dispatch;
// 2408 SW(23): ! INCLUDE SOMETHING
#line 2408 "test-new/nrimp10s-77.imp"
case_SW_23:;
// 2409 SW(24): ! REDUNDANT SEP
#line 2409 "test-new/nrimp10s-77.imp"
case_SW_24:;
// 2410 SW(2): ! <CMARK> <COMMENT TEXT>
#line 2410 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 2411 CSSEXIT: LAST INST=CURR INST
#line 2411 "test-new/nrimp10s-77.imp"
U_1015:;
#line 2411 "test-new/nrimp10s-77.imp"
LASTINST = CURRINST;
// 2412 %WHILE TWSPHEAD#0 %CYCLE
#line 2412 "test-new/nrimp10s-77.imp"
L_01D3:;
#line 2412 "test-new/nrimp10s-77.imp"
if (TWSPHEAD == 0) goto L_01D4;
// 2413 POP(TWSPHEAD,JJ,KK,QQ)
#line 2413 "test-new/nrimp10s-77.imp"
POP(/*?*/ &TWSPHEAD, /*?*/ &JJ, /*?*/ &KK, /*?*/ &QQ);
// 2414 RETURN WSP(JJ,KK)
#line 2414 "test-new/nrimp10s-77.imp"
RETURNWSP(JJ, KK);
// 2415 %REPEAT
#line 2415 "test-new/nrimp10s-77.imp"
goto L_01D3;
#line 2415 "test-new/nrimp10s-77.imp"
L_01D4:;
// 2416 %RETURN
#line 2416 "test-new/nrimp10s-77.imp"
return;
// 2417 SW(1): !(UI)(S)
#line 2417 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 2418 FAULT(57,0) %UNLESS LEVEL>=2
#line 2418 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_01D5;
#line 2418 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2418 "test-new/nrimp10s-77.imp"
L_01D5:;
// 2419 MARKER=P+1+A(P+1)<<8+A(P+2)
#line 2419 "test-new/nrimp10s-77.imp"
MARKER = P + 1 + (A[P + 1] << 8) + A[P + 2];
// 2420 P=P+3
#line 2420 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2421 ->LABFND %IF A(MARKER)=1
#line 2421 "test-new/nrimp10s-77.imp"
if (A[MARKER] != 1) goto L_01D6;
#line 2421 "test-new/nrimp10s-77.imp"
goto U_1016;
#line 2421 "test-new/nrimp10s-77.imp"
L_01D6:;
// 2422 %IF A(MARKER)=2 %THEN SET LINE %AND CUI(0) %AND ->CSSEXIT
#line 2422 "test-new/nrimp10s-77.imp"
if (A[MARKER] != 2) goto L_01D7;
#line 2422 "test-new/nrimp10s-77.imp"
SETLINE();
#line 2422 "test-new/nrimp10s-77.imp"
CUI(0);
#line 2422 "test-new/nrimp10s-77.imp"
goto U_1015;
#line 2422 "test-new/nrimp10s-77.imp"
L_01D7:;
// 2423 MARKE=0; MARKR=0
#line 2423 "test-new/nrimp10s-77.imp"
MARKE = 0;
#line 2423 "test-new/nrimp10s-77.imp"
MARKR = 0;
// 2424 MARKUI=P; MARKIU=MARKER+1
#line 2424 "test-new/nrimp10s-77.imp"
MARKUI = P;
#line 2424 "test-new/nrimp10s-77.imp"
MARKIU = MARKER + 1;
// 2425 MARKC=MARKIU+1
#line 2425 "test-new/nrimp10s-77.imp"
MARKC = MARKIU + 1;
// 2426 %IF A(MARKER)=3 %THEN CIFTHEN(MARKIU,MARKC,MARKUI,0,0,NO) %AND ->CSSEXIT
#line 2426 "test-new/nrimp10s-77.imp"
if (A[MARKER] != 3) goto L_01D8;
#line 2426 "test-new/nrimp10s-77.imp"
CIFTHEN(MARKIU, MARKC, MARKUI, 0, 0, 0);
#line 2426 "test-new/nrimp10s-77.imp"
goto U_1015;
#line 2426 "test-new/nrimp10s-77.imp"
L_01D8:;
// 2427 CLOOP(A(MARKIU),MARKC+2,MARKUI)
#line 2427 "test-new/nrimp10s-77.imp"
CLOOP(A[MARKIU], MARKC + 2, MARKUI);
// 2428 ->CSSEXIT
#line 2428 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2429 LABFND: ->SWITCH %UNLESS A(P)=1 %AND A(P+5)=2; ! 1ST OF UI AND NO APP
#line 2429 "test-new/nrimp10s-77.imp"
U_1016:;
#line 2429 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0184;
#line 2429 "test-new/nrimp10s-77.imp"
if (A[P + 5] == 2) goto L_01D9;
#line 2429 "test-new/nrimp10s-77.imp"
L_0184:;
#line 2429 "test-new/nrimp10s-77.imp"
goto U_1017;
#line 2429 "test-new/nrimp10s-77.imp"
L_01D9:;
// 2430 ->SWITCH %UNLESS A(P+6)=2 %AND A(P+7)=2;! NO ENAMSE OR ASSNMNT
#line 2430 "test-new/nrimp10s-77.imp"
if (A[P + 6] != 2) goto L_01DA;
#line 2430 "test-new/nrimp10s-77.imp"
if (A[P + 7] == 2) goto L_01DB;
#line 2430 "test-new/nrimp10s-77.imp"
L_01DA:;
#line 2430 "test-new/nrimp10s-77.imp"
goto U_1017;
#line 2430 "test-new/nrimp10s-77.imp"
L_01DB:;
// 2431 JJ=ENTER LAB(FROM AR2(P+3),0); ->CSSEXIT
#line 2431 "test-new/nrimp10s-77.imp"
JJ = ENTERLAB(FROMAR2(P + 3), 0);
#line 2431 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2432 SW(5): ! %CYCLE
#line 2432 "test-new/nrimp10s-77.imp"
case_SW_5:;
// 2433 FAULT(57,0) %UNLESS LEVEL>=2
#line 2433 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_01DC;
#line 2433 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2433 "test-new/nrimp10s-77.imp"
L_01DC:;
// 2434 %IF A(P+5)=2 %THEN %START; ! OPEN CYCLE
#line 2434 "test-new/nrimp10s-77.imp"
if (A[P + 5] != 2) goto L_01DD;
// 2435 CLOOP(0,P+1,0)
#line 2435 "test-new/nrimp10s-77.imp"
CLOOP(0, P + 1, 0);
// 2436 %FINISH %ELSE %START
#line 2436 "test-new/nrimp10s-77.imp"
goto L_01DE;
#line 2436 "test-new/nrimp10s-77.imp"
L_01DD:;
// 2437 CLOOP(6,P+6,P+1)
#line 2437 "test-new/nrimp10s-77.imp"
CLOOP(6, P + 6, P + 1);
// 2438 %FINISH
#line 2438 "test-new/nrimp10s-77.imp"
L_01DE:;
// 2439 ->CSSEXIT
#line 2439 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2440 !
// 2441 SW(6): ! REPEAT
#line 2441 "test-new/nrimp10s-77.imp"
case_SW_6:;
// 2442 ->CSSEXIT
#line 2442 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2443 SW(22): ! '%CONTROL' (CONST)
#line 2443 "test-new/nrimp10s-77.imp"
case_SW_22:;
// 2444 J=FROM AR4(P+2)
#line 2444 "test-new/nrimp10s-77.imp"
J = FROMAR4(P + 2);
// 2445 CODEOUT
#line 2445 "test-new/nrimp10s-77.imp"
CODEOUT();
// 2446 DCOMP=J>>28; ->CSSEXIT
#line 2446 "test-new/nrimp10s-77.imp"
DCOMP = (unsigned int)J >> 28;
#line 2446 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2447 !
// 2448 SW(3): ! (%IU)(COND)%THEN(UI)(ELSE')
#line 2448 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 2449 MARKIU=P+1; MARKC=MARKIU+3
#line 2449 "test-new/nrimp10s-77.imp"
MARKIU = P + 1;
#line 2449 "test-new/nrimp10s-77.imp"
MARKC = MARKIU + 3;
// 2450 MARKR=P+2+A(P+2)<<8+A(P+3); ! ! FROMAR2(P+2)
#line 2450 "test-new/nrimp10s-77.imp"
MARKR = P + 2 + (A[P + 2] << 8) + A[P + 3];
// 2451 MARKE=0
#line 2451 "test-new/nrimp10s-77.imp"
MARKE = 0;
// 2452 %IF A(MARKR)=3 %THEN %START
#line 2452 "test-new/nrimp10s-77.imp"
if (A[MARKR] != 3) goto L_01DF;
// 2453 MARKE=MARKR+1+FROMAR2(MARKR+1)
#line 2453 "test-new/nrimp10s-77.imp"
MARKE = MARKR + 1 + FROMAR2(MARKR + 1);
// 2454 MARKUI=MARKR+3
#line 2454 "test-new/nrimp10s-77.imp"
MARKUI = MARKR + 3;
// 2455 %FINISH
#line 2455 "test-new/nrimp10s-77.imp"
L_01DF:;
// 2456 CIFTHEN(MARKIU,MARKC,MARKUI,MARKE,MARKR,NO)
#line 2456 "test-new/nrimp10s-77.imp"
CIFTHEN(MARKIU, MARKC, MARKUI, MARKE, MARKR, 0);
// 2457 ->CSSEXIT
#line 2457 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2458 SW(4):
#line 2458 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 2459 ! '%FINISH(ELSE')(S)
// 2460 ->CSSEXIT
#line 2460 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2461 SWITCH: %BEGIN; ! SWITCH LABEL
#line 2461 "test-new/nrimp10s-77.imp"
U_1017:;
#line 2461 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2462 %INTEGER HEAD,BASEPT,NAPS,FNAME
#line 2462 "test-new/nrimp10s-77.imp"
int HEAD;
#line 2462 "test-new/nrimp10s-77.imp"
int BASEPT;
#line 2462 "test-new/nrimp10s-77.imp"
int NAPS;
#line 2462 "test-new/nrimp10s-77.imp"
int FNAME;
// 2463 %INTEGERARRAY BITS(0:2)
#line 2463 "test-new/nrimp10s-77.imp"
int BITS[3];
// 2464 FORGET(-1)
#line 2464 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 2465 FNAME=FROM AR2(P+3)
#line 2465 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(P + 3);
// 2466 %UNLESS A(P)=1 %AND A(P+5)=1 %THEN FAULT2(5,0,FNAME) %AND ->BEND
#line 2466 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_01E0;
#line 2466 "test-new/nrimp10s-77.imp"
if (A[P + 5] == 1) goto L_01E1;
#line 2466 "test-new/nrimp10s-77.imp"
L_01E0:;
#line 2466 "test-new/nrimp10s-77.imp"
FAULT2(5, 0, FNAME);
#line 2466 "test-new/nrimp10s-77.imp"
goto U_1018;
#line 2466 "test-new/nrimp10s-77.imp"
L_01E1:;
// 2467 ! 1ST OF UI + APP
// 2468 P=P+3; TEST APP(NAPS)
#line 2468 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 2468 "test-new/nrimp10s-77.imp"
TESTAPP(/*?*/ &NAPS);
// 2469 P=P+6
#line 2469 "test-new/nrimp10s-77.imp"
P = P + 6;
// 2470 %UNLESS INTEXP(JJ)=0 %THEN FAULT2(41,0,0) %AND ->BEND
#line 2470 "test-new/nrimp10s-77.imp"
if (INTEXP(/*?*/ &JJ) == 0) goto L_01E2;
#line 2470 "test-new/nrimp10s-77.imp"
FAULT2(41, 0, 0);
#line 2470 "test-new/nrimp10s-77.imp"
goto U_1018;
#line 2470 "test-new/nrimp10s-77.imp"
L_01E2:;
// 2471 ! UNLESS EXPRESSION EVALUATES AND
// 2472 %UNLESS NAPS=1 %THEN FAULT2(21,NAPS-1,FNAME) %AND ->BEND
#line 2472 "test-new/nrimp10s-77.imp"
if (NAPS == 1) goto L_01E3;
#line 2472 "test-new/nrimp10s-77.imp"
FAULT2(21, NAPS - 1, FNAME);
#line 2472 "test-new/nrimp10s-77.imp"
goto U_1018;
#line 2472 "test-new/nrimp10s-77.imp"
L_01E3:;
// 2473 ! NO REST OF APP
// 2474 %UNLESS A(P+1)=2=A(P+2) %THEN FAULT2(5,0,FNAME) %AND ->BEND
#line 2474 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 2 (Part I)
#line 2474 "test-new/nrimp10s-77.imp"
int tmp;
#line 2474 "test-new/nrimp10s-77.imp"
if (A[P + 1] != (tmp = 2)) goto L_01E4;
// Double-sided test on 2 (Part II)
#line 2474 "test-new/nrimp10s-77.imp"
if (tmp == A[P + 2]) goto L_01E5;
#line 2474 "test-new/nrimp10s-77.imp"
}
#line 2474 "test-new/nrimp10s-77.imp"
L_01E4:;
#line 2474 "test-new/nrimp10s-77.imp"
FAULT2(5, 0, FNAME);
#line 2474 "test-new/nrimp10s-77.imp"
goto U_1018;
#line 2474 "test-new/nrimp10s-77.imp"
L_01E5:;
// 2475 ! NO ENAME OR REST OF ASSIGMENT
// 2476 COPY TAG(FNAME)
#line 2476 "test-new/nrimp10s-77.imp"
COPYTAG(FNAME);
// 2477 HEAD=K
#line 2477 "test-new/nrimp10s-77.imp"
HEAD = K;
// 2478 %IF OLDI#LEVEL %OR TYPE#6 %THEN FAULT(4,FNAME) %AND ->BEND
#line 2478 "test-new/nrimp10s-77.imp"
if (OLDI != LEVEL) goto L_01E6;
#line 2478 "test-new/nrimp10s-77.imp"
if (TYPE == 6) goto L_01E7;
#line 2478 "test-new/nrimp10s-77.imp"
L_01E6:;
#line 2478 "test-new/nrimp10s-77.imp"
FAULT(4, FNAME);
#line 2478 "test-new/nrimp10s-77.imp"
goto U_1018;
#line 2478 "test-new/nrimp10s-77.imp"
L_01E7:;
// 2479 FROM123(HEAD,BASEPT,KKK,KK); ! EXTRACT TABLE ADDR,LB & UB
#line 2479 "test-new/nrimp10s-77.imp"
FROM123(HEAD, /*?*/ &BASEPT, /*?*/ &KKK, /*?*/ &KK);
// 2480 MLINK(HEAD); ! K POINTS TO BIT LIST
#line 2480 "test-new/nrimp10s-77.imp"
MLINK(/*?*/ &HEAD);
// 2481 ->INBD %IF KKK<=JJ<=KK
#line 2481 "test-new/nrimp10s-77.imp"
{
// Double-sided test on JJ (Part I)
#line 2481 "test-new/nrimp10s-77.imp"
int tmp;
#line 2481 "test-new/nrimp10s-77.imp"
if (KKK > (tmp = JJ)) goto L_01E8;
// Double-sided test on JJ (Part II)
#line 2481 "test-new/nrimp10s-77.imp"
if (tmp > KK) goto L_01E8;
#line 2481 "test-new/nrimp10s-77.imp"
}
#line 2481 "test-new/nrimp10s-77.imp"
goto U_1019;
#line 2481 "test-new/nrimp10s-77.imp"
L_01E8:;
// 2482 FAULT2(50,JJ,FNAME); ->BEND
#line 2482 "test-new/nrimp10s-77.imp"
FAULT2(50, JJ, FNAME);
#line 2482 "test-new/nrimp10s-77.imp"
goto U_1018;
// 2483 INBD: Q=JJ-KKK
#line 2483 "test-new/nrimp10s-77.imp"
U_1019:;
#line 2483 "test-new/nrimp10s-77.imp"
Q = JJ - KKK;
// 2484 %WHILE Q>=96 %%CYCLE
#line 2484 "test-new/nrimp10s-77.imp"
L_01E9:;
#line 2484 "test-new/nrimp10s-77.imp"
if (Q < 96) goto L_01EA;
// 2485 MLINK(HEAD)
#line 2485 "test-new/nrimp10s-77.imp"
MLINK(/*?*/ &HEAD);
// 2486 Q=Q-96
#line 2486 "test-new/nrimp10s-77.imp"
Q = Q - 96;
// 2487 %REPEAT
#line 2487 "test-new/nrimp10s-77.imp"
goto L_01E9;
#line 2487 "test-new/nrimp10s-77.imp"
L_01EA:;
// 2488 !
// 2489 ! ASLIST(HEAD) IS THE START OF 96 BIT ENTRY IN THE BIT LIST
// 2490 ! CHECK BIT NO Q TO SEE IF LABEL ALREADY SET AND THEN SET BIT Q
// 2491 !
// 2492 FROM123(HEAD,BITS(0),BITS(1),BITS(2))
#line 2492 "test-new/nrimp10s-77.imp"
FROM123(HEAD, /*?*/ &BITS[0], /*?*/ &BITS[1], /*?*/ &BITS[2]);
// 2493 QQ=Q>>5; ! RIGHT WORD
#line 2493 "test-new/nrimp10s-77.imp"
QQ = (unsigned int)Q >> 5;
// 2494 Q=Q&31; JJJ=1<<Q; ! BIT IN WORD
#line 2494 "test-new/nrimp10s-77.imp"
Q = Q & 31;
#line 2494 "test-new/nrimp10s-77.imp"
JJJ = 1 << Q;
// 2495 FAULT2(6,JJ,FNAME) %UNLESS BITS(QQ)&JJJ=0
#line 2495 "test-new/nrimp10s-77.imp"
if (BITS[QQ] & JJJ == 0) goto L_01EB;
#line 2495 "test-new/nrimp10s-77.imp"
FAULT2(6, JJ, FNAME);
#line 2495 "test-new/nrimp10s-77.imp"
L_01EB:;
// 2496 BITS(QQ)=BITS(QQ)!JJJ
#line 2496 "test-new/nrimp10s-77.imp"
BITS[QQ] = BITS[QQ] | JJJ;
// 2497 REPLACE123(HEAD,BITS(0),BITS(1),BITS(2))
#line 2497 "test-new/nrimp10s-77.imp"
REPLACE123(HEAD, BITS[0], BITS[1], BITS[2]);
// 2498 !
// 2499 ! OPTIMISED (ARR=2) SWITCHES BASEPT POINTS TO THE
// 2500 ! ZEROETH NOT THE FIRST ELEMENT
// 2501 !
// 2502 %IF ARR=2 %THEN KKK=0; ! RESET LB IF DESC TO ELEMNT 0
#line 2502 "test-new/nrimp10s-77.imp"
if (ARR != 2) goto L_01EC;
#line 2502 "test-new/nrimp10s-77.imp"
KKK = 0;
#line 2502 "test-new/nrimp10s-77.imp"
L_01EC:;
// 2503 QQ=BASEPT+(JJ-KKK)*4; ! REL POSITION OF LABEL
#line 2503 "test-new/nrimp10s-77.imp"
QQ = BASEPT + (JJ - KKK) * 4;
// 2504 PLUG(2,QQ,CA,4); ! OVERWRITE THE WORD IN TABLE
#line 2504 "test-new/nrimp10s-77.imp"
PLUG(2, QQ, CA, 4);
// 2505 ! RELOCATION(BY HD OF CODE) INTACT
// 2506 BEND: %END; ->CSSEXIT
#line 2506 "test-new/nrimp10s-77.imp"
U_1018:;
#line 2506 "test-new/nrimp10s-77.imp"
goto end_1003;
#line 2506 "test-new/nrimp10s-77.imp"
end_1003:;
#line 2506 "test-new/nrimp10s-77.imp"
}
#line 2506 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2507 SW(7): ! (%WU)(SC)(COND)(RESTOFWU)
#line 2507 "test-new/nrimp10s-77.imp"
case_SW_7:;
// 2508 FAULT(57,0) %UNLESS LEVEL>=2
#line 2508 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_01ED;
#line 2508 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2508 "test-new/nrimp10s-77.imp"
L_01ED:;
// 2509 MARKIU=P+1; ! TO WHILE/UNTIL
#line 2509 "test-new/nrimp10s-77.imp"
MARKIU = P + 1;
// 2510 MARKC=MARKIU+3; ! TO (SC)(COND)
#line 2510 "test-new/nrimp10s-77.imp"
MARKC = MARKIU + 3;
// 2511 CLOOP(A(MARKIU)+3,MARKC,MARKIU+1+FROMAR2(MARKIU+1))
#line 2511 "test-new/nrimp10s-77.imp"
CLOOP(A[MARKIU] + 3, MARKC, MARKIU + 1 + FROMAR2(MARKIU + 1));
// 2512 ->CSSEXIT
#line 2512 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2513 !
// 2514 SW(8): ! SIMPLE DECLN
#line 2514 "test-new/nrimp10s-77.imp"
case_SW_8:;
// 2515 FAULT(57,0) %UNLESS LEVEL>=2
#line 2515 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_01EE;
#line 2515 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2515 "test-new/nrimp10s-77.imp"
L_01EE:;
// 2516 FAULT(40,0) %IF NMDECS(LEVEL)&1#0
#line 2516 "test-new/nrimp10s-77.imp"
if (NMDECS[LEVEL] & 1 == 0) goto L_01EF;
#line 2516 "test-new/nrimp10s-77.imp"
FAULT(40, 0);
#line 2516 "test-new/nrimp10s-77.imp"
L_01EF:;
// 2517 QQ=P; P=P+5;CLT;ROUT=0; LITL=0
#line 2517 "test-new/nrimp10s-77.imp"
QQ = P;
#line 2517 "test-new/nrimp10s-77.imp"
P = P + 5;
#line 2517 "test-new/nrimp10s-77.imp"
CLT();
#line 2517 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 2517 "test-new/nrimp10s-77.imp"
LITL = 0;
// 2518 %IF A(P)#1 %THEN %START; ! ARRAY DECLARATIONS
#line 2518 "test-new/nrimp10s-77.imp"
if (A[P] == 1) goto L_01F0;
// 2519 FAULT(70,0) %IF TYPE=5 %AND ACC=0
#line 2519 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_01F1;
#line 2519 "test-new/nrimp10s-77.imp"
if (ACC != 0) goto L_01F1;
#line 2519 "test-new/nrimp10s-77.imp"
FAULT(70, 0);
#line 2519 "test-new/nrimp10s-77.imp"
L_01F1:;
// 2520 NAM=0
#line 2520 "test-new/nrimp10s-77.imp"
NAM = 0;
// 2521 SET LINE
#line 2521 "test-new/nrimp10s-77.imp"
SETLINE();
// 2522 QQ=2-A(P+1); P=P+2; ! QQ=1 FOR ARRAYFORMATS
#line 2522 "test-new/nrimp10s-77.imp"
QQ = 2 - A[P + 1];
#line 2522 "test-new/nrimp10s-77.imp"
P = P + 2;
// 2523 DECLARE ARRAYS(QQ,0)
#line 2523 "test-new/nrimp10s-77.imp"
DECLAREARRAYS(QQ, 0);
// 2524 %FINISH %ELSE %START
#line 2524 "test-new/nrimp10s-77.imp"
goto L_01F2;
#line 2524 "test-new/nrimp10s-77.imp"
L_01F0:;
// 2525 %IF A(QQ+1)=128 %THEN %START;! NOT LINKED&SHUFFLED
#line 2525 "test-new/nrimp10s-77.imp"
if (A[QQ + 1] != 128) goto L_01F3;
// 2526 CQN(P+1); P=P+2
#line 2526 "test-new/nrimp10s-77.imp"
CQN(P + 1);
#line 2526 "test-new/nrimp10s-77.imp"
P = P + 2;
// 2527 DECLARE SCALARS(1,0)
#line 2527 "test-new/nrimp10s-77.imp"
DECLARESCALARS(1, 0);
// 2528 %FINISH
#line 2528 "test-new/nrimp10s-77.imp"
L_01F3:;
// 2529 %FINISH
#line 2529 "test-new/nrimp10s-77.imp"
L_01F2:;
// 2530 ->CSSEXIT
#line 2530 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2531 !
// 2532 SW(9): ! %END
#line 2532 "test-new/nrimp10s-77.imp"
case_SW_9:;
// 2533 %BEGIN
#line 2533 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2534 %SWITCH S(1:5)
#line 2534 "test-new/nrimp10s-77.imp"
int S_index;
#line 2534 "test-new/nrimp10s-77.imp"
int S_line;
#line 2534 "test-new/nrimp10s-77.imp"
char *S_file;
#line 2534 "test-new/nrimp10s-77.imp"
static const void *S[5] = {&&case_S_missing, &&case_S_missing, &&case_S_missing, &&case_S_missing,
&&case_S_missing};
// 2535 -> S(A(P+1))
#line 2535 "test-new/nrimp10s-77.imp"
S_line = __LINE__;
S_file = __FILE__;
S_index = A[P + 1];
goto case_S_dispatch;
// 2536 S(1): ! ENDOFPROGRAM
#line 2536 "test-new/nrimp10s-77.imp"
case_S_1:;
// 2537 S(2): ! ENDOFFILE
#line 2537 "test-new/nrimp10s-77.imp"
case_S_2:;
// 2538 %IF CPRMODE=0 %THEN CPRMODE=2
#line 2538 "test-new/nrimp10s-77.imp"
if (CPRMODE != 0) goto L_01F5;
#line 2538 "test-new/nrimp10s-77.imp"
CPRMODE = 2;
#line 2538 "test-new/nrimp10s-77.imp"
L_01F5:;
// 2539 FAULT(15,0) %UNLESS LEVEL+CPRMODE=3
#line 2539 "test-new/nrimp10s-77.imp"
if (LEVEL + CPRMODE == 3) goto L_01F6;
#line 2539 "test-new/nrimp10s-77.imp"
FAULT(15, 0);
#line 2539 "test-new/nrimp10s-77.imp"
L_01F6:;
// 2540 FAULT(56,0) %UNLESS A(P+1)=CPRMODE
#line 2540 "test-new/nrimp10s-77.imp"
if (A[P + 1] == CPRMODE) goto L_01F7;
#line 2540 "test-new/nrimp10s-77.imp"
FAULT(56, 0);
#line 2540 "test-new/nrimp10s-77.imp"
L_01F7:;
// 2541 CEND(CPRMODE)
#line 2541 "test-new/nrimp10s-77.imp"
CEND(CPRMODE);
// 2542 ->BEND
#line 2542 "test-new/nrimp10s-77.imp"
goto U_101A;
// 2543 S(3): ! ENDOFLIST
#line 2543 "test-new/nrimp10s-77.imp"
case_S_3:;
// 2544 LIST=0;
#line 2544 "test-new/nrimp10s-77.imp"
LIST = 0;
// 2545 ->BEND
#line 2545 "test-new/nrimp10s-77.imp"
goto U_101A;
// 2546 S(4): ! END
#line 2546 "test-new/nrimp10s-77.imp"
case_S_4:;
// 2547 CEND(FLAG(LEVEL))
#line 2547 "test-new/nrimp10s-77.imp"
CEND(FLAG[LEVEL]);
// 2548 BEND: %END
#line 2548 "test-new/nrimp10s-77.imp"
U_101A:;
#line 2548 "test-new/nrimp10s-77.imp"
goto end_1004;
#line 2548 "test-new/nrimp10s-77.imp"
case_S_dispatch:
#line 2548 "test-new/nrimp10s-77.imp"
if (S_index < 1 || S_index > 5)
_imp_signalf(6, 3, S_index, "->S(%d) out of bounds at %s line %d", S_index, S_file, S_line);
#line 2548 "test-new/nrimp10s-77.imp"
goto *S[S_index - 1];
#line 2548 "test-new/nrimp10s-77.imp"
case_S_missing:
_imp_signalf(8, 2, S_index, "switch jump to undefined label S(%d): at %s line %d", S_index, S_file, S_line);
#line 2548 "test-new/nrimp10s-77.imp"
end_1004:;
#line 2548 "test-new/nrimp10s-77.imp"
}
// 2549 ->CSSEXIT
#line 2549 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2550 !
// 2551 SW(11):
#line 2551 "test-new/nrimp10s-77.imp"
case_SW_11:;
// 2552 %BEGIN
#line 2552 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2553 %INTEGER MARKER1,KK,KKK
#line 2553 "test-new/nrimp10s-77.imp"
int MARKER1;
#line 2553 "test-new/nrimp10s-77.imp"
int KK;
#line 2553 "test-new/nrimp10s-77.imp"
int KKK;
// 2554 %STRING(34)XNAME
#line 2554 "test-new/nrimp10s-77.imp"
_imp_string34 XNAME;
// 2555 P=P+1; MARKER1=FROM AR2(P)+P; ! (SEX)(RT)(SPEC')(NAME)(FPP)
#line 2555 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 2555 "test-new/nrimp10s-77.imp"
MARKER1 = FROMAR2(P) + P;
// 2556 AGN: Q=P; KK=FROM AR2(MARKER1+5); ! KK ON NAME
#line 2556 "test-new/nrimp10s-77.imp"
U_101B:;
#line 2556 "test-new/nrimp10s-77.imp"
Q = P;
#line 2556 "test-new/nrimp10s-77.imp"
KK = FROMAR2(MARKER1 + 5);
// 2557 EXTRN=A(P+2)
#line 2557 "test-new/nrimp10s-77.imp"
EXTRN = A[P + 2];
// 2558 LITL=EXTRN&3
#line 2558 "test-new/nrimp10s-77.imp"
LITL = EXTRN & 3;
// 2559 %IF A(MARKER1)=1 %THEN %START;! P<%SPEC'>='%SPEC'
#line 2559 "test-new/nrimp10s-77.imp"
if (A[MARKER1] != 1) goto L_01F8;
// 2560 P=P+3; CRSPEC(1-EXTRN>>2);! 0 FOR ROUTINESPEC
#line 2560 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 2560 "test-new/nrimp10s-77.imp"
CRSPEC(1 - ((unsigned int)EXTRN >> 2));
// 2561 ! 1 FOR EXTERNAL (ETC) SPEC
// 2562 ->BEND
#line 2562 "test-new/nrimp10s-77.imp"
goto U_1018;
// 2563 %FINISH
#line 2563 "test-new/nrimp10s-77.imp"
L_01F8:;
// 2564 COPY TAG(KK)
#line 2564 "test-new/nrimp10s-77.imp"
COPYTAG(KK);
// 2565 %IF OLDI=LEVEL %THEN %START
#line 2565 "test-new/nrimp10s-77.imp"
if (OLDI != LEVEL) goto L_01F9;
// 2566 %IF CPRMODE=0 %THEN CPRMODE=2;! FLAG AS FILE OF ROUTINES
#line 2566 "test-new/nrimp10s-77.imp"
if (CPRMODE != 0) goto L_01FA;
#line 2566 "test-new/nrimp10s-77.imp"
CPRMODE = 2;
#line 2566 "test-new/nrimp10s-77.imp"
L_01FA:;
// 2567 !
// 2568 %IF (CPRMODE=2 %AND LEVEL=1) %START
#line 2568 "test-new/nrimp10s-77.imp"
if (CPRMODE != 2) goto L_01FB;
#line 2568 "test-new/nrimp10s-77.imp"
if (LEVEL != 1) goto L_01FB;
// 2569 %IF EXTRN=3 %THEN EXTRN=2
#line 2569 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_01FC;
#line 2569 "test-new/nrimp10s-77.imp"
EXTRN = 2;
#line 2569 "test-new/nrimp10s-77.imp"
L_01FC:;
// 2570 XNAME<-STRING(DICTBASE+WORD(KK))
#line 2570 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &XNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *_imp_STRING(DICTBASE + WORD[KK]);
(void *)&tmp;
}),
/*max:*/ 34);
#line 2570 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 34 chars */
#line 2570 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &XNAME) > 34) *_imp_LENGTH((_imp_string *)/*?*/ &XNAME) = 34;
// 2571 %IF EXTRN=1 %THEN XNAME<-"S#".XNAME
#line 2571 "test-new/nrimp10s-77.imp"
if (EXTRN != 1) goto L_01FD;
#line 2571 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &XNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *({
_imp_string255 tmp =
_imp_join((_imp_string *)/*?*/ _imp_str_literal_ptr("S#"), (_imp_string *)/*?*/ &XNAME);
(_imp_string255 *)&tmp;
});
(void *)&tmp;
}),
/*max:*/ 34);
#line 2571 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 34 chars */
#line 2571 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &XNAME) > 34) *_imp_LENGTH((_imp_string *)/*?*/ &XNAME) = 34;
#line 2571 "test-new/nrimp10s-77.imp"
L_01FD:;
// 2572 %IF EXTRN=4 %THEN XNAME=""
#line 2572 "test-new/nrimp10s-77.imp"
if (EXTRN != 4) goto L_01FE;
#line 2572 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &XNAME, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = _imp_str_literal("");
(void *)&tmp;
}),
/*max:*/ 34);
#line 2572 "test-new/nrimp10s-77.imp"
L_01FE:;
// 2573 JJ=MIDCELL; ! CODE DESCRIPTOR REL ADDR
#line 2573 "test-new/nrimp10s-77.imp"
JJ = MIDCELL;
// 2574 %IF EXTRN#4 %THEN USEBITS=2
#line 2574 "test-new/nrimp10s-77.imp"
if (EXTRN == 4) goto L_01FF;
#line 2574 "test-new/nrimp10s-77.imp"
USEBITS = 2;
#line 2574 "test-new/nrimp10s-77.imp"
L_01FF:;
// 2575 DEFINE EP(XNAME,CA,JJ,0)
#line 2575 "test-new/nrimp10s-77.imp"
DEFINEEP(
#line 2575 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string34) tmp = XNAME /*q*/;
(_imp_string255 *)&tmp;
})
#line 2575 "test-new/nrimp10s-77.imp"
,
CA, JJ, 0);
// 2576 %IF JJ#0 %THEN PSF1(INCA,0,-JJ)
#line 2576 "test-new/nrimp10s-77.imp"
if (JJ == 0) goto L_0200;
#line 2576 "test-new/nrimp10s-77.imp"
PSF1(20, 0, -JJ);
#line 2576 "test-new/nrimp10s-77.imp"
L_0200:;
// 2577 %FINISH %ELSE %START; ! EXTERNALS IN PRGM OR WRNG LEVEL
#line 2577 "test-new/nrimp10s-77.imp"
goto L_0201;
#line 2577 "test-new/nrimp10s-77.imp"
L_01FB:;
// 2578 FAULT(55,KK) %UNLESS EXTRN=4; EXTRN=4
#line 2578 "test-new/nrimp10s-77.imp"
if (EXTRN == 4) goto L_0202;
#line 2578 "test-new/nrimp10s-77.imp"
FAULT(55, KK);
#line 2578 "test-new/nrimp10s-77.imp"
L_0202:;
#line 2578 "test-new/nrimp10s-77.imp"
EXTRN = 4;
// 2579 %FINISH
#line 2579 "test-new/nrimp10s-77.imp"
L_0201:;
// 2580 %IF A(P+3)=1 %THEN KKK=LITL<<14!16_1000 %ELSE %START
#line 2580 "test-new/nrimp10s-77.imp"
if (A[P + 3] != 1) goto L_0203;
#line 2580 "test-new/nrimp10s-77.imp"
KKK = LITL << 14 | 4096;
#line 2580 "test-new/nrimp10s-77.imp"
goto L_0204;
#line 2580 "test-new/nrimp10s-77.imp"
L_0203:;
// 2581 ROUT=1; P=P+4; ! FIGURE OUT PTYPE FOR FNS&MAPS
#line 2581 "test-new/nrimp10s-77.imp"
ROUT = 1;
#line 2581 "test-new/nrimp10s-77.imp"
P = P + 4;
// 2582 CLT; ARR=0; NAM=0
#line 2582 "test-new/nrimp10s-77.imp"
CLT();
#line 2582 "test-new/nrimp10s-77.imp"
ARR = 0;
#line 2582 "test-new/nrimp10s-77.imp"
NAM = 0;
// 2583 %IF A(P)=2 %THEN NAM=2; ! SET NAME ARRAY BIT FOR MAPS
#line 2583 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0205;
#line 2583 "test-new/nrimp10s-77.imp"
NAM = 2;
#line 2583 "test-new/nrimp10s-77.imp"
L_0205:;
// 2584 PACK(KKK); ! AND STORE PTYPE IN KKK
#line 2584 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &KKK);
// 2585 %FINISH
#line 2585 "test-new/nrimp10s-77.imp"
L_0204:;
// 2586 %FINISH
#line 2586 "test-new/nrimp10s-77.imp"
L_01F9:;
// 2587 %UNLESS OLDI=LEVEL %AND J=15 %AND PTYPE=KKK %START
#line 2587 "test-new/nrimp10s-77.imp"
if (OLDI != LEVEL) goto L_0206;
#line 2587 "test-new/nrimp10s-77.imp"
if (J != 15) goto L_0206;
#line 2587 "test-new/nrimp10s-77.imp"
if (PTYPE == KKK) goto L_0207;
#line 2587 "test-new/nrimp10s-77.imp"
L_0206:;
// 2588 P=Q+3; CRSPEC(0); P=Q; ->AGN
#line 2588 "test-new/nrimp10s-77.imp"
P = Q + 3;
#line 2588 "test-new/nrimp10s-77.imp"
CRSPEC(0);
#line 2588 "test-new/nrimp10s-77.imp"
P = Q;
#line 2588 "test-new/nrimp10s-77.imp"
goto U_101B;
// 2589 %FINISH
#line 2589 "test-new/nrimp10s-77.imp"
L_0207:;
// 2590 PTYPE=PTYPE!(EXTRN&3)<<14; ! DEAL WITH %ROUTINESPEC FOLLOWED
#line 2590 "test-new/nrimp10s-77.imp"
PTYPE = PTYPE | (EXTRN & 3) << 14;
// 2591 ! BY %EXTERNALROUTINE
// 2592 %BEGIN
#line 2592 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2593 %INTEGER PTR,PTYPEP,CNT,PP
#line 2593 "test-new/nrimp10s-77.imp"
int PTR;
#line 2593 "test-new/nrimp10s-77.imp"
int PTYPEP;
#line 2593 "test-new/nrimp10s-77.imp"
int CNT;
#line 2593 "test-new/nrimp10s-77.imp"
int PP;
// 2594 J=0; REPLACE TAG(KK);! BODY GIVEN SO UPDATE TAGS INFO
#line 2594 "test-new/nrimp10s-77.imp"
J = 0;
#line 2594 "test-new/nrimp10s-77.imp"
REPLACETAG(KK);
// 2595 JJ=K; PLABEL=PLABEL-1
#line 2595 "test-new/nrimp10s-77.imp"
JJ = K;
#line 2595 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
// 2596 %UNLESS COMPILER=1 %OR (CPRMODE=2 %AND LEVEL=1) %START
#line 2596 "test-new/nrimp10s-77.imp"
if (COMPILER == 1) goto L_0208;
#line 2596 "test-new/nrimp10s-77.imp"
if (CPRMODE != 2) goto L_0209;
#line 2596 "test-new/nrimp10s-77.imp"
if (LEVEL == 1) goto L_0208;
#line 2596 "test-new/nrimp10s-77.imp"
L_0209:;
// 2597 %IF JROUND(LEVEL+1)=0 %START; ! NOT JUMP OUTSTANDING
#line 2597 "test-new/nrimp10s-77.imp"
if (JROUND[LEVEL + 1] != 0) goto L_020A;
// 2598 JROUND(LEVEL+1)=PLABEL
#line 2598 "test-new/nrimp10s-77.imp"
JROUND[LEVEL + 1] = PLABEL;
// 2599 ENTER JUMP(15,PLABEL,0)
#line 2599 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, PLABEL, 0);
// 2600 %FINISH
#line 2600 "test-new/nrimp10s-77.imp"
L_020A:;
// 2601 %FINISH
#line 2601 "test-new/nrimp10s-77.imp"
L_0208:;
// 2602 PTYPEP=PTYPE
#line 2602 "test-new/nrimp10s-77.imp"
PTYPEP = PTYPE;
// 2603 P=MARKER1+7
#line 2603 "test-new/nrimp10s-77.imp"
P = MARKER1 + 7;
// 2604 RHEAD(KK)
#line 2604 "test-new/nrimp10s-77.imp"
RHEAD(KK);
// 2605 N=20; CNT=1
#line 2605 "test-new/nrimp10s-77.imp"
N = 20;
#line 2605 "test-new/nrimp10s-77.imp"
CNT = 1;
// 2606 %WHILE A(P)=1 %CYCLE; ! WHILE SOME (MORE) FP PART
#line 2606 "test-new/nrimp10s-77.imp"
L_020B:;
#line 2606 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_020C;
// 2607 PP=P+1+FROMAR2(P+1)
#line 2607 "test-new/nrimp10s-77.imp"
PP = P + 1 + FROMAR2(P + 1);
// 2608 P=P+3
#line 2608 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2609 CFPDEL
#line 2609 "test-new/nrimp10s-77.imp"
CFPDEL();
// 2610 PTR=P
#line 2610 "test-new/nrimp10s-77.imp"
PTR = P;
// 2611 {%UNTIL A(PTR-1)=2} %CYCLE; ! CYCLE DOWN NAMELIST
#line 2611 "test-new/nrimp10s-77.imp"
L_020D:;
// 2612 %IF JJ#0 %THEN %START
#line 2612 "test-new/nrimp10s-77.imp"
if (JJ == 0) goto L_020E;
// 2613 FROM12(JJ,J,JJJ); ! EXTRACT PTYPE XTRA INFO
#line 2613 "test-new/nrimp10s-77.imp"
FROM12(JJ, /*?*/ &J, /*?*/ &JJJ);
// 2614 %UNLESS J>>16=PTYPE %AND(PTYPE#5 %OR JJJ>>16=ACC) %THEN FAULT2(9,CNT,KK)
#line 2614 "test-new/nrimp10s-77.imp"
if ((unsigned int)J >> 16 != PTYPE) goto L_020F;
#line 2614 "test-new/nrimp10s-77.imp"
if (PTYPE != 5) goto L_0210;
#line 2614 "test-new/nrimp10s-77.imp"
if ((unsigned int)JJJ >> 16 == ACC) goto L_0210;
#line 2614 "test-new/nrimp10s-77.imp"
L_020F:;
#line 2614 "test-new/nrimp10s-77.imp"
FAULT2(9, CNT, KK);
#line 2614 "test-new/nrimp10s-77.imp"
L_0210:;
// 2615 %FINISH %ELSE FAULT2(8,0,KK);! MORE FPS THAN IN SPEC
#line 2615 "test-new/nrimp10s-77.imp"
goto L_0211;
#line 2615 "test-new/nrimp10s-77.imp"
L_020E:;
#line 2615 "test-new/nrimp10s-77.imp"
FAULT2(8, 0, KK);
#line 2615 "test-new/nrimp10s-77.imp"
L_0211:;
// 2616 PTR=PTR+3
#line 2616 "test-new/nrimp10s-77.imp"
PTR = PTR + 3;
// 2617 CNT=CNT+1
#line 2617 "test-new/nrimp10s-77.imp"
CNT = CNT + 1;
// 2618 MLINK(JJ)
#line 2618 "test-new/nrimp10s-77.imp"
MLINK(/*?*/ &JJ);
// 2619 %REPEAT %UNTIL A(PTR-1)=2
#line 2619 "test-new/nrimp10s-77.imp"
if (A[PTR - 1] == 2) goto L_0212;
#line 2619 "test-new/nrimp10s-77.imp"
goto L_020D;
#line 2619 "test-new/nrimp10s-77.imp"
L_0212:;
// 2620 DECLARE SCALARS(0,0)
#line 2620 "test-new/nrimp10s-77.imp"
DECLARESCALARS(0, 0);
// 2621 P=PP
#line 2621 "test-new/nrimp10s-77.imp"
P = PP;
// 2622 %REPEAT; ! UNTIL NO MORE FP-PART
#line 2622 "test-new/nrimp10s-77.imp"
goto L_020B;
#line 2622 "test-new/nrimp10s-77.imp"
L_020C:;
// 2623 N=(N+3)&(-4); ! TO WORD BOUNDARY AFTER ALL SYSTEM
#line 2623 "test-new/nrimp10s-77.imp"
N = N + 3 & -4;
// 2624 ! STANDARD PARAMETERS HAVE BEEN DECLARED
// 2625 FAULT2(10,0,KK) %UNLESS JJ=0
#line 2625 "test-new/nrimp10s-77.imp"
if (JJ == 0) goto L_0213;
#line 2625 "test-new/nrimp10s-77.imp"
FAULT2(10, 0, KK);
#line 2625 "test-new/nrimp10s-77.imp"
L_0213:;
// 2626 PTYPE=PTYPEP
#line 2626 "test-new/nrimp10s-77.imp"
PTYPE = PTYPEP;
// 2627 %IF PTYPE&16_F0F=5 %THEN N=N+8;! STR FNS RESULT PARAM IS STACKED
#line 2627 "test-new/nrimp10s-77.imp"
if (PTYPE & 3855 != 5) goto L_0214;
#line 2627 "test-new/nrimp10s-77.imp"
N = N + 8;
#line 2627 "test-new/nrimp10s-77.imp"
L_0214:;
// 2628 ! AS XTRA PARM JUST BEFORE DISPLAY
// 2629 RDISPLAY(KK)
#line 2629 "test-new/nrimp10s-77.imp"
RDISPLAY(KK);
// 2630 MAKE DECS(MARKER1+1)
#line 2630 "test-new/nrimp10s-77.imp"
MAKEDECS(MARKER1 + 1);
// 2631 %END
#line 2631 "test-new/nrimp10s-77.imp"
goto end_1006;
#line 2631 "test-new/nrimp10s-77.imp"
end_1006:;
#line 2631 "test-new/nrimp10s-77.imp"
}
// 2632 BEND: %END; ->CSSEXIT
#line 2632 "test-new/nrimp10s-77.imp"
U_1018:;
#line 2632 "test-new/nrimp10s-77.imp"
goto end_1005;
#line 2632 "test-new/nrimp10s-77.imp"
end_1005:;
#line 2632 "test-new/nrimp10s-77.imp"
}
#line 2632 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2633 !
// 2634 SW(13): !REALS(LN)
#line 2634 "test-new/nrimp10s-77.imp"
case_SW_13:;
// 2635 FAULT(58,0) %UNLESS CPRMODE=0
#line 2635 "test-new/nrimp10s-77.imp"
if (CPRMODE == 0) goto L_0215;
#line 2635 "test-new/nrimp10s-77.imp"
FAULT(58, 0);
#line 2635 "test-new/nrimp10s-77.imp"
L_0215:;
// 2636 ALL LONG=A(P+1)&1;->CSSEXIT
#line 2636 "test-new/nrimp10s-77.imp"
ALLLONG = A[P + 1] & 1;
#line 2636 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2637 !
// 2638 SW(14): !%BEGIN
#line 2638 "test-new/nrimp10s-77.imp"
case_SW_14:;
// 2639 %BEGIN
#line 2639 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2640 PTYPE=0
#line 2640 "test-new/nrimp10s-77.imp"
PTYPE = 0;
// 2641 %IF LEVEL=1 %AND RLEVEL=0 %AND CPRMODE=0 %START
#line 2641 "test-new/nrimp10s-77.imp"
if (LEVEL != 1) goto L_0216;
#line 2641 "test-new/nrimp10s-77.imp"
if (RLEVEL != 0) goto L_0216;
#line 2641 "test-new/nrimp10s-77.imp"
if (CPRMODE != 0) goto L_0216;
// 2642 CODE DES(JJ)
#line 2642 "test-new/nrimp10s-77.imp"
CODEDES(/*?*/ &JJ);
// 2643 DEFINE EP(MAINEP, CA, JJ, 1)
#line 2643 "test-new/nrimp10s-77.imp"
DEFINEEP(
#line 2643 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string31) tmp = MAINEP /*q*/;
(_imp_string255 *)&tmp;
})
#line 2643 "test-new/nrimp10s-77.imp"
,
CA, JJ, 1);
// 2644 RLEVEL=1; RBASE=1
#line 2644 "test-new/nrimp10s-77.imp"
RLEVEL = 1;
#line 2644 "test-new/nrimp10s-77.imp"
RBASE = 1;
// 2645 L(1)=0; M(1)=0; DIAGINF(1)=0; AUXSBASE(1)=0
#line 2645 "test-new/nrimp10s-77.imp"
L[1] = 0;
#line 2645 "test-new/nrimp10s-77.imp"
M[1] = 0;
#line 2645 "test-new/nrimp10s-77.imp"
DIAGINF[1] = 0;
#line 2645 "test-new/nrimp10s-77.imp"
AUXSBASE[1] = 0;
// 2646 CPRMODE=1
#line 2646 "test-new/nrimp10s-77.imp"
CPRMODE = 1;
// 2647 N=24; NMAX=N
#line 2647 "test-new/nrimp10s-77.imp"
N = 24;
#line 2647 "test-new/nrimp10s-77.imp"
NMAX = N;
// 2648 FORGET(-1)
#line 2648 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 2649 DIAG POINTER(LEVEL+1)
#line 2649 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL + 1);
// 2650 !
// 2651 ! THE CODE PLANTED IS AS FOLLOWS:-
// 2652 ! STD (LNB+3) SAVE DESCRIPTOG TO GLA(PLT)
// 2653 ! LXN (LNB+4) TO GLA(PLT)
// 2654 ! STLN (XNB+5) SAVE LNB FOR STOP SEQUENCE
// 2655 ! ASF 1 FOR REPORT WORD
// 2656 !
// 2657 PSF1(STD,1,12)
#line 2657 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
// 2658 PSF1(LXN,1,16)
#line 2658 "test-new/nrimp10s-77.imp"
PSF1(126, 1, 16);
// 2659 PF1(STLN,0,XNB,20)
#line 2659 "test-new/nrimp10s-77.imp"
PF1(92, 0, 3, 20);
// 2660 ! PSF1(ASF,0,1)
// 2661 !
// 2662 ! THE NEXT 8 INSTRUCTIONS ARE REQUIRED TO SET SF 6 WORDS IN FRONT OF LNB
// 2663 ! AN ASF 1 WORKS AS WELL EXCEPT FOR K-STAND ALONE WHEN THERE MAY BE
// 2664 ! A USELESS REDUNDANT DESCRIPTOR ON THE STACK
// 2665 !
// 2666 PF1(STLN,0,TOS,0)
#line 2666 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
// 2667 PF1(LSS,0,TOS,0)
#line 2667 "test-new/nrimp10s-77.imp"
PF1(98, 0, 6, 0);
// 2668 PSF1(IAD,0,24)
#line 2668 "test-new/nrimp10s-77.imp"
PSF1(224, 0, 24);
// 2669 PF1(STSF,0,TOS,0)
#line 2669 "test-new/nrimp10s-77.imp"
PF1(94, 0, 6, 0);
// 2670 PF1(ISB,0,TOS,0)
#line 2670 "test-new/nrimp10s-77.imp"
PF1(226, 0, 6, 0);
// 2671 PSF1(ISH,0,-2)
#line 2671 "test-new/nrimp10s-77.imp"
PSF1(232, 0, -2);
// 2672 PF1(ST,0,BREG,0)
#line 2672 "test-new/nrimp10s-77.imp"
PF1(72, 0, 7, 0);
// 2673 PF1(ASF,0,BREG,0)
#line 2673 "test-new/nrimp10s-77.imp"
PF1(110, 0, 7, 0);
// 2674 !
// 2675 !
// 2676 ! SET THE PROGRAM MASK TO MASK OUT UNDERFLOW AND ALLOW ALL OTHER INTS
// 2677 !
// 2678 ! MPSR 16_40C0
// 2679 !
// 2680 PF1(MPSR,0,0,16_40C0)
#line 2680 "test-new/nrimp10s-77.imp"
PF1(50, 0, 0, 16576);
// 2681 PTYPE=1
#line 2681 "test-new/nrimp10s-77.imp"
PTYPE = 1;
// 2682 %FINISH %ELSE SET LINE; ! SO 'ENTERED FROM LINE' IS OK
#line 2682 "test-new/nrimp10s-77.imp"
goto L_0217;
#line 2682 "test-new/nrimp10s-77.imp"
L_0216:;
#line 2682 "test-new/nrimp10s-77.imp"
SETLINE();
#line 2682 "test-new/nrimp10s-77.imp"
L_0217:;
// 2683 RHEAD(-1)
#line 2683 "test-new/nrimp10s-77.imp"
RHEAD(-1);
// 2684 RDISPLAY(-1)
#line 2684 "test-new/nrimp10s-77.imp"
RDISPLAY(-1);
// 2685 MAKE DECS(P+1)
#line 2685 "test-new/nrimp10s-77.imp"
MAKEDECS(P + 1);
// 2686 %END
#line 2686 "test-new/nrimp10s-77.imp"
goto end_1007;
#line 2686 "test-new/nrimp10s-77.imp"
end_1007:;
#line 2686 "test-new/nrimp10s-77.imp"
}
// 2687 ->CSSEXIT
#line 2687 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2688 !
// 2689 SW(15):
#line 2689 "test-new/nrimp10s-77.imp"
case_SW_15:;
// 2690 ! '%ON'(EVENT')(N)(NLIST)'%START'
// 2691 FAULT(57,0) %UNLESS LEVEL>=2
#line 2691 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_0218;
#line 2691 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2691 "test-new/nrimp10s-77.imp"
L_0218:;
// 2692 FAULT(40,0) %IF NMDECS(LEVEL)&1#0
#line 2692 "test-new/nrimp10s-77.imp"
if (NMDECS[LEVEL] & 1 == 0) goto L_0219;
#line 2692 "test-new/nrimp10s-77.imp"
FAULT(40, 0);
#line 2692 "test-new/nrimp10s-77.imp"
L_0219:;
// 2693 NMDECS(LEVEL)=NMDECS(LEVEL)!16_11;! NO MORE DECS AND IN ONCOND
#line 2693 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | 17;
// 2694 %IF STACK=0 %THEN %START
#line 2694 "test-new/nrimp10s-77.imp"
if (STACK != 0) goto L_021A;
// 2695 SAVE AUX STACK
#line 2695 "test-new/nrimp10s-77.imp"
SAVEAUXSTACK();
// 2696 DISP=AUXSBASE(LEVEL)
#line 2696 "test-new/nrimp10s-77.imp"
DISP = AUXSBASE[LEVEL];
// 2697 PSF1(LSS,2,DISP); ! SAVE TOP OF AUX STACK
#line 2697 "test-new/nrimp10s-77.imp"
PSF1(98, 2, DISP);
// 2698 PSF1(ST,1,DISP+12)
#line 2698 "test-new/nrimp10s-77.imp"
PSF1(72, 1, DISP + 12);
// 2699 %FINISH
#line 2699 "test-new/nrimp10s-77.imp"
L_021A:;
// 2700 GRUSE(ACCR)=0
#line 2700 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 2701 PSF1(CPSR,1,N+8)
#line 2701 "test-new/nrimp10s-77.imp"
PSF1(52, 1, N + 8);
// 2702 PLABEL=PLABEL-1
#line 2702 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
// 2703 JJJ=PLABEL
#line 2703 "test-new/nrimp10s-77.imp"
JJJ = PLABEL;
// 2704 ENTER JUMP(15,JJJ,B'10'); ! JUMP ROUND ON BODY
#line 2704 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, JJJ, 2);
// 2705 !
// 2706 P=P+2; JJ=0; ! SET UP A BITMASK IN JJ
#line 2706 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 2706 "test-new/nrimp10s-77.imp"
JJ = 0;
// 2707 {%UNTIL A(P-1)=2} %CYCLE; ! UNTIL NO MORE NLIST
#line 2707 "test-new/nrimp10s-77.imp"
L_021B:;
// 2708 KK=A(P)
#line 2708 "test-new/nrimp10s-77.imp"
KK = A[P];
// 2709 FAULT2(26,KK,0) %UNLESS 1<=KK<=14
#line 2709 "test-new/nrimp10s-77.imp"
{
// Double-sided test on KK (Part I)
#line 2709 "test-new/nrimp10s-77.imp"
int tmp;
#line 2709 "test-new/nrimp10s-77.imp"
if (1 > (tmp = KK)) goto L_0149;
// Double-sided test on KK (Part II)
#line 2709 "test-new/nrimp10s-77.imp"
if (tmp <= 14) goto L_021C;
#line 2709 "test-new/nrimp10s-77.imp"
}
#line 2709 "test-new/nrimp10s-77.imp"
L_0149:;
#line 2709 "test-new/nrimp10s-77.imp"
FAULT2(26, KK, 0);
#line 2709 "test-new/nrimp10s-77.imp"
L_021C:;
// 2710 JJ=JJ!1<<(KK-1)
#line 2710 "test-new/nrimp10s-77.imp"
JJ = JJ | 1 << KK - 1;
// 2711 P=P+2
#line 2711 "test-new/nrimp10s-77.imp"
P = P + 2;
// 2712 %REPEAT %UNTIL A(P-1)=2
#line 2712 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_021D;
#line 2712 "test-new/nrimp10s-77.imp"
goto L_021B;
#line 2712 "test-new/nrimp10s-77.imp"
L_021D:;
// 2713 KK=CA; PGLA(4,4,ADDR(CA))
#line 2713 "test-new/nrimp10s-77.imp"
KK = CA;
#line 2713 "test-new/nrimp10s-77.imp"
PGLA(4, 4, _imp_ADDR(/*?*/ &CA));
// 2714 RELOCATE(GLACA-4,KK,1); ! ENTRY ADDRESS IN PLT
#line 2714 "test-new/nrimp10s-77.imp"
RELOCATE(GLACA - 4, KK, 1);
// 2715 ONWORD(LEVEL)=JJ<<18!(GLACA-4)
#line 2715 "test-new/nrimp10s-77.imp"
ONWORD[LEVEL] = JJ << 18 | GLACA - 4;
// 2716 FORGET(-1)
#line 2716 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 2717 PSF1(ST,1,N); ! STORE EVENT,SUBEVENT&LINE
#line 2717 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N);
// 2718 PSF1(MPSR,1,N+8)
#line 2718 "test-new/nrimp10s-77.imp"
PSF1(50, 1, N + 8);
// 2719 ONINF(LEVEL)=N; N=N+12
#line 2719 "test-new/nrimp10s-77.imp"
ONINF[LEVEL] = N;
#line 2719 "test-new/nrimp10s-77.imp"
N = N + 12;
// 2720 %IF STACK=0 %THEN %START
#line 2720 "test-new/nrimp10s-77.imp"
if (STACK != 0) goto L_021E;
// 2721 PSF1(LSS,1,DISP+12); ! RESET AUX STACK TOP
#line 2721 "test-new/nrimp10s-77.imp"
PSF1(98, 1, DISP + 12);
// 2722 PSF1(ST,2,DISP)
#line 2722 "test-new/nrimp10s-77.imp"
PSF1(72, 2, DISP);
// 2723 %FINISH
#line 2723 "test-new/nrimp10s-77.imp"
L_021E:;
// 2724 CSTART(0,3)
#line 2724 "test-new/nrimp10s-77.imp"
CSTART(0, 3);
// 2725 NMDECS(LEVEL)=NMDECS(LEVEL)!!16_10;! NOT IN ONCOND
#line 2725 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] ^ 16;
// 2726 JJ=ENTER LAB(JJJ,B'111'); ! REPLACE ENVIRONMENT
#line 2726 "test-new/nrimp10s-77.imp"
JJ = ENTERLAB(JJJ, 7);
// 2727 ->CSSEXIT
#line 2727 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2728 SW(16):
#line 2728 "test-new/nrimp10s-77.imp"
case_SW_16:;
// 2729 FAULT(57,0) %UNLESS LEVEL>=2
#line 2729 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_021F;
#line 2729 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 2729 "test-new/nrimp10s-77.imp"
L_021F:;
// 2730 %BEGIN; ! %SWITCH (SWITCH LIST)
#line 2730 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 2731 %INTEGER Q,RANGE,KKK,KK,LB,PP,D0,D1,OPHEAD,V,ARRP,R
#line 2731 "test-new/nrimp10s-77.imp"
int Q;
#line 2731 "test-new/nrimp10s-77.imp"
int RANGE;
#line 2731 "test-new/nrimp10s-77.imp"
int KKK;
#line 2731 "test-new/nrimp10s-77.imp"
int KK;
#line 2731 "test-new/nrimp10s-77.imp"
int LB;
#line 2731 "test-new/nrimp10s-77.imp"
int PP;
#line 2731 "test-new/nrimp10s-77.imp"
int D0;
#line 2731 "test-new/nrimp10s-77.imp"
int D1;
#line 2731 "test-new/nrimp10s-77.imp"
int OPHEAD;
#line 2731 "test-new/nrimp10s-77.imp"
int V;
#line 2731 "test-new/nrimp10s-77.imp"
int ARRP;
#line 2731 "test-new/nrimp10s-77.imp"
int R;
// 2732 Q=P
#line 2732 "test-new/nrimp10s-77.imp"
Q = P;
// 2733 ARRP=1
#line 2733 "test-new/nrimp10s-77.imp"
ARRP = 1;
// 2734 %IF PARMOPT=0 %THEN ARRP=2
#line 2734 "test-new/nrimp10s-77.imp"
if (PARMOPT != 0) goto L_0220;
#line 2734 "test-new/nrimp10s-77.imp"
ARRP = 2;
#line 2734 "test-new/nrimp10s-77.imp"
L_0220:;
// 2735 {%UNTIL A(Q)=2} %CYCLE; ! UNTIL NO'REST OF SW LIST'
#line 2735 "test-new/nrimp10s-77.imp"
L_0221:;
// 2736 P=P+3
#line 2736 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2737 P=P+3 %WHILE A(P)=1
#line 2737 "test-new/nrimp10s-77.imp"
L_0222:;
#line 2737 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0223;
#line 2737 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 2737 "test-new/nrimp10s-77.imp"
goto L_0222;
#line 2737 "test-new/nrimp10s-77.imp"
L_0223:;
// 2738 P=P+4; ! TO P(+')
#line 2738 "test-new/nrimp10s-77.imp"
P = P + 4;
// 2739 KKK=INTEXP(LB); ! EXTRACT LOWER BOUND
#line 2739 "test-new/nrimp10s-77.imp"
KKK = INTEXP(/*?*/ &LB);
// 2740 P=P+3
#line 2740 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2741 KKK=KKK!INTEXP(KK); ! EXTRACT UPPER BOUND
#line 2741 "test-new/nrimp10s-77.imp"
KKK = KKK | INTEXP(/*?*/ &KK);
// 2742 RANGE=(KK-LB+1)
#line 2742 "test-new/nrimp10s-77.imp"
RANGE = KK - LB + 1;
// 2743 %IF RANGE<=0 %OR KKK#0 %START
#line 2743 "test-new/nrimp10s-77.imp"
if (RANGE <= 0) goto L_0224;
#line 2743 "test-new/nrimp10s-77.imp"
if (KKK == 0) goto L_0225;
#line 2743 "test-new/nrimp10s-77.imp"
L_0224:;
// 2744 FAULT2(38,1-RANGE,FROMAR2(Q+1))
#line 2744 "test-new/nrimp10s-77.imp"
FAULT2(38, 1 - RANGE, FROMAR2(Q + 1));
// 2745 LB=0; KK=10; RANGE=11
#line 2745 "test-new/nrimp10s-77.imp"
LB = 0;
#line 2745 "test-new/nrimp10s-77.imp"
KK = 10;
#line 2745 "test-new/nrimp10s-77.imp"
RANGE = 11;
// 2746 %FINISH
#line 2746 "test-new/nrimp10s-77.imp"
L_0225:;
// 2747 %IF GLACA+8-4*LB<0 %THEN ARRP=1;! ZEROETH ELEMENT OFF FRONT
#line 2747 "test-new/nrimp10s-77.imp"
if (GLACA + 8 - 4 * LB >= 0) goto L_0226;
#line 2747 "test-new/nrimp10s-77.imp"
ARRP = 1;
#line 2747 "test-new/nrimp10s-77.imp"
L_0226:;
// 2748 PTYPE=16_56+ARRP<<8; ! WORD LABEL ARRAY
#line 2748 "test-new/nrimp10s-77.imp"
PTYPE = 86 + (ARRP << 8);
// 2749 PP=P; P=Q+1
#line 2749 "test-new/nrimp10s-77.imp"
PP = P;
#line 2749 "test-new/nrimp10s-77.imp"
P = Q + 1;
// 2750 {%UNTIL A(P-1)=2} %CYCLE; ! DOWN NAMELIST
#line 2750 "test-new/nrimp10s-77.imp"
L_0227:;
// 2751 K=FROM AR2(P)
#line 2751 "test-new/nrimp10s-77.imp"
K = FROMAR2(P);
// 2752 P=P+3
#line 2752 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2753 OPHEAD=0; R=LB
#line 2753 "test-new/nrimp10s-77.imp"
OPHEAD = 0;
#line 2753 "test-new/nrimp10s-77.imp"
R = LB;
// 2754 !
// 2755 ! SET UP A BIT LIST (96 BITS PER CELL) TO CHECK FOR SWITCH LABELS
// 2756 ! SET TWICE
// 2757 !
// 2758 {%UNTIL R>KK} %CYCLE
#line 2758 "test-new/nrimp10s-77.imp"
L_0228:;
// 2759 PUSH(OPHEAD,0,0,0)
#line 2759 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &OPHEAD, 0, 0, 0);
// 2760 R=R+96
#line 2760 "test-new/nrimp10s-77.imp"
R = R + 96;
// 2761 %REPEAT %UNTIL R>KK
#line 2761 "test-new/nrimp10s-77.imp"
if (R > KK) goto L_0229;
#line 2761 "test-new/nrimp10s-77.imp"
goto L_0228;
#line 2761 "test-new/nrimp10s-77.imp"
L_0229:;
// 2762 !
// 2763 ! FOR CHECKING MODE USE A BOUNDED WORD DESCRIPTOR AND WORD SIZE
// 2764 ! ENTRIES PRESET TO "SW LABEL NOT SET". OPTIMISING USE BCI WORD
// 2765 ! ARRAYS WITH BASE SET TO ZEROETH ELEMENT
// 2766
// 2767 D1=(GLACA+15)&(-8); ! FIRST TABLE ENTRY
#line 2767 "test-new/nrimp10s-77.imp"
D1 = GLACA + 15 & -8;
// 2768 D0=16_28000000!RANGE; ! SCALED WORD DES
#line 2768 "test-new/nrimp10s-77.imp"
D0 = 671088640 | RANGE;
// 2769 %IF ARRP=2 %THEN %START
#line 2769 "test-new/nrimp10s-77.imp"
if (ARRP != 2) goto L_022A;
// 2770 D0=D0!16_01000000 %UNLESS LB=0;! SET BCI BIT
#line 2770 "test-new/nrimp10s-77.imp"
if (LB == 0) goto L_022B;
#line 2770 "test-new/nrimp10s-77.imp"
D0 = D0 | 16777216;
#line 2770 "test-new/nrimp10s-77.imp"
L_022B:;
// 2771 D1=D1-4*LB
#line 2771 "test-new/nrimp10s-77.imp"
D1 = D1 - 4 * LB;
// 2772 %FINISH
#line 2772 "test-new/nrimp10s-77.imp"
L_022A:;
// 2773 PGLA(8,8,ADDR(D0))
#line 2773 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &D0));
// 2774 SNDISP=GLACA>>2-2; ! WORD PLT DISP
#line 2774 "test-new/nrimp10s-77.imp"
SNDISP = ((unsigned int)GLACA >> 2) - 2;
// 2775 RELOCATE(GLACA-4,D1,2); ! RELOCATE RELATIVE TO GLA
#line 2775 "test-new/nrimp10s-77.imp"
RELOCATE(GLACA - 4, D1, 2);
// 2776 PUSH(OPHEAD,D1,LB,KK)
#line 2776 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &OPHEAD, D1, LB, KK);
// 2777 KFORM=0; ACC=4
#line 2777 "test-new/nrimp10s-77.imp"
KFORM = 0;
#line 2777 "test-new/nrimp10s-77.imp"
ACC = 4;
// 2778 J=1; STORE TAG(K,OPHEAD)
#line 2778 "test-new/nrimp10s-77.imp"
J = 1;
#line 2778 "test-new/nrimp10s-77.imp"
STORETAG(K, OPHEAD);
// 2779 !
// 2780 !THE TABLE WILL CONSIST OF RELATIVE DISPLACEMENTS FROM THE TABLE HEAD
// 2781 ! TO THE LABEL POSN. SET ALL TO GO TO PLAB(6) INITIALLY
// 2782 !
// 2783 V=PLABS(6)
#line 2783 "test-new/nrimp10s-77.imp"
V = PLABS[6];
// 2784 %CYCLE KKK=LB,1,KK
#line 2784 "test-new/nrimp10s-77.imp"
// %for KKK = LB, 1, KK %cycle
#line 2784 "test-new/nrimp10s-77.imp"
{
int _control, _initial = LB, _increment = 1, _final = KK;
#line 2784 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle KKK = LB, 1, KK");
_control = KKK = _initial - _increment;
#line 2784 "test-new/nrimp10s-77.imp"
L_022C:
#line 2784 "test-new/nrimp10s-77.imp"
if (KKK != _control) _imp_signal(4, 2, 0, "Corrupt control variable KKK");
#line 2784 "test-new/nrimp10s-77.imp"
if (KKK == _final) goto L_022D;
#line 2784 "test-new/nrimp10s-77.imp"
_control += _increment;
KKK += _increment;
// 2785 RELOCATE(-1,V,1); ! PLABS(6) RELOCATED BY HD OF CODE
#line 2785 "test-new/nrimp10s-77.imp"
RELOCATE(-1, V, 1);
// 2786 %REPEAT
#line 2786 "test-new/nrimp10s-77.imp"
goto L_022C;
#line 2786 "test-new/nrimp10s-77.imp"
}
#line 2786 "test-new/nrimp10s-77.imp"
L_022D:;
// 2787 %REPEAT %UNTIL A(P-1)=2; ! FOR ANY MORE NAMES IN NAMELIST
#line 2787 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_022F;
#line 2787 "test-new/nrimp10s-77.imp"
goto L_0227;
#line 2787 "test-new/nrimp10s-77.imp"
L_022F:;
// 2788 Q=PP; P=Q
#line 2788 "test-new/nrimp10s-77.imp"
Q = PP;
#line 2788 "test-new/nrimp10s-77.imp"
P = Q;
// 2789 %REPEAT %UNTIL A(Q)=2; ! UNTIL A(Q)=2
#line 2789 "test-new/nrimp10s-77.imp"
if (A[Q] == 2) goto L_0230;
#line 2789 "test-new/nrimp10s-77.imp"
goto L_0221;
#line 2789 "test-new/nrimp10s-77.imp"
L_0230:;
// 2790 %END;->CSSEXIT
#line 2790 "test-new/nrimp10s-77.imp"
goto end_1008;
#line 2790 "test-new/nrimp10s-77.imp"
end_1008:;
#line 2790 "test-new/nrimp10s-77.imp"
}
#line 2790 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2791 !
// 2792 SW(17): LIST=1; ->CSSEXIT
#line 2792 "test-new/nrimp10s-77.imp"
case_SW_17:;
#line 2792 "test-new/nrimp10s-77.imp"
LIST = 1;
#line 2792 "test-new/nrimp10s-77.imp"
goto U_1015;
// 2793 !
// 2794 SW(12): ! '%OWN' (TYPE)(OWNDEC)
#line 2794 "test-new/nrimp10s-77.imp"
case_SW_12:;
// 2795 %BEGIN
#line 2795 "test-new/nrimp10s-77.imp"
{ /*%begin*/
#line 2795 "test-new/nrimp10s-77.imp"
auto void CLEAR(int LENGTH);
#line 2795 "test-new/nrimp10s-77.imp"
auto void STAG(int J, int DATALEN);
#line 2795 "test-new/nrimp10s-77.imp"
auto void XTRACTCONST(int CONTYPE, int CONPREC);
#line 2795 "test-new/nrimp10s-77.imp"
auto void INITSPACE(int SIZE, int NELS);
// 2796 !***********************************************************************
// 2797 !* INITIALISED DECLARATION GO INTO THE GLA OR GLA SYMBOL TABLES *
// 2798 !* EXCEPT FOR CONST ARRAYS WHICH GO INTO THE CODE SYMBOL TABLES *
// 2799 !* STRINGS AND ARRAYS HAVE A HEADER IN THE GLA. LPUT ARRANGES *
// 2800 !* FOR THE LOADER TO RELOCATE THE HEADERS. *
// 2801 !* EXTERNALS ARE IDENTICAL WITH OWN BUT ALSO HAVE A DATA EP DEFN *
// 2802 !* IN THE LOAD DATA SO THEY CAN BE FOUND AT LOAD TIME *
// 2803 !* EXTRINSICS HAVE A DATA REFERENCE AND A DUMMY HEADER IN THE GLA *
// 2804 !* THE LOADER USES THE FORMER TO RELOCATE THE LATTER. *
// 2805 !***********************************************************************
// 2806 %ROUTINESPEC CLEAR(%INTEGER L)
// 2807 %ROUTINESPEC STAG(%INTEGER J,DATALEN)
// 2808 %ROUTINESPEC XTRACT CONST(%INTEGER CONTYPE,CONPREC)
// 2809 %ROUTINESPEC INIT SPACE(%INTEGER A,B)
// 2810 %INTEGER LENGTH,BP,PP,SIGN,CBASE,MODE,UICONST,ICONST,TAGDISP,EPTYPE, {%C
#line 2810 "test-new/nrimp10s-77.imp"
int LENGTH;
#line 2810 "test-new/nrimp10s-77.imp"
int BP;
#line 2810 "test-new/nrimp10s-77.imp"
int PP;
#line 2810 "test-new/nrimp10s-77.imp"
int SIGN;
#line 2810 "test-new/nrimp10s-77.imp"
int CBASE;
#line 2810 "test-new/nrimp10s-77.imp"
int MODE;
#line 2810 "test-new/nrimp10s-77.imp"
int UICONST;
#line 2810 "test-new/nrimp10s-77.imp"
int ICONST;
#line 2810 "test-new/nrimp10s-77.imp"
int TAGDISP;
#line 2810 "test-new/nrimp10s-77.imp"
int EPTYPE;
#line 2810 "test-new/nrimp10s-77.imp"
int EPDISP;
#line 2810 "test-new/nrimp10s-77.imp"
int AH1;
#line 2810 "test-new/nrimp10s-77.imp"
int AH2;
#line 2810 "test-new/nrimp10s-77.imp"
int AH3;
#line 2810 "test-new/nrimp10s-77.imp"
int AH4;
#line 2810 "test-new/nrimp10s-77.imp"
int AD;
#line 2810 "test-new/nrimp10s-77.imp"
int FNAM;
#line 2810 "test-new/nrimp10s-77.imp"
int FINF;
#line 2810 "test-new/nrimp10s-77.imp"
int SPOINT;
#line 2810 "test-new/nrimp10s-77.imp"
int CONSTSFOUND;
#line 2810 "test-new/nrimp10s-77.imp"
int CPREC;
#line 2810 "test-new/nrimp10s-77.imp"
int EXTRN;
#line 2810 "test-new/nrimp10s-77.imp"
int NNAMES;
#line 2810 "test-new/nrimp10s-77.imp"
int MARK;
#line 2810 "test-new/nrimp10s-77.imp"
int LPUTP;
#line 2810 "test-new/nrimp10s-77.imp"
int MARKER1;
#line 2810 "test-new/nrimp10s-77.imp"
int LB;
#line 2810 "test-new/nrimp10s-77.imp"
int CTYPE;
#line 2810 "test-new/nrimp10s-77.imp"
int CONSTP;
#line 2810 "test-new/nrimp10s-77.imp"
int FORMAT;
#line 2810 "test-new/nrimp10s-77.imp"
int PTSIZE;
#line 2810 "test-new/nrimp10s-77.imp"
int DIMEN;
#line 2810 "test-new/nrimp10s-77.imp"
int SACC;
#line 2810 "test-new/nrimp10s-77.imp"
int TYPEP;
// 2811+ EPDISP,AH1,AH2,AH3,AH4,AD,FNAM,FINF,SPOINT,CONSTSFOUND,CPREC,{%C
// 2812+ EXTRN,NNAMES,MARK,LPUTP,MARKER1,LB,CTYPE,CONSTP,FORMAT, {%C
// 2813+ PTSIZE,DIMEN,SACC,TYPEP
// 2814 %LONGREAL RCONST,LRCONST
#line 2814 "test-new/nrimp10s-77.imp"
double RCONST;
#line 2814 "test-new/nrimp10s-77.imp"
double LRCONST;
// 2815 %OWNLONGREAL ZERO=0
#line 2815 "test-new/nrimp10s-77.imp"
static double ZERO = 0;
// 2816 %STRING(255) SCONST,NAMTXT
#line 2816 "test-new/nrimp10s-77.imp"
_imp_string255 SCONST;
#line 2816 "test-new/nrimp10s-77.imp"
_imp_string255 NAMTXT;
// 2817 %INTEGERNAME STPTR
#line 2817 "test-new/nrimp10s-77.imp"
int *STPTR;
// 2818 LPUTP=5; STPTR==USTPTR; ! NORMAL CASE GLA SYMBOLTABLES
#line 2818 "test-new/nrimp10s-77.imp"
LPUTP = 5;
#line 2818 "test-new/nrimp10s-77.imp"
STPTR = (int *)/*?*/ &USTPTR;
// 2819 ! FAULT(40,0) %IF NMDECS&1#0
// 2820 EXTRN=A(P+1)
#line 2820 "test-new/nrimp10s-77.imp"
EXTRN = A[P + 1];
// 2821 %IF EXTRN>=4 %THEN EXTRN=0; ! CONST & CONSTANT->0
#line 2821 "test-new/nrimp10s-77.imp"
if (EXTRN < 4) goto L_0231;
#line 2821 "test-new/nrimp10s-77.imp"
EXTRN = 0;
#line 2821 "test-new/nrimp10s-77.imp"
L_0231:;
// 2822 LITL=EXTRN
#line 2822 "test-new/nrimp10s-77.imp"
LITL = EXTRN;
// 2823 %IF LITL<=1 %THEN LITL=LITL!!1
#line 2823 "test-new/nrimp10s-77.imp"
if (LITL > 1) goto L_0232;
#line 2823 "test-new/nrimp10s-77.imp"
LITL = LITL ^ 1;
#line 2823 "test-new/nrimp10s-77.imp"
L_0232:;
// 2824 KFORM=0; SNDISP=0
#line 2824 "test-new/nrimp10s-77.imp"
KFORM = 0;
#line 2824 "test-new/nrimp10s-77.imp"
SNDISP = 0;
// 2825 CONSTS FOUND=0
#line 2825 "test-new/nrimp10s-77.imp"
CONSTSFOUND = 0;
// 2826 %IF EXTRN=0 %THEN LPUTP=4 %AND STPTR==SSTL
#line 2826 "test-new/nrimp10s-77.imp"
if (EXTRN != 0) goto L_0233;
#line 2826 "test-new/nrimp10s-77.imp"
LPUTP = 4;
#line 2826 "test-new/nrimp10s-77.imp"
STPTR = (int *)/*?*/ &SSTL;
#line 2826 "test-new/nrimp10s-77.imp"
L_0233:;
// 2827 P=P+3; CBASE=0
#line 2827 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 2827 "test-new/nrimp10s-77.imp"
CBASE = 0;
// 2828 MODE=A(P-1); ! MODE =1 FOR NORMAL OWNS
#line 2828 "test-new/nrimp10s-77.imp"
MODE = A[P - 1];
// 2829 ->RECORD %IF MODE>1; ! MODE =2 FOR OWN RECORDS
#line 2829 "test-new/nrimp10s-77.imp"
if (MODE <= 1) goto L_0234;
#line 2829 "test-new/nrimp10s-77.imp"
goto U_101C;
#line 2829 "test-new/nrimp10s-77.imp"
L_0234:;
// 2830 CLT; ! MODE =3 FOR OWN RECORD ARRAYS
#line 2830 "test-new/nrimp10s-77.imp"
CLT();
// 2831 %IF A(P)=1 %THEN CQN(P+1) %ELSE ARR=1 %AND NAM=0
#line 2831 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0235;
#line 2831 "test-new/nrimp10s-77.imp"
CQN(P + 1);
#line 2831 "test-new/nrimp10s-77.imp"
goto L_0236;
#line 2831 "test-new/nrimp10s-77.imp"
L_0235:;
#line 2831 "test-new/nrimp10s-77.imp"
ARR = 1;
#line 2831 "test-new/nrimp10s-77.imp"
NAM = 0;
#line 2831 "test-new/nrimp10s-77.imp"
L_0236:;
// 2832 %IF TYPE=5 %AND ACC=0=NAM %THEN FAULT(70,0) %AND ACC=2
#line 2832 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_0237;
#line 2832 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 2832 "test-new/nrimp10s-77.imp"
int tmp;
#line 2832 "test-new/nrimp10s-77.imp"
if (ACC != (tmp = 0)) goto L_0237;
// Double-sided test on 0 (Part II)
#line 2832 "test-new/nrimp10s-77.imp"
if (tmp != NAM) goto L_0237;
#line 2832 "test-new/nrimp10s-77.imp"
}
#line 2832 "test-new/nrimp10s-77.imp"
FAULT(70, 0);
#line 2832 "test-new/nrimp10s-77.imp"
ACC = 2;
#line 2832 "test-new/nrimp10s-77.imp"
L_0237:;
// 2833 ROUT=0; PACK(PTYPE)
#line 2833 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 2833 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
// 2834 -> NON SCALAR %IF ARR#0 %AND NAM=0
#line 2834 "test-new/nrimp10s-77.imp"
if (ARR == 0) goto L_0238;
#line 2834 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_0238;
#line 2834 "test-new/nrimp10s-77.imp"
goto U_101D;
#line 2834 "test-new/nrimp10s-77.imp"
L_0238:;
// 2835 P=P+1
#line 2835 "test-new/nrimp10s-77.imp"
P = P + 1;
// 2836 {%UNTIL A(MARK)=2} %CYCLE; ! UNTIL <RESTOFOWNDEC> NULL
#line 2836 "test-new/nrimp10s-77.imp"
L_0239:;
// 2837 MARK= P+1+FROM AR2(P+1)
#line 2837 "test-new/nrimp10s-77.imp"
MARK = P + 1 + FROMAR2(P + 1);
// 2838 NNAMES=1
#line 2838 "test-new/nrimp10s-77.imp"
NNAMES = 1;
// 2839 PP=P+3; P=PP+2; ! PP ON FIRST NAME'
#line 2839 "test-new/nrimp10s-77.imp"
PP = P + 3;
#line 2839 "test-new/nrimp10s-77.imp"
P = PP + 2;
// 2840 %WHILE A(P)=1 %%CYCLE
#line 2840 "test-new/nrimp10s-77.imp"
L_023A:;
#line 2840 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_023B;
// 2841 NNAMES=NNAMES+1
#line 2841 "test-new/nrimp10s-77.imp"
NNAMES = NNAMES + 1;
// 2842 P=P+3
#line 2842 "test-new/nrimp10s-77.imp"
P = P + 3;
// 2843 %REPEAT
#line 2843 "test-new/nrimp10s-77.imp"
goto L_023A;
#line 2843 "test-new/nrimp10s-77.imp"
L_023B:;
// 2844 P=P+1; ! P ON CONST'
#line 2844 "test-new/nrimp10s-77.imp"
P = P + 1;
// 2845 !
// 2846 ! OBTAIN THE INITIAL CONSTANT,ITS TYPE(CTYPE) AND SIGN(SIGN)
// 2847 !
// 2848 ICONST=0; UICONST=0
#line 2848 "test-new/nrimp10s-77.imp"
ICONST = 0;
#line 2848 "test-new/nrimp10s-77.imp"
UICONST = 0;
// 2849 RCONST=0; LRCONST=0; SCONST=""
#line 2849 "test-new/nrimp10s-77.imp"
RCONST = 0;
#line 2849 "test-new/nrimp10s-77.imp"
LRCONST = 0;
#line 2849 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &SCONST, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = _imp_str_literal("");
(void *)&tmp;
}),
/*max:*/ 255);
// 2850 SIGN=3; CTYPE=TYPE; CONSTSFOUND=0; CPREC=PREC
#line 2850 "test-new/nrimp10s-77.imp"
SIGN = 3;
#line 2850 "test-new/nrimp10s-77.imp"
CTYPE = TYPE;
#line 2850 "test-new/nrimp10s-77.imp"
CONSTSFOUND = 0;
#line 2850 "test-new/nrimp10s-77.imp"
CPREC = PREC;
// 2851 %IF NAM#0 %THEN CTYPE=1 %AND CPREC=5
#line 2851 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_023C;
#line 2851 "test-new/nrimp10s-77.imp"
CTYPE = 1;
#line 2851 "test-new/nrimp10s-77.imp"
CPREC = 5;
#line 2851 "test-new/nrimp10s-77.imp"
L_023C:;
// 2852 !
// 2853 %IF A(P)=1 %THEN %START; ! CONSTANT GIVEN
#line 2853 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_023D;
// 2854 P=P+1
#line 2854 "test-new/nrimp10s-77.imp"
P = P + 1;
// 2855 XTRACT CONST(CTYPE,CPREC)
#line 2855 "test-new/nrimp10s-77.imp"
XTRACTCONST(CTYPE, CPREC);
// 2856 %FINISH
#line 2856 "test-new/nrimp10s-77.imp"
L_023D:;
// 2857 !
// 2858 {%UNTIL NNAMES=0} %CYCLE; ! DOWN <NAMELIST>
#line 2858 "test-new/nrimp10s-77.imp"
L_023E:;
// 2859 J=0; K=FROM AR2(PP)
#line 2859 "test-new/nrimp10s-77.imp"
J = 0;
#line 2859 "test-new/nrimp10s-77.imp"
K = FROMAR2(PP);
// 2860 NAMTXT=STRING(DICTBASE+WORD(K))
#line 2860 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &NAMTXT, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = *_imp_STRING(DICTBASE + WORD[K]);
(void *)&tmp;
}),
/*max:*/ 255);
// 2861 %IF NAM#0 %THEN %START; ! OWNNAMES AND ARRAYNAMES
#line 2861 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_023F;
// 2862 %IF EXTRN=3 %THEN FAULT2(46,0,K);! NO EXTRINSIC NAMES
#line 2862 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0240;
#line 2862 "test-new/nrimp10s-77.imp"
FAULT2(46, 0, K);
#line 2862 "test-new/nrimp10s-77.imp"
L_0240:;
// 2863 UICONST=16_FFFF!PREC<<27
#line 2863 "test-new/nrimp10s-77.imp"
UICONST = 65535 | PREC << 27;
// 2864 PGLA(8,ACC,ADDR(UICONST))
#line 2864 "test-new/nrimp10s-77.imp"
PGLA(8, ACC, _imp_ADDR(/*?*/ &UICONST));
// 2865 TAGDISP=GLACA-ACC; EPDISP=TAGDISP
#line 2865 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - ACC;
#line 2865 "test-new/nrimp10s-77.imp"
EPDISP = TAGDISP;
// 2866 %FINISH %ELSE %START
#line 2866 "test-new/nrimp10s-77.imp"
goto L_0241;
#line 2866 "test-new/nrimp10s-77.imp"
L_023F:;
// 2867 %IF TYPE=5 %THEN %START; ! STRING
#line 2867 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_0242;
// 2868 QQ=STPTR; AD=ADDR(SCONST)
#line 2868 "test-new/nrimp10s-77.imp"
QQ = *STPTR;
#line 2868 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &SCONST);
// 2869 %IF EXTRN=3 %THEN %START; ! EXTRINSIC STRINGS
#line 2869 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0243;
// 2870 AH3=0; AH2=PREC<<27!ACC; ! DUMMY STRING HEADER
#line 2870 "test-new/nrimp10s-77.imp"
AH3 = 0;
#line 2870 "test-new/nrimp10s-77.imp"
AH2 = PREC << 27 | ACC;
// 2871 %FINISH %ELSE %START
#line 2871 "test-new/nrimp10s-77.imp"
goto L_0244;
#line 2871 "test-new/nrimp10s-77.imp"
L_0243:;
// 2872 LPUT(LPUTP,ACC,QQ,AD) %IF INHCODE=0;! O/P STRING
#line 2872 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0245;
#line 2872 "test-new/nrimp10s-77.imp"
LPUT(LPUTP, ACC, QQ, AD);
#line 2872 "test-new/nrimp10s-77.imp"
L_0245:;
// 2873 STPTR=(STPTR+ACC+3)&(-4)
#line 2873 "test-new/nrimp10s-77.imp"
*STPTR = *STPTR + ACC + 3 & -4;
// 2874 AH3=QQ; AH2=3<<27!ACC
#line 2874 "test-new/nrimp10s-77.imp"
AH3 = QQ;
#line 2874 "test-new/nrimp10s-77.imp"
AH2 = 3 << 27 | ACC;
// 2875 %FINISH
#line 2875 "test-new/nrimp10s-77.imp"
L_0244:;
// 2876 PGLA(8,8,ADDR(AH2))
#line 2876 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &AH2));
// 2877 TAGDISP=GLACA-8
#line 2877 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - 8;
// 2878 %IF EXTRN=3 %THEN GXREF(NAMTXT,2,2<<24!ACC,TAGDISP+4) %ELSE RELOCATE(TAGDISP+4,AH3,LPUTP)
#line 2878 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0246;
#line 2878 "test-new/nrimp10s-77.imp"
GXREF(
#line 2878 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = NAMTXT /*q*/;
(_imp_string31 *)&tmp;
})
#line 2878 "test-new/nrimp10s-77.imp"
,
2, 2 << 24 | ACC, TAGDISP + 4);
#line 2878 "test-new/nrimp10s-77.imp"
goto L_0247;
#line 2878 "test-new/nrimp10s-77.imp"
L_0246:;
#line 2878 "test-new/nrimp10s-77.imp"
RELOCATE(TAGDISP + 4, AH3, LPUTP);
#line 2878 "test-new/nrimp10s-77.imp"
L_0247:;
// 2879 EPTYPE=5; EPDISP=QQ; ! DATA IN GLA SYMBOL TABLES
#line 2879 "test-new/nrimp10s-77.imp"
EPTYPE = 5;
#line 2879 "test-new/nrimp10s-77.imp"
EPDISP = QQ;
// 2880 %FINISH %ELSE %START; ! INTEGER & REAL
#line 2880 "test-new/nrimp10s-77.imp"
goto L_0248;
#line 2880 "test-new/nrimp10s-77.imp"
L_0242:;
// 2881 %IF EXTRN=3 %THEN %START; ! EXTRINSICS
#line 2881 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0249;
// 2882 PTYPE=PTYPE!1<<10; ! EXTRINSICS VIA PTR
#line 2882 "test-new/nrimp10s-77.imp"
PTYPE = PTYPE | 1 << 10;
// 2883 AH2=PREC<<27; AH3=0
#line 2883 "test-new/nrimp10s-77.imp"
AH2 = PREC << 27;
#line 2883 "test-new/nrimp10s-77.imp"
AH3 = 0;
// 2884 PGLA(8,8,ADDR(AH2))
#line 2884 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &AH2));
// 2885 TAGDISP=GLACA-8
#line 2885 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - 8;
// 2886 GXREF(NAMTXT,2,2<<24!ACC,TAGDISP+4)
#line 2886 "test-new/nrimp10s-77.imp"
GXREF(
#line 2886 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = NAMTXT /*q*/;
(_imp_string31 *)&tmp;
})
#line 2886 "test-new/nrimp10s-77.imp"
,
2, 2 << 24 | ACC, TAGDISP + 4);
// 2887 %FINISH %ELSE %START; ! OWN,EXTERNAL&CONST
#line 2887 "test-new/nrimp10s-77.imp"
goto L_024A;
#line 2887 "test-new/nrimp10s-77.imp"
L_0249:;
// 2888 %IF TYPE=2 %THEN %START
#line 2888 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_024B;
// 2889 AD=ADDR(RCONST)
#line 2889 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &RCONST);
// 2890 %FINISH %ELSE %START; ! INTEGER VARIABLES
#line 2890 "test-new/nrimp10s-77.imp"
goto L_024C;
#line 2890 "test-new/nrimp10s-77.imp"
L_024B:;
// 2891 AD=ADDR(ICONST)+4-ACC
#line 2891 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &ICONST) + 4 - ACC;
// 2892 %FINISH
#line 2892 "test-new/nrimp10s-77.imp"
L_024C:;
// 2893 %IF EXTRN#0 %THEN PGLA(ACC,ACC,AD); ! PUT CONSTANT INTO GLA
#line 2893 "test-new/nrimp10s-77.imp"
if (EXTRN == 0) goto L_024D;
#line 2893 "test-new/nrimp10s-77.imp"
PGLA(ACC, ACC, AD);
#line 2893 "test-new/nrimp10s-77.imp"
L_024D:;
// 2894 TAGDISP=GLACA-ACC; ! OFFSET OF VAR FOR TAGS
#line 2894 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - ACC;
// 2895 EPDISP=TAGDISP; ! AND FOR ENTRY DEFN
#line 2895 "test-new/nrimp10s-77.imp"
EPDISP = TAGDISP;
// 2896 EPTYPE=2; ! DATA IN ADRESSABLE GLA
#line 2896 "test-new/nrimp10s-77.imp"
EPTYPE = 2;
// 2897 %FINISH
#line 2897 "test-new/nrimp10s-77.imp"
L_024A:;
// 2898 %FINISH
#line 2898 "test-new/nrimp10s-77.imp"
L_0248:;
// 2899 %FINISH
#line 2899 "test-new/nrimp10s-77.imp"
L_0241:;
// 2900 STAG(TAGDISP,ACC)
#line 2900 "test-new/nrimp10s-77.imp"
STAG(TAGDISP, ACC);
// 2901 %IF EXTRN=0=NAM %START; ! CONST = LITERAL
#line 2901 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 2901 "test-new/nrimp10s-77.imp"
int tmp;
#line 2901 "test-new/nrimp10s-77.imp"
if (EXTRN != (tmp = 0)) goto L_024E;
// Double-sided test on 0 (Part II)
#line 2901 "test-new/nrimp10s-77.imp"
if (tmp != NAM) goto L_024E;
#line 2901 "test-new/nrimp10s-77.imp"
}
// 2902 REPLACE2(TAGS(K),INTEGER(AD&(-4)));! BYTES!
#line 2902 "test-new/nrimp10s-77.imp"
REPLACE2(TAGS[K], *_imp_INTEGER(AD & -4));
// 2903 %IF PREC=6 %THEN REPLACE3(TAGS(K),INTEGER(AD+4))
#line 2903 "test-new/nrimp10s-77.imp"
if (PREC != 6) goto L_024F;
#line 2903 "test-new/nrimp10s-77.imp"
REPLACE3(TAGS[K], *_imp_INTEGER(AD + 4));
#line 2903 "test-new/nrimp10s-77.imp"
L_024F:;
// 2904 %IF PREC=7 %THEN REPLACE3(TAGS(K),CONSTP)
#line 2904 "test-new/nrimp10s-77.imp"
if (PREC != 7) goto L_0250;
#line 2904 "test-new/nrimp10s-77.imp"
REPLACE3(TAGS[K], CONSTP);
#line 2904 "test-new/nrimp10s-77.imp"
L_0250:;
// 2905 %FINISH
#line 2905 "test-new/nrimp10s-77.imp"
L_024E:;
// 2906 PP=PP+3
#line 2906 "test-new/nrimp10s-77.imp"
PP = PP + 3;
// 2907 NNAMES=NNAMES-1
#line 2907 "test-new/nrimp10s-77.imp"
NNAMES = NNAMES - 1;
// 2908 %REPEAT %UNTIL NNAMES=0; ! DOWN <NAMELIST>
#line 2908 "test-new/nrimp10s-77.imp"
if (NNAMES == 0) goto L_0251;
#line 2908 "test-new/nrimp10s-77.imp"
goto L_023E;
#line 2908 "test-new/nrimp10s-77.imp"
L_0251:;
// 2909 P=MARK
#line 2909 "test-new/nrimp10s-77.imp"
P = MARK;
// 2910 %REPEAT %UNTIL A(MARK)=2; ! UNTIL <RESTOFOWNDEC> NULL
#line 2910 "test-new/nrimp10s-77.imp"
if (A[MARK] == 2) goto L_0252;
#line 2910 "test-new/nrimp10s-77.imp"
goto L_0239;
#line 2910 "test-new/nrimp10s-77.imp"
L_0252:;
// 2911 ->BEND
#line 2911 "test-new/nrimp10s-77.imp"
goto U_101E;
// 2912 RECORD: ! <XOWN>'%RECORD'<NAMELIST>
#line 2912 "test-new/nrimp10s-77.imp"
U_101C:;
// 2913 !***********************************************************************
// 2914 !* NO INITIALISATION OF OWN RECORDS ALLOWED SO THEY ARE ALL *
// 2915 !* CLEARED TO ZERO. *
// 2916 !***********************************************************************
// 2917 MARKER1=P+1+FROM AR2(P+1); ! TO FORMAT NAME
#line 2917 "test-new/nrimp10s-77.imp"
MARKER1 = P + 1 + FROMAR2(P + 1);
// 2918 FNAM=FROM AR2(MARKER1)
#line 2918 "test-new/nrimp10s-77.imp"
FNAM = FROMAR2(MARKER1);
// 2919 COPYTAG(FNAM)
#line 2919 "test-new/nrimp10s-77.imp"
COPYTAG(FNAM);
// 2920 FINF=TCELL
#line 2920 "test-new/nrimp10s-77.imp"
FINF = TCELL;
// 2921 %IF PTYPE#4 %THEN FAULT(62,FNAM) %AND ->BEND
#line 2921 "test-new/nrimp10s-77.imp"
if (PTYPE == 4) goto L_0253;
#line 2921 "test-new/nrimp10s-77.imp"
FAULT(62, FNAM);
#line 2921 "test-new/nrimp10s-77.imp"
goto U_101E;
#line 2921 "test-new/nrimp10s-77.imp"
L_0253:;
// 2922 PTYPE=16_133!LITL<<14
#line 2922 "test-new/nrimp10s-77.imp"
PTYPE = 307 | LITL << 14;
// 2923 KFORM=FINF; UNPACK
#line 2923 "test-new/nrimp10s-77.imp"
KFORM = FINF;
#line 2923 "test-new/nrimp10s-77.imp"
UNPACK();
// 2924 %IF MODE=3 %THEN FORMAT=2-A(P) %AND P=P+2 %AND ->RECIN
#line 2924 "test-new/nrimp10s-77.imp"
if (MODE != 3) goto L_0254;
#line 2924 "test-new/nrimp10s-77.imp"
FORMAT = 2 - A[P];
#line 2924 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 2924 "test-new/nrimp10s-77.imp"
goto U_101F;
#line 2924 "test-new/nrimp10s-77.imp"
L_0254:;
// 2925 P=P+1; BP=ACC; ! SIZE OF RECORD FROM FORMAT
#line 2925 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 2925 "test-new/nrimp10s-77.imp"
BP = ACC;
// 2926 PTYPE=16_33; J=0
#line 2926 "test-new/nrimp10s-77.imp"
PTYPE = 51;
#line 2926 "test-new/nrimp10s-77.imp"
J = 0;
// 2927 %IF A(P-1)#3 %THEN CQN(P-1) %AND PACK(PTYPE)
#line 2927 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 3) goto L_0255;
#line 2927 "test-new/nrimp10s-77.imp"
CQN(P - 1);
#line 2927 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
#line 2927 "test-new/nrimp10s-77.imp"
L_0255:;
// 2928 P=P+1; PTSIZE=ACC; ! SIZE OF HOLE FOR POINTER
#line 2928 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 2928 "test-new/nrimp10s-77.imp"
PTSIZE = ACC;
// 2929 {%UNTIL A(P)=2} %CYCLE
#line 2929 "test-new/nrimp10s-77.imp"
L_0256:;
// 2930 P=P+1; K=FROM AR2(P)
#line 2930 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 2930 "test-new/nrimp10s-77.imp"
K = FROMAR2(P);
// 2931 NAMTXT=STRING(DICTBASE+WORD(K))
#line 2931 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &NAMTXT, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = *_imp_STRING(DICTBASE + WORD[K]);
(void *)&tmp;
}),
/*max:*/ 255);
// 2932 %IF NAM#0 %THEN %START; ! OWNNAMES AND ARRAYNAMES
#line 2932 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_0257;
// 2933 %IF EXTRN=3 %THEN FAULT2(46,0,K);! NO EXTRINSIC NAMES
#line 2933 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0258;
#line 2933 "test-new/nrimp10s-77.imp"
FAULT2(46, 0, K);
#line 2933 "test-new/nrimp10s-77.imp"
L_0258:;
// 2934 UICONST=16_FFFF!PREC<<27
#line 2934 "test-new/nrimp10s-77.imp"
UICONST = 65535 | PREC << 27;
// 2935 PGLA(8,PTSIZE,ADDR(UICONST))
#line 2935 "test-new/nrimp10s-77.imp"
PGLA(8, PTSIZE, _imp_ADDR(/*?*/ &UICONST));
// 2936 EPTYPE=2
#line 2936 "test-new/nrimp10s-77.imp"
EPTYPE = 2;
// 2937 TAGDISP=GLACA-PTSIZE; EPDISP=TAGDISP
#line 2937 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - PTSIZE;
#line 2937 "test-new/nrimp10s-77.imp"
EPDISP = TAGDISP;
// 2938 %FINISH %ELSE %START
#line 2938 "test-new/nrimp10s-77.imp"
goto L_0259;
#line 2938 "test-new/nrimp10s-77.imp"
L_0257:;
// 2939 %IF EXTRN=3 %THEN %START; ! EXTRINISIC
#line 2939 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_025A;
// 2940 PTYPE=PTYPE!16_400; ! FORCE NAM=1 (IE VIA POINTER)
#line 2940 "test-new/nrimp10s-77.imp"
PTYPE = PTYPE | 1024;
// 2941 AH2=16_18000000+BP
#line 2941 "test-new/nrimp10s-77.imp"
AH2 = 402653184 + BP;
// 2942 AH3=0
#line 2942 "test-new/nrimp10s-77.imp"
AH3 = 0;
// 2943 PGLA(8,8,ADDR(AH2))
#line 2943 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &AH2));
// 2944 TAGDISP=GLACA-8
#line 2944 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - 8;
// 2945 GXREF(NAMTXT,2,2<<24!BP,TAGDISP+4); ! RELOCATE BY EXTERNAL
#line 2945 "test-new/nrimp10s-77.imp"
GXREF(
#line 2945 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = NAMTXT /*q*/;
(_imp_string31 *)&tmp;
})
#line 2945 "test-new/nrimp10s-77.imp"
,
2, 2 << 24 | BP, TAGDISP + 4);
// 2946 %FINISH %ELSE %START
#line 2946 "test-new/nrimp10s-77.imp"
goto L_025B;
#line 2946 "test-new/nrimp10s-77.imp"
L_025A:;
// 2947 EPDISP=(GLACA+15)&(-8)
#line 2947 "test-new/nrimp10s-77.imp"
EPDISP = GLACA + 15 & -8;
// 2948 AH3=EPDISP
#line 2948 "test-new/nrimp10s-77.imp"
AH3 = EPDISP;
// 2949 AH2=16_18000000+BP; ! TOP WORD OFDESRCIPTOR
#line 2949 "test-new/nrimp10s-77.imp"
AH2 = 402653184 + BP;
// 2950 PGLA(8,4,ADDR(AH2)); ! ADDED 18MAR76 TO FIX BUG
#line 2950 "test-new/nrimp10s-77.imp"
PGLA(8, 4, _imp_ADDR(/*?*/ &AH2));
// 2951 RELOCATE(-1,AH3,2); ! PUT DISP INTO GLA
#line 2951 "test-new/nrimp10s-77.imp"
RELOCATE(-1, AH3, 2);
// 2952 TAGDISP=EPDISP; ! AND RELOCATE REL APPROPIATE AREA
#line 2952 "test-new/nrimp10s-77.imp"
TAGDISP = EPDISP;
// 2953 EPTYPE=2; ! DATA IN GLA TABLES
#line 2953 "test-new/nrimp10s-77.imp"
EPTYPE = 2;
// 2954 I=0; ICONST=0
#line 2954 "test-new/nrimp10s-77.imp"
I = 0;
#line 2954 "test-new/nrimp10s-77.imp"
ICONST = 0;
// 2955 %WHILE I<BP %CYCLE
#line 2955 "test-new/nrimp10s-77.imp"
L_025C:;
#line 2955 "test-new/nrimp10s-77.imp"
if (I >= BP) goto L_025D;
// 2956 PGLA(4,4,ADDR(ICONST))
#line 2956 "test-new/nrimp10s-77.imp"
PGLA(4, 4, _imp_ADDR(/*?*/ &ICONST));
// 2957 I=I+4
#line 2957 "test-new/nrimp10s-77.imp"
I = I + 4;
// 2958 %REPEAT
#line 2958 "test-new/nrimp10s-77.imp"
goto L_025C;
#line 2958 "test-new/nrimp10s-77.imp"
L_025D:;
// 2959 %FINISH
#line 2959 "test-new/nrimp10s-77.imp"
L_025B:;
// 2960 %FINISH
#line 2960 "test-new/nrimp10s-77.imp"
L_0259:;
// 2961 ACC=BP; ! ACC TO SIZE OF RECORD
#line 2961 "test-new/nrimp10s-77.imp"
ACC = BP;
// 2962 STAG(TAGDISP,BP)
#line 2962 "test-new/nrimp10s-77.imp"
STAG(TAGDISP, BP);
// 2963 P=P+2
#line 2963 "test-new/nrimp10s-77.imp"
P = P + 2;
// 2964 %REPEAT %UNTIL A(P)=2
#line 2964 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_025E;
#line 2964 "test-new/nrimp10s-77.imp"
goto L_0256;
#line 2964 "test-new/nrimp10s-77.imp"
L_025E:;
// 2965 ->BEND
#line 2965 "test-new/nrimp10s-77.imp"
goto U_101E;
// 2966 NONSCALAR: ! OWN AND OWNRECORD ARRAYS
#line 2966 "test-new/nrimp10s-77.imp"
U_101D:;
// 2967 !***********************************************************************
// 2968 !* OWN ARRAYS CAN BE INITIALISED BUT ONLY ONE ARRAY CAN BE *
// 2969 !* DECLARED IN A STATEMENT.(THANK HEAVENS!) *
// 2970 !* OWN RECORD ARRAYS ARE CLEARED TO ZERO *
// 2971 !***********************************************************************
// 2972 P=P+1
#line 2972 "test-new/nrimp10s-77.imp"
P = P + 1;
// 2973 FORMAT=2-A(P)
#line 2973 "test-new/nrimp10s-77.imp"
FORMAT = 2 - A[P];
// 2974 RECIN: PP=P+1; P=P+3; NNAMES=1
#line 2974 "test-new/nrimp10s-77.imp"
U_101F:;
#line 2974 "test-new/nrimp10s-77.imp"
PP = P + 1;
#line 2974 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 2974 "test-new/nrimp10s-77.imp"
NNAMES = 1;
// 2975 K=FROM AR2(PP)
#line 2975 "test-new/nrimp10s-77.imp"
K = FROMAR2(PP);
// 2976 NAMTXT=STRING(DICTBASE+WORD(K))
#line 2976 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &NAMTXT, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = *_imp_STRING(DICTBASE + WORD[K]);
(void *)&tmp;
}),
/*max:*/ 255);
// 2977 %IF TYPE>=3 %THEN BP=ACC %ELSE BP=BYTES(PREC)
#line 2977 "test-new/nrimp10s-77.imp"
if (TYPE < 3) goto L_025F;
#line 2977 "test-new/nrimp10s-77.imp"
BP = ACC;
#line 2977 "test-new/nrimp10s-77.imp"
goto L_0260;
#line 2977 "test-new/nrimp10s-77.imp"
L_025F:;
#line 2977 "test-new/nrimp10s-77.imp"
BP = BYTES[PREC];
#line 2977 "test-new/nrimp10s-77.imp"
L_0260:;
// 2978 SACC=ACC; TYPEP=PTYPE
#line 2978 "test-new/nrimp10s-77.imp"
SACC = ACC;
#line 2978 "test-new/nrimp10s-77.imp"
TYPEP = PTYPE;
// 2979 AH4=12+DOPE VECTOR(TYPE,BP,0,K,QQ,LB)
#line 2979 "test-new/nrimp10s-77.imp"
AH4 = 12 + DOPEVECTOR(TYPE, BP, 0, K, /*?*/ &QQ, /*?*/ &LB);
// 2980 SNDISP=AH4-12; ! DV DISP (+TOP BIT FLAG)
#line 2980 "test-new/nrimp10s-77.imp"
SNDISP = AH4 - 12;
// 2981 %IF SNDISP=-1 %THEN SNDISP=0; ! BUM DOPE VECTOR
#line 2981 "test-new/nrimp10s-77.imp"
if (SNDISP != -1) goto L_0261;
#line 2981 "test-new/nrimp10s-77.imp"
SNDISP = 0;
#line 2981 "test-new/nrimp10s-77.imp"
L_0261:;
// 2982 SNDISP=(SNDISP&16_3FFFF)>>2; ! AS WORD DISPLACEMENT
#line 2982 "test-new/nrimp10s-77.imp"
SNDISP = (unsigned int)(SNDISP & 262143) >> 2;
// 2983 DIMEN=J; ! SAVE NO OF DIMENESIONS
#line 2983 "test-new/nrimp10s-77.imp"
DIMEN = J;
// 2984 ACC=SACC; PTYPE=TYPEP; UNPACK
#line 2984 "test-new/nrimp10s-77.imp"
ACC = SACC;
#line 2984 "test-new/nrimp10s-77.imp"
PTYPE = TYPEP;
#line 2984 "test-new/nrimp10s-77.imp"
UNPACK();
// 2985 %IF LB=0 %AND J=1 %AND TYPE<=3 %THEN ARR=2 %AND PACK (PTYPE)
#line 2985 "test-new/nrimp10s-77.imp"
if (LB != 0) goto L_0262;
#line 2985 "test-new/nrimp10s-77.imp"
if (J != 1) goto L_0262;
#line 2985 "test-new/nrimp10s-77.imp"
if (TYPE > 3) goto L_0262;
#line 2985 "test-new/nrimp10s-77.imp"
ARR = 2;
#line 2985 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
#line 2985 "test-new/nrimp10s-77.imp"
L_0262:;
// 2986 LENGTH=QQ//BP; ! NO OF ELEMENTS
#line 2986 "test-new/nrimp10s-77.imp"
LENGTH = ((long)QQ / (long)BP);
// 2987 SPOINT=STPTR
#line 2987 "test-new/nrimp10s-77.imp"
SPOINT = *STPTR;
// 2988 %IF MODE#3 %AND FORMAT=0 %THEN %START; ! NOT A RECORD ARRAY
#line 2988 "test-new/nrimp10s-77.imp"
if (MODE == 3) goto L_0263;
#line 2988 "test-new/nrimp10s-77.imp"
if (FORMAT != 0) goto L_0263;
// 2989 %IF A(P)=1 %THEN P=P+1 %AND INIT SPACE(QQ,LENGTH)
#line 2989 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0264;
#line 2989 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 2989 "test-new/nrimp10s-77.imp"
INITSPACE(QQ, LENGTH);
#line 2989 "test-new/nrimp10s-77.imp"
L_0264:;
// 2990 %FINISH
#line 2990 "test-new/nrimp10s-77.imp"
L_0263:;
// 2991 %IF CONSTS FOUND=0 %THEN %START;! NO CONSTANTS GIVEN
#line 2991 "test-new/nrimp10s-77.imp"
if (CONSTSFOUND != 0) goto L_0265;
// 2992 ! SO CLEAR AN AREA TO ZERO
// 2993 CONSTS FOUND=LENGTH
#line 2993 "test-new/nrimp10s-77.imp"
CONSTSFOUND = LENGTH;
// 2994 CLEAR(QQ) %UNLESS LENGTH<1 %OR EXTRN=3 %OR FORMAT#0
#line 2994 "test-new/nrimp10s-77.imp"
if (LENGTH < 1) goto L_0266;
#line 2994 "test-new/nrimp10s-77.imp"
if (EXTRN == 3) goto L_0266;
#line 2994 "test-new/nrimp10s-77.imp"
if (FORMAT != 0) goto L_0266;
#line 2994 "test-new/nrimp10s-77.imp"
CLEAR(QQ);
#line 2994 "test-new/nrimp10s-77.imp"
L_0266:;
// 2995 %FINISH %ELSE %START
#line 2995 "test-new/nrimp10s-77.imp"
goto L_0267;
#line 2995 "test-new/nrimp10s-77.imp"
L_0265:;
// 2996 FAULT2(49,0,K) %IF EXTRN=3 %OR FORMAT#0
#line 2996 "test-new/nrimp10s-77.imp"
if (EXTRN == 3) goto L_0268;
#line 2996 "test-new/nrimp10s-77.imp"
if (FORMAT == 0) goto L_0269;
#line 2996 "test-new/nrimp10s-77.imp"
L_0268:;
#line 2996 "test-new/nrimp10s-77.imp"
FAULT2(49, 0, K);
#line 2996 "test-new/nrimp10s-77.imp"
L_0269:;
// 2997 %FINISH
#line 2997 "test-new/nrimp10s-77.imp"
L_0267:;
// 2998 %IF EXTRN=3 %THEN EPDISP=0 %ELSE EPDISP=SPOINT
#line 2998 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_026A;
#line 2998 "test-new/nrimp10s-77.imp"
EPDISP = 0;
#line 2998 "test-new/nrimp10s-77.imp"
goto L_026B;
#line 2998 "test-new/nrimp10s-77.imp"
L_026A:;
#line 2998 "test-new/nrimp10s-77.imp"
EPDISP = SPOINT;
#line 2998 "test-new/nrimp10s-77.imp"
L_026B:;
// 2999 !
// 3000 ! OUTPUT AN ARRAYHEAD INTO THE GLA RELATIVE TO THE START OF THE SYMBOL-
// 3001 ! TABLES IN WHICH THE ARRAY RESIDES.
// 3002 !
// 3003 J=DIMEN; ! RESET DIMENSIONS AFTER INITTING
#line 3003 "test-new/nrimp10s-77.imp"
J = DIMEN;
// 3004 %IF TYPE<=2 %THEN AH1=PREC<<27!LENGTH %ELSE AH1=3<<27!1<<25!QQ
#line 3004 "test-new/nrimp10s-77.imp"
if (TYPE > 2) goto L_026C;
#line 3004 "test-new/nrimp10s-77.imp"
AH1 = PREC << 27 | LENGTH;
#line 3004 "test-new/nrimp10s-77.imp"
goto L_026D;
#line 3004 "test-new/nrimp10s-77.imp"
L_026C:;
#line 3004 "test-new/nrimp10s-77.imp"
AH1 = 3 << 27 | 1 << 25 | QQ;
#line 3004 "test-new/nrimp10s-77.imp"
L_026D:;
// 3005 AH1=AH1!(1-PARMARR)<<24; ! SET BCI IF BASE TO BE SHIFTED
#line 3005 "test-new/nrimp10s-77.imp"
AH1 = AH1 | 1 - PARMARR << 24;
// 3006 %IF PREC=4 %THEN AH1=16_58000002
#line 3006 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_026E;
#line 3006 "test-new/nrimp10s-77.imp"
AH1 = 1476395010;
#line 3006 "test-new/nrimp10s-77.imp"
L_026E:;
// 3007 AH2=EPDISP
#line 3007 "test-new/nrimp10s-77.imp"
AH2 = EPDISP;
// 3008 AH3=5<<27!3*J; ! DV DESPTR = WORD CHKD
#line 3008 "test-new/nrimp10s-77.imp"
AH3 = 5 << 27 | 3 * J;
// 3009 %IF TYPE<=3 %AND PARMARR=0=FORMAT %AND PARMCHK=0 %AND J=1 %THEN AH2=AH2-BP*LB
#line 3009 "test-new/nrimp10s-77.imp"
if (TYPE > 3) goto L_026F;
#line 3009 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 3009 "test-new/nrimp10s-77.imp"
int tmp;
#line 3009 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_026F;
// Double-sided test on 0 (Part II)
#line 3009 "test-new/nrimp10s-77.imp"
if (tmp != FORMAT) goto L_026F;
#line 3009 "test-new/nrimp10s-77.imp"
}
#line 3009 "test-new/nrimp10s-77.imp"
if (PARMCHK != 0) goto L_026F;
#line 3009 "test-new/nrimp10s-77.imp"
if (J != 1) goto L_026F;
#line 3009 "test-new/nrimp10s-77.imp"
AH2 = AH2 - BP * LB;
#line 3009 "test-new/nrimp10s-77.imp"
L_026F:;
// 3010 PGLA(8,16,ADDR(AH1))
#line 3010 "test-new/nrimp10s-77.imp"
PGLA(8, 16, _imp_ADDR(/*?*/ &AH1));
// 3011 TAGDISP=GLACA-16
#line 3011 "test-new/nrimp10s-77.imp"
TAGDISP = GLACA - 16;
// 3012 %IF EXTRN=3 %THEN %START; ! EXTRINSIC ARRAYS
#line 3012 "test-new/nrimp10s-77.imp"
if (EXTRN != 3) goto L_0270;
// 3013 GXREF(NAMTXT,2,2<<24!QQ,TAGDISP+4); ! RELOCATE ADDR(A(FIRST))
#line 3013 "test-new/nrimp10s-77.imp"
GXREF(
#line 3013 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string255) tmp = NAMTXT /*q*/;
(_imp_string31 *)&tmp;
})
#line 3013 "test-new/nrimp10s-77.imp"
,
2, 2 << 24 | QQ, TAGDISP + 4);
// 3014 %FINISH %ELSE %START
#line 3014 "test-new/nrimp10s-77.imp"
goto L_0271;
#line 3014 "test-new/nrimp10s-77.imp"
L_0270:;
// 3015 RELOCATE(TAGDISP+4,AH2,LPUTP);! RELOCATE ADDR(A(FIRST))
#line 3015 "test-new/nrimp10s-77.imp"
RELOCATE(TAGDISP + 4, AH2, LPUTP);
// 3016 %FINISH
#line 3016 "test-new/nrimp10s-77.imp"
L_0271:;
// 3017 RELOCATE(TAGDISP+12,AH4,1); ! RELOCATE DV POINTER
#line 3017 "test-new/nrimp10s-77.imp"
RELOCATE(TAGDISP + 12, AH4, 1);
// 3018 AH4=(AH4<<1>>3)!16_80000000
#line 3018 "test-new/nrimp10s-77.imp"
AH4 = (unsigned int)AH4 << 1 >> 3 | -2147483648;
// 3019 NOTE CREF(AH4!(TAGDISP+12)>>2<<16,(AH4&16_FFFF)<<2)
#line 3019 "test-new/nrimp10s-77.imp"
NOTECREF(AH4 | (unsigned int)TAGDISP + 12 >> 2 << 16, (AH4 & 65535) << 2);
// 3020 EPTYPE=5; ! DATA IN GLA SYMBOL TABLES
#line 3020 "test-new/nrimp10s-77.imp"
EPTYPE = 5;
// 3021 STAG(TAGDISP,QQ)
#line 3021 "test-new/nrimp10s-77.imp"
STAG(TAGDISP, QQ);
// 3022 -> BEND
#line 3022 "test-new/nrimp10s-77.imp"
goto U_101E;
// 3023 %ROUTINE INIT SPACE(%INTEGER SIZE,NELS)
#line 3023 "test-new/nrimp10s-77.imp"
void INITSPACE(int SIZE, int NELS) {
// 3024 !***********************************************************************
// 3025 !* P IS TO FIRST ENTRY FOR CONSTLIST *
// 3026 !* MAP SPACE ONTO WORKFILE END TO GIVE SANE ERROR MESSAGE IF *
// 3027 !* THERE WAS NOT ENOUGH SPACE *
// 3028 !***********************************************************************
// 3029 %INTEGER RF,I,K,ELSIZE,AD,SPP,LENGTH,SAVER,WSIZE,WRIT
#line 3029 "test-new/nrimp10s-77.imp"
int RF;
#line 3029 "test-new/nrimp10s-77.imp"
int I;
#line 3029 "test-new/nrimp10s-77.imp"
int K;
#line 3029 "test-new/nrimp10s-77.imp"
int ELSIZE;
#line 3029 "test-new/nrimp10s-77.imp"
int AD;
#line 3029 "test-new/nrimp10s-77.imp"
int SPP;
#line 3029 "test-new/nrimp10s-77.imp"
int LENGTH;
#line 3029 "test-new/nrimp10s-77.imp"
int SAVER;
#line 3029 "test-new/nrimp10s-77.imp"
int WSIZE;
#line 3029 "test-new/nrimp10s-77.imp"
int WRIT;
// 3030 {%BYTEINTEGERARRAYNAME SP
// 3031
// 3032 %IF SIZE>4096 %THEN WSIZE=4096 %ELSE WSIZE=SIZE
#line 3032 "test-new/nrimp10s-77.imp"
if (SIZE <= 4096) goto L_0272;
#line 3032 "test-new/nrimp10s-77.imp"
WSIZE = 4096;
#line 3032 "test-new/nrimp10s-77.imp"
goto L_0273;
#line 3032 "test-new/nrimp10s-77.imp"
L_0272:;
#line 3032 "test-new/nrimp10s-77.imp"
WSIZE = SIZE;
#line 3032 "test-new/nrimp10s-77.imp"
L_0273:;
// 3033 {%BYTEINTEGERARRAYFORMAT SPF(0:WSIZE+256)
// 3034 SAVER=R; R=R+WSIZE+256
#line 3034 "test-new/nrimp10s-77.imp"
SAVER = R;
#line 3034 "test-new/nrimp10s-77.imp"
R = R + WSIZE + 256;
// 3035 %IF R>ARSIZE %THEN FAULT(102,0)
#line 3035 "test-new/nrimp10s-77.imp"
if (R <= ARSIZE) goto L_0274;
#line 3035 "test-new/nrimp10s-77.imp"
FAULT(102, 0);
#line 3035 "test-new/nrimp10s-77.imp"
L_0274:;
// 3036 %byteintegerarray SP(0:WSIZE+256)
#line 3036 "test-new/nrimp10s-77.imp"
unsigned char SP[WSIZE + 256 + 1];
// 3037 {SP==ARRAY(ADDR(A(SAVER)),SPF)
// 3038 %IF TYPE=1 %THEN AD=ADDR(ICONST)+4-ACC
#line 3038 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0275;
#line 3038 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &ICONST) + 4 - ACC;
#line 3038 "test-new/nrimp10s-77.imp"
L_0275:;
// 3039 %IF TYPE=2 %THEN AD=ADDR(RCONST)
#line 3039 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_0276;
#line 3039 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &RCONST);
#line 3039 "test-new/nrimp10s-77.imp"
L_0276:;
// 3040 %IF TYPE=5 %THEN AD=ADDR(SCONST)
#line 3040 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_0277;
#line 3040 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &SCONST);
#line 3040 "test-new/nrimp10s-77.imp"
L_0277:;
// 3041 SPP=0; WRIT=0
#line 3041 "test-new/nrimp10s-77.imp"
SPP = 0;
#line 3041 "test-new/nrimp10s-77.imp"
WRIT = 0;
// 3042 ELSIZE=SIZE//NELS
#line 3042 "test-new/nrimp10s-77.imp"
ELSIZE = ((long)SIZE / (long)NELS);
// 3043 {%UNTIL A(P-1)=2} %CYCLE
#line 3043 "test-new/nrimp10s-77.imp"
L_0278:;
// 3044 XTRACT CONST(TYPE,PREC)
#line 3044 "test-new/nrimp10s-77.imp"
XTRACTCONST(TYPE, PREC);
// 3045 %IF A(P)=1 %START; ! REPITITION FACTOR
#line 3045 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0279;
// 3046 P=P+1
#line 3046 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3047 %IF INTEXP(RF)#0 %THEN FAULT(44,CONSTS FOUND) %AND RF=1
#line 3047 "test-new/nrimp10s-77.imp"
if (INTEXP(/*?*/ &RF) == 0) goto L_027A;
#line 3047 "test-new/nrimp10s-77.imp"
FAULT(44, CONSTSFOUND);
#line 3047 "test-new/nrimp10s-77.imp"
RF = 1;
#line 3047 "test-new/nrimp10s-77.imp"
L_027A:;
// 3048 P=P+1
#line 3048 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3049 %FINISH %ELSE RF=1 %AND P=P+2
#line 3049 "test-new/nrimp10s-77.imp"
goto L_027B;
#line 3049 "test-new/nrimp10s-77.imp"
L_0279:;
#line 3049 "test-new/nrimp10s-77.imp"
RF = 1;
#line 3049 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3049 "test-new/nrimp10s-77.imp"
L_027B:;
// 3050 FAULT(44,CONSTS FOUND) %IF RF<=0
#line 3050 "test-new/nrimp10s-77.imp"
if (RF > 0) goto L_027C;
#line 3050 "test-new/nrimp10s-77.imp"
FAULT(44, CONSTSFOUND);
#line 3050 "test-new/nrimp10s-77.imp"
L_027C:;
// 3051 %CYCLE I=RF,-1,1
#line 3051 "test-new/nrimp10s-77.imp"
// %for I = RF, -1, 1 %cycle
#line 3051 "test-new/nrimp10s-77.imp"
{
int _control, _initial = RF, _increment = -1, _final = 1;
#line 3051 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = RF, -1, 1");
_control = I = _initial - _increment;
#line 3051 "test-new/nrimp10s-77.imp"
L_027D:
#line 3051 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 3051 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_027E;
#line 3051 "test-new/nrimp10s-77.imp"
_control += _increment;
I -= 1;
// 3052 %CYCLE K=0,1,ELSIZE-1
#line 3052 "test-new/nrimp10s-77.imp"
// %for K = 0, 1, ELSIZE - 1 %cycle
#line 3052 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = ELSIZE - 1;
#line 3052 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle K = 0, 1, ELSIZE - 1");
_control = K = _initial - _increment;
#line 3052 "test-new/nrimp10s-77.imp"
L_0280:
#line 3052 "test-new/nrimp10s-77.imp"
if (K != _control) _imp_signal(4, 2, 0, "Corrupt control variable K");
#line 3052 "test-new/nrimp10s-77.imp"
if (K == _final) goto L_0281;
#line 3052 "test-new/nrimp10s-77.imp"
_control += _increment;
K += _increment;
// 3053 %IF CONSTS FOUND<=NELS %THEN SP(SPP)=BYTE INTEGER(AD+K) %AND SPP=SPP+1
#line 3053 "test-new/nrimp10s-77.imp"
if (CONSTSFOUND > NELS) goto L_0282;
#line 3053 "test-new/nrimp10s-77.imp"
SP[SPP] = *_imp_BYTEINTEGER(AD + K);
#line 3053 "test-new/nrimp10s-77.imp"
SPP = SPP + 1;
#line 3053 "test-new/nrimp10s-77.imp"
L_0282:;
// 3054 %REPEAT
#line 3054 "test-new/nrimp10s-77.imp"
goto L_0280;
#line 3054 "test-new/nrimp10s-77.imp"
}
#line 3054 "test-new/nrimp10s-77.imp"
L_0281:;
// 3055 CONSTS FOUND=CONSTS FOUND+1
#line 3055 "test-new/nrimp10s-77.imp"
CONSTSFOUND = CONSTSFOUND + 1;
// 3056 %IF SPP>=4096 %START; ! EMPTY BUFFER
#line 3056 "test-new/nrimp10s-77.imp"
if (SPP < 4096) goto L_0283;
// 3057 LPUT(LPUTP,SPP,STPTR+WRIT,ADDR(SP(0))) %IF INHCODE=0
#line 3057 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0284;
#line 3057 "test-new/nrimp10s-77.imp"
LPUT(LPUTP, SPP, *STPTR + WRIT, _imp_ADDR(/*?*/ &SP[0]));
#line 3057 "test-new/nrimp10s-77.imp"
L_0284:;
// 3058 WRIT=WRIT+SPP
#line 3058 "test-new/nrimp10s-77.imp"
WRIT = WRIT + SPP;
// 3059 SPP=0
#line 3059 "test-new/nrimp10s-77.imp"
SPP = 0;
// 3060 %FINISH
#line 3060 "test-new/nrimp10s-77.imp"
L_0283:;
// 3061 %REPEAT
#line 3061 "test-new/nrimp10s-77.imp"
goto L_027D;
#line 3061 "test-new/nrimp10s-77.imp"
}
#line 3061 "test-new/nrimp10s-77.imp"
L_027E:;
// 3062 %REPEAT %UNTIL A(P-1)=2; ! UNTIL P<ROCL>=%NULL
#line 3062 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_0285;
#line 3062 "test-new/nrimp10s-77.imp"
goto L_0278;
#line 3062 "test-new/nrimp10s-77.imp"
L_0285:;
// 3063 %IF CONSTS FOUND#NELS %THEN FAULT(45,CONSTS FOUND)
#line 3063 "test-new/nrimp10s-77.imp"
if (CONSTSFOUND == NELS) goto L_0286;
#line 3063 "test-new/nrimp10s-77.imp"
FAULT(45, CONSTSFOUND);
#line 3063 "test-new/nrimp10s-77.imp"
L_0286:;
// 3064 STPTR=(STPTR+3)&(-4)
#line 3064 "test-new/nrimp10s-77.imp"
*STPTR = *STPTR + 3 & -4;
// 3065 LENGTH=(SIZE+3)&(-4)
#line 3065 "test-new/nrimp10s-77.imp"
LENGTH = SIZE + 3 & -4;
// 3066 LPUT(LPUTP,LENGTH-WRIT,STPTR+WRIT,ADDR(SP(0))) %IF INHCODE=0
#line 3066 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0287;
#line 3066 "test-new/nrimp10s-77.imp"
LPUT(LPUTP, LENGTH - WRIT, *STPTR + WRIT, _imp_ADDR(/*?*/ &SP[0]));
#line 3066 "test-new/nrimp10s-77.imp"
L_0287:;
// 3067 STPTR=STPTR+LENGTH
#line 3067 "test-new/nrimp10s-77.imp"
*STPTR = *STPTR + LENGTH;
// 3068 R=SAVER
#line 3068 "test-new/nrimp10s-77.imp"
R = SAVER;
// 3069 %END
#line 3069 "test-new/nrimp10s-77.imp"
return;
#line 3069 "test-new/nrimp10s-77.imp"
} /* end of INITSPACE */
// 3070 %ROUTINE CLEAR(%INTEGER LENGTH)
#line 3070 "test-new/nrimp10s-77.imp"
void CLEAR(int LENGTH) {
// 3071 STPTR=(STPTR+3)&(-4)
#line 3071 "test-new/nrimp10s-77.imp"
*STPTR = *STPTR + 3 & -4;
// 3072 LENGTH=(LENGTH+3)&(-4)
#line 3072 "test-new/nrimp10s-77.imp"
LENGTH = LENGTH + 3 & -4;
// 3073 LPUT(LPUTP,LENGTH,STPTR,0)%IF INHCODE=0
#line 3073 "test-new/nrimp10s-77.imp"
if (INHCODE != 0) goto L_0288;
#line 3073 "test-new/nrimp10s-77.imp"
LPUT(LPUTP, LENGTH, *STPTR, 0);
#line 3073 "test-new/nrimp10s-77.imp"
L_0288:;
// 3074 STPTR=STPTR+LENGTH
#line 3074 "test-new/nrimp10s-77.imp"
*STPTR = *STPTR + LENGTH;
// 3075 %END
#line 3075 "test-new/nrimp10s-77.imp"
return;
#line 3075 "test-new/nrimp10s-77.imp"
} /* end of CLEAR */
// 3076 %ROUTINE STAG(%INTEGER J,DATALEN)
#line 3076 "test-new/nrimp10s-77.imp"
void STAG(int J, int DATALEN) {
// 3077 %IF EXTRN=2 %THEN LPUT(14,EPTYPE<<24!DATALEN,EPDISP,ADDR(NAMTXT))
#line 3077 "test-new/nrimp10s-77.imp"
if (EXTRN != 2) goto L_0289;
#line 3077 "test-new/nrimp10s-77.imp"
LPUT(14, EPTYPE << 24 | DATALEN, EPDISP, _imp_ADDR(/*?*/ &NAMTXT));
#line 3077 "test-new/nrimp10s-77.imp"
L_0289:;
// 3078 RBASE=CBASE
#line 3078 "test-new/nrimp10s-77.imp"
RBASE = CBASE;
// 3079 STORE TAG(K,J)
#line 3079 "test-new/nrimp10s-77.imp"
STORETAG(K, J);
// 3080 RBASE=RLEVEL
#line 3080 "test-new/nrimp10s-77.imp"
RBASE = RLEVEL;
// 3081 %END
#line 3081 "test-new/nrimp10s-77.imp"
return;
#line 3081 "test-new/nrimp10s-77.imp"
} /* end of STAG */
// 3082 %ROUTINE XTRACT CONST(%INTEGER CONTYPE,CONPREC)
#line 3082 "test-new/nrimp10s-77.imp"
void XTRACTCONST(int CONTYPE, int CONPREC) {
// 3083 !***********************************************************************
// 3084 !* P POINTS TO P<+'> OF <+'><OPERNAD><RESTOFEXPR> AND IS UPDATED*
// 3085 !* THE CONST IS CONVERTED TO REQUIRED FORM AND IF INTEGER *
// 3086 !* IS LEFT IN ICONST, IF REAL IN RCONST AND IF STRING IN SCONST *
// 3087 !***********************************************************************
// 3088 %INTEGER LENGTH,STYPE,SPREC,SACC,CPREC,MODE,I
#line 3088 "test-new/nrimp10s-77.imp"
int LENGTH;
#line 3088 "test-new/nrimp10s-77.imp"
int STYPE;
#line 3088 "test-new/nrimp10s-77.imp"
int SPREC;
#line 3088 "test-new/nrimp10s-77.imp"
int SACC;
#line 3088 "test-new/nrimp10s-77.imp"
int CPREC;
#line 3088 "test-new/nrimp10s-77.imp"
int MODE;
#line 3088 "test-new/nrimp10s-77.imp"
int I;
// 3089 STYPE=PTYPE; SACC=ACC;! MAY BE CHANGED IF CONST IS EXPR
#line 3089 "test-new/nrimp10s-77.imp"
STYPE = PTYPE;
#line 3089 "test-new/nrimp10s-77.imp"
SACC = ACC;
// 3090 %IF CONTYPE=5 %THEN %START
#line 3090 "test-new/nrimp10s-77.imp"
if (CONTYPE != 5) goto L_028A;
// 3091 CTYPE=5
#line 3091 "test-new/nrimp10s-77.imp"
CTYPE = 5;
// 3092 %IF A(P)=4 %AND A(P+1)=2 %AND A(P+2)=16_35 %AND A(P+A(P+7)+8)=2 %START
#line 3092 "test-new/nrimp10s-77.imp"
if (A[P] != 4) goto L_028B;
#line 3092 "test-new/nrimp10s-77.imp"
if (A[P + 1] != 2) goto L_028B;
#line 3092 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 53) goto L_028B;
#line 3092 "test-new/nrimp10s-77.imp"
if (A[P + A[P + 7] + 8] != 2) goto L_028B;
// 3093 SCONST=STRING(ADDR(A(P+7)))
#line 3093 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &SCONST, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = *_imp_STRING(_imp_ADDR(/*?*/ &A[P + 7]));
(void *)&tmp;
}),
/*max:*/ 255);
// 3094 LENGTH=A(P+7)
#line 3094 "test-new/nrimp10s-77.imp"
LENGTH = A[P + 7];
// 3095 P=P+A(P+7)+9
#line 3095 "test-new/nrimp10s-77.imp"
P = P + A[P + 7] + 9;
// 3096 %FINISH %ELSE %START
#line 3096 "test-new/nrimp10s-77.imp"
goto L_028C;
#line 3096 "test-new/nrimp10s-77.imp"
L_028B:;
// 3097 FAULT(44,CONSTS FOUND); SCONST=""
#line 3097 "test-new/nrimp10s-77.imp"
FAULT(44, CONSTSFOUND);
#line 3097 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &SCONST, ({
__typeof__(_imp_string255) tmp; /*B*/
tmp = _imp_str_literal("");
(void *)&tmp;
}),
/*max:*/ 255);
// 3098 LENGTH=0; P=P-3; SKIP EXP
#line 3098 "test-new/nrimp10s-77.imp"
LENGTH = 0;
#line 3098 "test-new/nrimp10s-77.imp"
P = P - 3;
#line 3098 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 3099 %FINISH
#line 3099 "test-new/nrimp10s-77.imp"
L_028C:;
// 3100 %FINISH %ELSE %START
#line 3100 "test-new/nrimp10s-77.imp"
goto L_028D;
#line 3100 "test-new/nrimp10s-77.imp"
L_028A:;
// 3101 MODE=CONPREC<<4!CONTYPE
#line 3101 "test-new/nrimp10s-77.imp"
MODE = CONPREC << 4 | CONTYPE;
// 3102 %IF CONPREC<5 %THEN MODE=CONTYPE!16_50
#line 3102 "test-new/nrimp10s-77.imp"
if (CONPREC >= 5) goto L_028E;
#line 3102 "test-new/nrimp10s-77.imp"
MODE = CONTYPE | 80;
#line 3102 "test-new/nrimp10s-77.imp"
L_028E:;
// 3103 CONSTP=CONSTEXP(MODE)
#line 3103 "test-new/nrimp10s-77.imp"
CONSTP = CONSTEXP(MODE);
// 3104 %IF CONSTP=0 %THEN FAULT(41,0) %AND CONSTP=ADDR(ZERO);! CANT EVALUATE EXPT
#line 3104 "test-new/nrimp10s-77.imp"
if (CONSTP != 0) goto L_028F;
#line 3104 "test-new/nrimp10s-77.imp"
FAULT(41, 0);
#line 3104 "test-new/nrimp10s-77.imp"
CONSTP = _imp_ADDR(/*?*/ &ZERO);
#line 3104 "test-new/nrimp10s-77.imp"
L_028F:;
// 3105 CTYPE=TYPE; CPREC=PREC
#line 3105 "test-new/nrimp10s-77.imp"
CTYPE = TYPE;
#line 3105 "test-new/nrimp10s-77.imp"
CPREC = PREC;
// 3106 %IF CTYPE=1 %THEN %START
#line 3106 "test-new/nrimp10s-77.imp"
if (CTYPE != 1) goto L_0290;
// 3107 ICONST=INTEGER(CONSTP)
#line 3107 "test-new/nrimp10s-77.imp"
ICONST = *_imp_INTEGER(CONSTP);
// 3108 %IF CONPREC=6 %THEN UICONST=ICONST %AND ICONST=INTEGER(CONSTP+4)
#line 3108 "test-new/nrimp10s-77.imp"
if (CONPREC != 6) goto L_0291;
#line 3108 "test-new/nrimp10s-77.imp"
UICONST = ICONST;
#line 3108 "test-new/nrimp10s-77.imp"
ICONST = *_imp_INTEGER(CONSTP + 4);
#line 3108 "test-new/nrimp10s-77.imp"
L_0291:;
// 3109 %FINISH %ELSE %START
#line 3109 "test-new/nrimp10s-77.imp"
goto L_0292;
#line 3109 "test-new/nrimp10s-77.imp"
L_0290:;
// 3110 RCONST=LONGREAL(CONSTP)
#line 3110 "test-new/nrimp10s-77.imp"
RCONST = *_imp_LONGREAL(CONSTP);
// 3111 %IF CONPREC=7 %THEN %START;! LONGLONGS UNALIGNED IN AR
#line 3111 "test-new/nrimp10s-77.imp"
if (CONPREC != 7) goto L_0293;
// 3112 %CYCLE I=0,1,15
#line 3112 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 15 %cycle
#line 3112 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 15;
#line 3112 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 15");
_control = I = _initial - _increment;
#line 3112 "test-new/nrimp10s-77.imp"
L_0294:
#line 3112 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 3112 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0295;
#line 3112 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 3113 BYTEINTEGER(ADDR(RCONST)+I)=BYTEINTEGER(CONSTP+I)
#line 3113 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &RCONST) + I) = *_imp_BYTEINTEGER(CONSTP + I);
// 3114 %REPEAT
#line 3114 "test-new/nrimp10s-77.imp"
goto L_0294;
#line 3114 "test-new/nrimp10s-77.imp"
}
#line 3114 "test-new/nrimp10s-77.imp"
L_0295:;
// 3115 %FINISH
#line 3115 "test-new/nrimp10s-77.imp"
L_0293:;
// 3116 %FINISH
#line 3116 "test-new/nrimp10s-77.imp"
L_0292:;
// 3117 %FINISH
#line 3117 "test-new/nrimp10s-77.imp"
L_028D:;
// 3118 PTYPE=STYPE; UNPACK; ACC=SACC
#line 3118 "test-new/nrimp10s-77.imp"
PTYPE = STYPE;
#line 3118 "test-new/nrimp10s-77.imp"
UNPACK();
#line 3118 "test-new/nrimp10s-77.imp"
ACC = SACC;
// 3119 !
// 3120 ! FAULT ANY OBVIOUS ERRORS IE:-
// 3121 ! CONSTANT FOR EXTRINSIC OR INCOMPATIBLE TYPE OR STRING TOO LONG
// 3122 !
// 3123 %IF EXTRN=3 %OR (CTYPE=5 %AND LENGTH>=ACC) %OR (CONTYPE=1 %AND ((CONPREC=3 %AND ICONST>255) %OR (CONPREC=4 %AND ICONST>16_FFFF))) %THEN FAULT(44,CONSTS FOUND)
#line 3123 "test-new/nrimp10s-77.imp"
if (EXTRN == 3) goto L_0297;
#line 3123 "test-new/nrimp10s-77.imp"
if (CTYPE != 5) goto L_0298;
#line 3123 "test-new/nrimp10s-77.imp"
if (LENGTH >= ACC) goto L_0297;
#line 3123 "test-new/nrimp10s-77.imp"
L_0298:;
#line 3123 "test-new/nrimp10s-77.imp"
if (CONTYPE != 1) goto L_0299;
#line 3123 "test-new/nrimp10s-77.imp"
if (CONPREC != 3) goto L_029A;
#line 3123 "test-new/nrimp10s-77.imp"
if (ICONST > 255) goto L_0297;
#line 3123 "test-new/nrimp10s-77.imp"
L_029A:;
#line 3123 "test-new/nrimp10s-77.imp"
if (CONPREC != 4) goto L_0299;
#line 3123 "test-new/nrimp10s-77.imp"
if (ICONST <= 65535) goto L_0299;
#line 3123 "test-new/nrimp10s-77.imp"
L_0297:;
#line 3123 "test-new/nrimp10s-77.imp"
FAULT(44, CONSTSFOUND);
#line 3123 "test-new/nrimp10s-77.imp"
L_0299:;
// 3124 %END
#line 3124 "test-new/nrimp10s-77.imp"
return;
#line 3124 "test-new/nrimp10s-77.imp"
} /* end of XTRACTCONST */
// ?SPREC unused
// 3125 BEND: %END; ->CSSEXIT
#line 3125 "test-new/nrimp10s-77.imp"
U_101E:;
#line 3125 "test-new/nrimp10s-77.imp"
goto end_1009;
#line 3125 "test-new/nrimp10s-77.imp"
end_1009:;
#line 3125 "test-new/nrimp10s-77.imp"
}
#line 3125 "test-new/nrimp10s-77.imp"
goto U_1015;
// 3126 SW(18):
#line 3126 "test-new/nrimp10s-77.imp"
case_SW_18:;
// 3127 ABORT
#line 3127 "test-new/nrimp10s-77.imp"
ABORT();
// 3128 SW(10):
#line 3128 "test-new/nrimp10s-77.imp"
case_SW_10:;
// 3129 %BEGIN; ! %RECORD (RDECLN)
#line 3129 "test-new/nrimp10s-77.imp"
{ /*%begin*/
// 3130 !***********************************************************************
// 3131 !* RECORDS ARE ALLOCATED AT COMPILE TIME WHEN POSSIBLE *
// 3132 !* SEE CRFORMAT FOR ACTION ON RECORD FORMAT DECLARATIONS *
// 3133 !***********************************************************************
// 3134 %INTEGER MODE,RECL,ALLOC,FNAM,FINF,NAME,OPHEAD
#line 3134 "test-new/nrimp10s-77.imp"
int MODE;
#line 3134 "test-new/nrimp10s-77.imp"
int RECL;
#line 3134 "test-new/nrimp10s-77.imp"
int ALLOC;
#line 3134 "test-new/nrimp10s-77.imp"
int FNAM;
#line 3134 "test-new/nrimp10s-77.imp"
int FINF;
#line 3134 "test-new/nrimp10s-77.imp"
int NAME;
#line 3134 "test-new/nrimp10s-77.imp"
int OPHEAD;
// 3135 P=P+1; MODE=A(P); SNDISP=0
#line 3135 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3135 "test-new/nrimp10s-77.imp"
MODE = A[P];
#line 3135 "test-new/nrimp10s-77.imp"
SNDISP = 0;
// 3136 %IF MODE=1 %THEN %START; ! DEAL WITH FORMAT
#line 3136 "test-new/nrimp10s-77.imp"
if (MODE != 1) goto L_029B;
// 3137 NAME=FROM AR2(P+1); P=P+3
#line 3137 "test-new/nrimp10s-77.imp"
NAME = FROMAR2(P + 1);
#line 3137 "test-new/nrimp10s-77.imp"
P = P + 3;
// 3138 CRFORMAT(OPHEAD); K=NAME
#line 3138 "test-new/nrimp10s-77.imp"
CRFORMAT(/*?*/ &OPHEAD);
#line 3138 "test-new/nrimp10s-77.imp"
K = NAME;
// 3139 PTYPE=4; J=0
#line 3139 "test-new/nrimp10s-77.imp"
PTYPE = 4;
#line 3139 "test-new/nrimp10s-77.imp"
J = 0;
// 3140 KFORM=OPHEAD
#line 3140 "test-new/nrimp10s-77.imp"
KFORM = OPHEAD;
// 3141 STORE TAG(K,OPHEAD)
#line 3141 "test-new/nrimp10s-77.imp"
STORETAG(K, OPHEAD);
// 3142 ->BEND
#line 3142 "test-new/nrimp10s-77.imp"
goto U_1020;
// 3143 %FINISH
#line 3143 "test-new/nrimp10s-77.imp"
L_029B:;
// 3144 P=P+1; MARKER=P+FROM AR2(P)
#line 3144 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3144 "test-new/nrimp10s-77.imp"
MARKER = P + FROMAR2(P);
// 3145 FNAM=FROM AR2(MARKER); ! FORMAT NAME
#line 3145 "test-new/nrimp10s-77.imp"
FNAM = FROMAR2(MARKER);
// 3146 COPY TAG(FNAM)
#line 3146 "test-new/nrimp10s-77.imp"
COPYTAG(FNAM);
// 3147 FINF=TCELL
#line 3147 "test-new/nrimp10s-77.imp"
FINF = TCELL;
// 3148 %IF TYPE#4 %THEN %START
#line 3148 "test-new/nrimp10s-77.imp"
if (TYPE == 4) goto L_029C;
// 3149 FINF=DUMMY FORMAT
#line 3149 "test-new/nrimp10s-77.imp"
FINF = DUMMYFORMAT;
// 3150 ACC=4; FAULT(62,FNAM)
#line 3150 "test-new/nrimp10s-77.imp"
ACC = 4;
#line 3150 "test-new/nrimp10s-77.imp"
FAULT(62, FNAM);
// 3151 %FINISH
#line 3151 "test-new/nrimp10s-77.imp"
L_029C:;
// 3152 RECL=ACC
#line 3152 "test-new/nrimp10s-77.imp"
RECL = ACC;
// 3153 %IF MODE=2%THEN %START; ! '%RECORDSPEC'
#line 3153 "test-new/nrimp10s-77.imp"
if (MODE != 2) goto L_029D;
// 3154 COPY TAG(FROM AR2(P+2))
#line 3154 "test-new/nrimp10s-77.imp"
COPYTAG(FROMAR2(P + 2));
// 3155 %IF A(P+4)=1 %AND TYPE=4 %START;! SPEC FOR FORMAT ELEMENT
#line 3155 "test-new/nrimp10s-77.imp"
if (A[P + 4] != 1) goto L_029E;
#line 3155 "test-new/nrimp10s-77.imp"
if (TYPE != 4) goto L_029E;
// 3156 P=P+5
#line 3156 "test-new/nrimp10s-77.imp"
P = P + 5;
// 3157 Q=DISPLACEMENT(TCELL)
#line 3157 "test-new/nrimp10s-77.imp"
Q = DISPLACEMENT(TCELL);
// 3158 UNPACK
#line 3158 "test-new/nrimp10s-77.imp"
UNPACK();
// 3159 %FINISH
#line 3159 "test-new/nrimp10s-77.imp"
L_029E:;
// 3160 %IF TYPE=3 %AND NAM=1 %AND FROM3(TCELL)&16_FFFF=0 %START
#line 3160 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_029F;
#line 3160 "test-new/nrimp10s-77.imp"
if (NAM != 1) goto L_029F;
#line 3160 "test-new/nrimp10s-77.imp"
if (FROM3(TCELL) & 65535 != 0) goto L_029F;
// 3161 REPLACE3(TCELL,FINF!K<<16)
#line 3161 "test-new/nrimp10s-77.imp"
REPLACE3(TCELL, FINF | K << 16);
// 3162 REPLACE2(TCELL,SNDISP<<16!RECL)
#line 3162 "test-new/nrimp10s-77.imp"
REPLACE2(TCELL, SNDISP << 16 | RECL);
// 3163 %FINISH %ELSE FAULT(63,0)
#line 3163 "test-new/nrimp10s-77.imp"
goto L_02A0;
#line 3163 "test-new/nrimp10s-77.imp"
L_029F:;
#line 3163 "test-new/nrimp10s-77.imp"
FAULT(63, 0);
#line 3163 "test-new/nrimp10s-77.imp"
L_02A0:;
// 3164 %FINISH %ELSE %START; ! RECORD DECLARATION
#line 3164 "test-new/nrimp10s-77.imp"
goto L_02A1;
#line 3164 "test-new/nrimp10s-77.imp"
L_029D:;
// 3165 FAULT(57,0) %UNLESS LEVEL>=2
#line 3165 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_02A2;
#line 3165 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 3165 "test-new/nrimp10s-77.imp"
L_02A2:;
// 3166 FAULT(40,0) %IF NMDECS(LEVEL)&1#0
#line 3166 "test-new/nrimp10s-77.imp"
if (NMDECS[LEVEL] & 1 == 0) goto L_02A3;
#line 3166 "test-new/nrimp10s-77.imp"
FAULT(40, 0);
#line 3166 "test-new/nrimp10s-77.imp"
L_02A3:;
// 3167 TYPE=3; PREC=3; ROUT=0
#line 3167 "test-new/nrimp10s-77.imp"
TYPE = 3;
#line 3167 "test-new/nrimp10s-77.imp"
PREC = 3;
#line 3167 "test-new/nrimp10s-77.imp"
ROUT = 0;
// 3168 %IF A(P+2)=1 %THEN %START; ! SIMPLE RECORD AND RECORDNAMES
#line 3168 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 1) goto L_02A4;
// 3169 ALLOC=ACC; CQN(P+3)
#line 3169 "test-new/nrimp10s-77.imp"
ALLOC = ACC;
#line 3169 "test-new/nrimp10s-77.imp"
CQN(P + 3);
// 3170 ACC=ALLOC; P=P+4
#line 3170 "test-new/nrimp10s-77.imp"
ACC = ALLOC;
#line 3170 "test-new/nrimp10s-77.imp"
P = P + 4;
// 3171 DECLARE SCALARS(1,FINF)
#line 3171 "test-new/nrimp10s-77.imp"
DECLARESCALARS(1, FINF);
// 3172 %FINISH %ELSE %START; ! ARRAYS OF RECORDS
#line 3172 "test-new/nrimp10s-77.imp"
goto L_02A5;
#line 3172 "test-new/nrimp10s-77.imp"
L_02A4:;
// 3173 NAM=0
#line 3173 "test-new/nrimp10s-77.imp"
NAM = 0;
// 3174 Q=2-A(P+3); P=P+4; ! Q=1 FOR ARRAY FORMAT
#line 3174 "test-new/nrimp10s-77.imp"
Q = 2 - A[P + 3];
#line 3174 "test-new/nrimp10s-77.imp"
P = P + 4;
// 3175 SET LINE
#line 3175 "test-new/nrimp10s-77.imp"
SETLINE();
// 3176 DECLARE ARRAYS(Q,FINF)
#line 3176 "test-new/nrimp10s-77.imp"
DECLAREARRAYS(Q, FINF);
// 3177 %FINISH
#line 3177 "test-new/nrimp10s-77.imp"
L_02A5:;
// 3178 %FINISH
#line 3178 "test-new/nrimp10s-77.imp"
L_02A1:;
// 3179 BEND: %END;->CSSEXIT
#line 3179 "test-new/nrimp10s-77.imp"
U_1020:;
#line 3179 "test-new/nrimp10s-77.imp"
goto end_1010;
#line 3179 "test-new/nrimp10s-77.imp"
end_1010:;
#line 3179 "test-new/nrimp10s-77.imp"
}
#line 3179 "test-new/nrimp10s-77.imp"
goto U_1015;
// 3180 !
// 3181 SW(19):
#line 3181 "test-new/nrimp10s-77.imp"
case_SW_19:;
// 3182 ! '*' (UCI) (S)
// 3183 FAULT(57,0) %UNLESS LEVEL>=2
#line 3183 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_02A6;
#line 3183 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 3183 "test-new/nrimp10s-77.imp"
L_02A6:;
// 3184 %BEGIN
#line 3184 "test-new/nrimp10s-77.imp"
{ /*%begin*/
#line 3184 "test-new/nrimp10s-77.imp"
auto void CIND(void);
// 3185 %ROUTINESPEC CIND
// 3186 %INTEGER FNAME,ALT,OPCODE,FORM,H,Q,MASK,FILLER
#line 3186 "test-new/nrimp10s-77.imp"
int FNAME;
#line 3186 "test-new/nrimp10s-77.imp"
int ALT;
#line 3186 "test-new/nrimp10s-77.imp"
int OPCODE;
#line 3186 "test-new/nrimp10s-77.imp"
int FORM;
#line 3186 "test-new/nrimp10s-77.imp"
int H;
#line 3186 "test-new/nrimp10s-77.imp"
int Q;
#line 3186 "test-new/nrimp10s-77.imp"
int MASK;
#line 3186 "test-new/nrimp10s-77.imp"
int FILLER;
// 3187 %SWITCH SW(1:5),F(1:3),POP(1:6),TOP(1:4)
#line 3187 "test-new/nrimp10s-77.imp"
int SW_index;
#line 3187 "test-new/nrimp10s-77.imp"
int SW_line;
#line 3187 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 3187 "test-new/nrimp10s-77.imp"
static const void *SW[5] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing};
#line 3187 "test-new/nrimp10s-77.imp"
int F_index;
#line 3187 "test-new/nrimp10s-77.imp"
int F_line;
#line 3187 "test-new/nrimp10s-77.imp"
char *F_file;
#line 3187 "test-new/nrimp10s-77.imp"
static const void *F[3] = {&&case_F_missing, &&case_F_missing, &&case_F_missing};
#line 3187 "test-new/nrimp10s-77.imp"
int POP_index;
#line 3187 "test-new/nrimp10s-77.imp"
int POP_line;
#line 3187 "test-new/nrimp10s-77.imp"
char *POP_file;
#line 3187 "test-new/nrimp10s-77.imp"
static const void *POP[6] = {&&case_POP_missing, &&case_POP_missing, &&case_POP_missing,
&&case_POP_missing, &&case_POP_missing, &&case_POP_missing};
#line 3187 "test-new/nrimp10s-77.imp"
int TOP_index;
#line 3187 "test-new/nrimp10s-77.imp"
int TOP_line;
#line 3187 "test-new/nrimp10s-77.imp"
char *TOP_file;
#line 3187 "test-new/nrimp10s-77.imp"
static const void *TOP[4] = {&&case_TOP_missing, &&case_TOP_missing, &&case_TOP_missing, &&case_TOP_missing};
// 3188 ALT=A(P+1); P=P+2
#line 3188 "test-new/nrimp10s-77.imp"
ALT = A[P + 1];
#line 3188 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3189 OPCODE=CALL
#line 3189 "test-new/nrimp10s-77.imp"
OPCODE = 30;
// 3190 ->SW(ALT)
#line 3190 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = ALT;
goto case_SW_dispatch;
// 3191 SW(1):SW(2):
#line 3191 "test-new/nrimp10s-77.imp"
case_SW_1:;
#line 3191 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 3192 FNAME=FROM AR2(P)
#line 3192 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(P);
// 3193 COPY TAG(FNAME)
#line 3193 "test-new/nrimp10s-77.imp"
COPYTAG(FNAME);
// 3194 FAULT(33,FNAME) %UNLESS ROUT=NAM=0 %AND ARR=0 %AND PREC>4 %AND I=RBASE %AND TYPE#7
#line 3194 "test-new/nrimp10s-77.imp"
{
// Double-sided test on NAM (Part I)
#line 3194 "test-new/nrimp10s-77.imp"
int tmp;
#line 3194 "test-new/nrimp10s-77.imp"
if (ROUT != (tmp = NAM)) goto L_02A8;
// Double-sided test on NAM (Part II)
#line 3194 "test-new/nrimp10s-77.imp"
if (tmp != 0) goto L_02A8;
#line 3194 "test-new/nrimp10s-77.imp"
}
#line 3194 "test-new/nrimp10s-77.imp"
if (ARR != 0) goto L_02A8;
#line 3194 "test-new/nrimp10s-77.imp"
if (PREC <= 4) goto L_02A8;
#line 3194 "test-new/nrimp10s-77.imp"
if (I != RBASE) goto L_02A8;
#line 3194 "test-new/nrimp10s-77.imp"
if (TYPE != 7) goto L_02A9;
#line 3194 "test-new/nrimp10s-77.imp"
L_02A8:;
#line 3194 "test-new/nrimp10s-77.imp"
FAULT(33, FNAME);
#line 3194 "test-new/nrimp10s-77.imp"
L_02A9:;
// 3195 %IF ALT=1 %THEN PSF1(ST,1,K) %ELSE GET IN ACC(ACCR,BYTES(PREC)>>2,0,LNB,K)
#line 3195 "test-new/nrimp10s-77.imp"
if (ALT != 1) goto L_02AA;
#line 3195 "test-new/nrimp10s-77.imp"
PSF1(72, 1, K);
#line 3195 "test-new/nrimp10s-77.imp"
goto L_02AB;
#line 3195 "test-new/nrimp10s-77.imp"
L_02AA:;
#line 3195 "test-new/nrimp10s-77.imp"
GETINACC(0, (unsigned int)BYTES[PREC] >> 2, 0, 2, K);
#line 3195 "test-new/nrimp10s-77.imp"
L_02AB:;
// 3196 ->EXIT
#line 3196 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3197 SW(3): ! PUT (HEX HALFWORD)
#line 3197 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 3198 TYPE=A(P)
#line 3198 "test-new/nrimp10s-77.imp"
TYPE = A[P];
// 3199 PREC=TYPE>>4; TYPE=TYPE&7
#line 3199 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)TYPE >> 4;
#line 3199 "test-new/nrimp10s-77.imp"
TYPE = TYPE & 7;
// 3200 FAULT(32,0) %UNLESS TYPE=1 %AND PREC<6
#line 3200 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_02AC;
#line 3200 "test-new/nrimp10s-77.imp"
if (PREC < 6) goto L_02AD;
#line 3200 "test-new/nrimp10s-77.imp"
L_02AC:;
#line 3200 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3200 "test-new/nrimp10s-77.imp"
L_02AD:;
// 3201 %IF PREC=5 %THEN P=P+2
#line 3201 "test-new/nrimp10s-77.imp"
if (PREC != 5) goto L_02AE;
#line 3201 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3201 "test-new/nrimp10s-77.imp"
L_02AE:;
// 3202 PLANT(FROM AR2(P+1))
#line 3202 "test-new/nrimp10s-77.imp"
PLANT(FROMAR2(P + 1));
// 3203 ->EXIT
#line 3203 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3204 SW(5): ! CNOP
#line 3204 "test-new/nrimp10s-77.imp"
case_SW_5:;
// 3205 CNOP(A(P),A(P+1))
#line 3205 "test-new/nrimp10s-77.imp"
CNOP(A[P], A[P + 1]);
// 3206 ->EXIT
#line 3206 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3207 SW(4): ! ASSEMBLER
#line 3207 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 3208 FORM=A(P); ! FORM=PRIMARY,SECONDARY OR 3RY
#line 3208 "test-new/nrimp10s-77.imp"
FORM = A[P];
// 3209 OPCODE=A(P+1)
#line 3209 "test-new/nrimp10s-77.imp"
OPCODE = A[P + 1];
// 3210 P=P+2; ->F(FORM)
#line 3210 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3210 "test-new/nrimp10s-77.imp"
F_line = __LINE__;
F_file = __FILE__;
F_index = FORM;
goto case_F_dispatch;
// 3211 F(1): ! ALL PRIMARY FORMAT INSTRUCTIONS
#line 3211 "test-new/nrimp10s-77.imp"
case_F_1:;
// 3212 ALT=A(P); P=P+1
#line 3212 "test-new/nrimp10s-77.imp"
ALT = A[P];
#line 3212 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3213 ->POP(ALT)
#line 3213 "test-new/nrimp10s-77.imp"
POP_line = __LINE__;
POP_file = __FILE__;
POP_index = ALT;
goto case_POP_dispatch;
// 3214 POP(1): ! LABELNAME
#line 3214 "test-new/nrimp10s-77.imp"
case_POP_1:;
// 3215 FNAME=FROM AR2(P); P=P+2
#line 3215 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(P);
#line 3215 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3216 ENTER JUMP(OPCODE<<24!3<<23,FNAME,0)
#line 3216 "test-new/nrimp10s-77.imp"
ENTERJUMP(OPCODE << 24 | 3 << 23, FNAME, 0);
// 3217 ->EXIT
#line 3217 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3218 POP(2): ! DIRECT SYMBOLIC
#line 3218 "test-new/nrimp10s-77.imp"
case_POP_2:;
// 3219 CIND
#line 3219 "test-new/nrimp10s-77.imp"
CIND();
// 3220 POPI: PSORLF1(OPCODE,ACCESS,AREA,DISP)
#line 3220 "test-new/nrimp10s-77.imp"
U_1022:;
#line 3220 "test-new/nrimp10s-77.imp"
PSORLF1(OPCODE, ACCESS, AREA, DISP);
// 3221 ->EXIT
#line 3221 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3222 POP(3): ! INDIRECT SYMBOLIC
#line 3222 "test-new/nrimp10s-77.imp"
case_POP_3:;
// 3223 CIND
#line 3223 "test-new/nrimp10s-77.imp"
CIND();
// 3224 ACCESS=4-A(P); P=P+1
#line 3224 "test-new/nrimp10s-77.imp"
ACCESS = 4 - A[P];
#line 3224 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3225 ->POPI
#line 3225 "test-new/nrimp10s-77.imp"
goto U_1022;
// 3226 POP(4): ! DR SYMBOLICALLY MODIFIED
#line 3226 "test-new/nrimp10s-77.imp"
case_POP_4:;
// 3227 CIND; ACCESS=1; ->POPI
#line 3227 "test-new/nrimp10s-77.imp"
CIND();
#line 3227 "test-new/nrimp10s-77.imp"
ACCESS = 1;
#line 3227 "test-new/nrimp10s-77.imp"
goto U_1022;
// 3228 POP(5): ! (DR) & (DR+B)
#line 3228 "test-new/nrimp10s-77.imp"
case_POP_5:;
// 3229 ACCESS=4-A(P); AREA=7
#line 3229 "test-new/nrimp10s-77.imp"
ACCESS = 4 - A[P];
#line 3229 "test-new/nrimp10s-77.imp"
AREA = 7;
// 3230 DISP=0; P=P+1
#line 3230 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 3230 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3231 ->POPI
#line 3231 "test-new/nrimp10s-77.imp"
goto U_1022;
// 3232 POP(6): ! B
#line 3232 "test-new/nrimp10s-77.imp"
case_POP_6:;
// 3233 ACCESS=0
#line 3233 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 3234 AREA=7; DISP=0; ->POPI
#line 3234 "test-new/nrimp10s-77.imp"
AREA = 7;
#line 3234 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 3234 "test-new/nrimp10s-77.imp"
goto U_1022;
// 3235 F(2): ! SECONDARY (STORE-TO STORE)FORMAT
#line 3235 "test-new/nrimp10s-77.imp"
case_F_2:;
// 3236 MASK=0; FILLER=0; Q=0; FNAME=0
#line 3236 "test-new/nrimp10s-77.imp"
MASK = 0;
#line 3236 "test-new/nrimp10s-77.imp"
FILLER = 0;
#line 3236 "test-new/nrimp10s-77.imp"
Q = 0;
#line 3236 "test-new/nrimp10s-77.imp"
FNAME = 0;
// 3237 H=2-A(P)
#line 3237 "test-new/nrimp10s-77.imp"
H = 2 - A[P];
// 3238 %IF H=0 %THEN FNAME=FROM AR2(P+1)-1 %AND P=P+2
#line 3238 "test-new/nrimp10s-77.imp"
if (H != 0) goto L_02B1;
#line 3238 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(P + 1) - 1;
#line 3238 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3238 "test-new/nrimp10s-77.imp"
L_02B1:;
// 3239 FAULT(32,0) %UNLESS 0<=FNAME<=127
#line 3239 "test-new/nrimp10s-77.imp"
{
// Double-sided test on FNAME (Part I)
#line 3239 "test-new/nrimp10s-77.imp"
int tmp;
#line 3239 "test-new/nrimp10s-77.imp"
if (0 > (tmp = FNAME)) goto L_02B2;
// Double-sided test on FNAME (Part II)
#line 3239 "test-new/nrimp10s-77.imp"
if (tmp <= 127) goto L_02B3;
#line 3239 "test-new/nrimp10s-77.imp"
}
#line 3239 "test-new/nrimp10s-77.imp"
L_02B2:;
#line 3239 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3239 "test-new/nrimp10s-77.imp"
L_02B3:;
// 3240 ALT=A(P+1); P=P+2
#line 3240 "test-new/nrimp10s-77.imp"
ALT = A[P + 1];
#line 3240 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3241 %IF ALT=1 %THEN %START
#line 3241 "test-new/nrimp10s-77.imp"
if (ALT != 1) goto L_02B4;
// 3242 Q=1
#line 3242 "test-new/nrimp10s-77.imp"
Q = 1;
// 3243 MASK=FROM AR2(P)
#line 3243 "test-new/nrimp10s-77.imp"
MASK = FROMAR2(P);
// 3244 FILLER=FROM AR2(P+2)
#line 3244 "test-new/nrimp10s-77.imp"
FILLER = FROMAR2(P + 2);
// 3245 P=P+4
#line 3245 "test-new/nrimp10s-77.imp"
P = P + 4;
// 3246 FAULT(32,0) %UNLESS 0<=MASK!FILLER<=255
#line 3246 "test-new/nrimp10s-77.imp"
{
// Double-sided test on MASK | FILLER (Part I)
#line 3246 "test-new/nrimp10s-77.imp"
int tmp;
#line 3246 "test-new/nrimp10s-77.imp"
if (0 > (tmp = MASK | FILLER)) goto L_027F;
// Double-sided test on MASK | FILLER (Part II)
#line 3246 "test-new/nrimp10s-77.imp"
if (tmp <= 255) goto L_02B5;
#line 3246 "test-new/nrimp10s-77.imp"
}
#line 3246 "test-new/nrimp10s-77.imp"
L_027F:;
#line 3246 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3246 "test-new/nrimp10s-77.imp"
L_02B5:;
// 3247 %FINISH
#line 3247 "test-new/nrimp10s-77.imp"
L_02B4:;
// 3248 PF2(OPCODE,H,Q,FNAME,MASK,FILLER)
#line 3248 "test-new/nrimp10s-77.imp"
PF2(OPCODE, H, Q, FNAME, MASK, FILLER);
// 3249 ->EXIT
#line 3249 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3250 F(3): ! TERTIARY FORMAT
#line 3250 "test-new/nrimp10s-77.imp"
case_F_3:;
// 3251 MASK=FROM AR2(P)
#line 3251 "test-new/nrimp10s-77.imp"
MASK = FROMAR2(P);
// 3252 ALT=A(P+2)
#line 3252 "test-new/nrimp10s-77.imp"
ALT = A[P + 2];
// 3253 FAULT(32,0) %UNLESS 0<=MASK<=15
#line 3253 "test-new/nrimp10s-77.imp"
{
// Double-sided test on MASK (Part I)
#line 3253 "test-new/nrimp10s-77.imp"
int tmp;
#line 3253 "test-new/nrimp10s-77.imp"
if (0 > (tmp = MASK)) goto L_02B6;
// Double-sided test on MASK (Part II)
#line 3253 "test-new/nrimp10s-77.imp"
if (tmp <= 15) goto L_02B7;
#line 3253 "test-new/nrimp10s-77.imp"
}
#line 3253 "test-new/nrimp10s-77.imp"
L_02B6:;
#line 3253 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3253 "test-new/nrimp10s-77.imp"
L_02B7:;
// 3254 P=P+3; ->TOP(ALT)
#line 3254 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3254 "test-new/nrimp10s-77.imp"
TOP_line = __LINE__;
TOP_file = __FILE__;
TOP_index = ALT;
goto case_TOP_dispatch;
// 3255 TOP(1): ! LABEL
#line 3255 "test-new/nrimp10s-77.imp"
case_TOP_1:;
// 3256 FNAME=FROM AR2(P); P=P+2
#line 3256 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(P);
#line 3256 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3257 ENTER JUMP(OPCODE<<24!MASK<<21,FNAME,0)
#line 3257 "test-new/nrimp10s-77.imp"
ENTERJUMP(OPCODE << 24 | MASK << 21, FNAME, 0);
// 3258 ->EXIT
#line 3258 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3259 TOP(2): ! SYMBOLIC OPERAND
#line 3259 "test-new/nrimp10s-77.imp"
case_TOP_2:;
// 3260 CIND
#line 3260 "test-new/nrimp10s-77.imp"
CIND();
// 3261 FAULT(32,0) %IF AREA>=6
#line 3261 "test-new/nrimp10s-77.imp"
if (AREA < 6) goto L_02B9;
#line 3261 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3261 "test-new/nrimp10s-77.imp"
L_02B9:;
// 3262 %IF AREA=LNB %OR AREA=XNB %OR AREA=CTB %THEN DISP=DISP//4
#line 3262 "test-new/nrimp10s-77.imp"
if (AREA == 2) goto L_02BA;
#line 3262 "test-new/nrimp10s-77.imp"
if (AREA == 3) goto L_02BA;
#line 3262 "test-new/nrimp10s-77.imp"
if (AREA != 5) goto L_02BB;
#line 3262 "test-new/nrimp10s-77.imp"
L_02BA:;
#line 3262 "test-new/nrimp10s-77.imp"
DISP = ((long)DISP / (long)4);
#line 3262 "test-new/nrimp10s-77.imp"
L_02BB:;
// 3263 TOPI: PF3(OPCODE,MASK,AREA,DISP)
#line 3263 "test-new/nrimp10s-77.imp"
U_1023:;
#line 3263 "test-new/nrimp10s-77.imp"
PF3(OPCODE, MASK, AREA, DISP);
// 3264 ->EXIT
#line 3264 "test-new/nrimp10s-77.imp"
goto U_1021;
// 3265 TOP(3): ! (DR) & (DR+B)
#line 3265 "test-new/nrimp10s-77.imp"
case_TOP_3:;
// 3266 DISP=0; AREA=8-A(P)
#line 3266 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 3266 "test-new/nrimp10s-77.imp"
AREA = 8 - A[P];
// 3267 P=P+1; ->TOPI
#line 3267 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3267 "test-new/nrimp10s-77.imp"
goto U_1023;
// 3268 TOP(4): ! (DR+N)
#line 3268 "test-new/nrimp10s-77.imp"
case_TOP_4:;
// 3269 DISP=FROM AR2(P); P=P+2
#line 3269 "test-new/nrimp10s-77.imp"
DISP = FROMAR2(P);
#line 3269 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3270 AREA=1; ->TOPI
#line 3270 "test-new/nrimp10s-77.imp"
AREA = 1;
#line 3270 "test-new/nrimp10s-77.imp"
goto U_1023;
// 3271 %ROUTINE CIND
#line 3271 "test-new/nrimp10s-77.imp"
void CIND(void) {
// 3272 !***********************************************************************
// 3273 !* COMPILE A SYMBOLIC OPERAND BY SETTING ACCESS,AREA &DISP *
// 3274 !***********************************************************************
// 3275 %INTEGER ALT,AFN,FN0,FN1,FN2,FN3,JJ,D,CTYPE,CPREC
#line 3275 "test-new/nrimp10s-77.imp"
int ALT;
#line 3275 "test-new/nrimp10s-77.imp"
int AFN;
#line 3275 "test-new/nrimp10s-77.imp"
int FN0;
#line 3275 "test-new/nrimp10s-77.imp"
int FN1;
#line 3275 "test-new/nrimp10s-77.imp"
int FN2;
#line 3275 "test-new/nrimp10s-77.imp"
int FN3;
#line 3275 "test-new/nrimp10s-77.imp"
int JJ;
#line 3275 "test-new/nrimp10s-77.imp"
int D;
#line 3275 "test-new/nrimp10s-77.imp"
int CTYPE;
#line 3275 "test-new/nrimp10s-77.imp"
int CPREC;
// 3276 %SWITCH SW(1:4)
#line 3276 "test-new/nrimp10s-77.imp"
int SW_index;
#line 3276 "test-new/nrimp10s-77.imp"
int SW_line;
#line 3276 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 3276 "test-new/nrimp10s-77.imp"
static const void *SW[4] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 3277 AFN=ADDR(FN0)
#line 3277 "test-new/nrimp10s-77.imp"
AFN = _imp_ADDR(/*?*/ &FN0);
// 3278 ALT=A(P); ACCESS=0
#line 3278 "test-new/nrimp10s-77.imp"
ALT = A[P];
#line 3278 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 3279 P=P+1; ->SW(ALT)
#line 3279 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3279 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = ALT;
goto case_SW_dispatch;
// 3280 SW(1): ! (=')(PLUS')(ICONST)
#line 3280 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 3281 P=P+1; ! PAST (=')
#line 3281 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3282 D=A(P); CTYPE=A(P+1)
#line 3282 "test-new/nrimp10s-77.imp"
D = A[P];
#line 3282 "test-new/nrimp10s-77.imp"
CTYPE = A[P + 1];
// 3283 CPREC=CTYPE>>4; CTYPE=CTYPE&7
#line 3283 "test-new/nrimp10s-77.imp"
CPREC = (unsigned int)CTYPE >> 4;
#line 3283 "test-new/nrimp10s-77.imp"
CTYPE = CTYPE & 7;
// 3284 %IF CPREC=4 %THEN FN0=FROM AR2(P+2) %ELSE %START
#line 3284 "test-new/nrimp10s-77.imp"
if (CPREC != 4) goto L_02BD;
#line 3284 "test-new/nrimp10s-77.imp"
FN0 = FROMAR2(P + 2);
#line 3284 "test-new/nrimp10s-77.imp"
goto L_02BE;
#line 3284 "test-new/nrimp10s-77.imp"
L_02BD:;
// 3285 %CYCLE JJ=0,1,BYTES(CPREC)-1
#line 3285 "test-new/nrimp10s-77.imp"
// %for JJ = 0, 1, BYTES[CPREC] - 1 %cycle
#line 3285 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = BYTES[CPREC] - 1;
#line 3285 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0)
_imp_signal(5, 1, 0, "Illegal cycle JJ = 0, 1, BYTES[CPREC] - 1");
_control = JJ = _initial - _increment;
#line 3285 "test-new/nrimp10s-77.imp"
L_02BF:
#line 3285 "test-new/nrimp10s-77.imp"
if (JJ != _control) _imp_signal(4, 2, 0, "Corrupt control variable JJ");
#line 3285 "test-new/nrimp10s-77.imp"
if (JJ == _final) goto L_02C0;
#line 3285 "test-new/nrimp10s-77.imp"
_control += _increment;
JJ += _increment;
// 3286 BYTEINTEGER(AFN+JJ)=A(P+JJ+2)
#line 3286 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(AFN + JJ) = A[P + JJ + 2];
// 3287 %REPEAT
#line 3287 "test-new/nrimp10s-77.imp"
goto L_02BF;
#line 3287 "test-new/nrimp10s-77.imp"
}
#line 3287 "test-new/nrimp10s-77.imp"
L_02C0:;
// 3288 %FINISH
#line 3288 "test-new/nrimp10s-77.imp"
L_02BE:;
// 3289 P=P+2+BYTES(CPREC)
#line 3289 "test-new/nrimp10s-77.imp"
P = P + 2 + BYTES[CPREC];
// 3290 %IF D=2 %THEN %START
#line 3290 "test-new/nrimp10s-77.imp"
if (D != 2) goto L_02C2;
// 3291 %IF CTYPE=2 %THEN FN0=FN0!!16_80000000 %ELSE %START
#line 3291 "test-new/nrimp10s-77.imp"
if (CTYPE != 2) goto L_02C3;
#line 3291 "test-new/nrimp10s-77.imp"
FN0 = FN0 ^ -2147483648;
#line 3291 "test-new/nrimp10s-77.imp"
goto L_02C4;
#line 3291 "test-new/nrimp10s-77.imp"
L_02C3:;
// 3292 %IF CPREC=6 %THEN LONGINTEGER(AFN)=-LONGINTEGER(AFN) %ELSE FN0=-FN0
#line 3292 "test-new/nrimp10s-77.imp"
if (CPREC != 6) goto L_02C5;
#line 3292 "test-new/nrimp10s-77.imp"
*LONGINTEGER(AFN) = -*LONGINTEGER(AFN);
#line 3292 "test-new/nrimp10s-77.imp"
goto L_02C6;
#line 3292 "test-new/nrimp10s-77.imp"
L_02C5:;
#line 3292 "test-new/nrimp10s-77.imp"
FN0 = -FN0;
#line 3292 "test-new/nrimp10s-77.imp"
L_02C6:;
// 3293 %FINISH
#line 3293 "test-new/nrimp10s-77.imp"
L_02C4:;
// 3294 %FINISH
#line 3294 "test-new/nrimp10s-77.imp"
L_02C2:;
// 3295 CNST: ->LIT %UNLESS CTYPE=1 %AND CPREC<=5 %AND 16_FFFE0000<=FN0<=16_1FFFF
#line 3295 "test-new/nrimp10s-77.imp"
U_1024:;
#line 3295 "test-new/nrimp10s-77.imp"
if (CTYPE != 1) goto L_02C7;
#line 3295 "test-new/nrimp10s-77.imp"
if (CPREC > 5) goto L_02C7;
#line 3295 "test-new/nrimp10s-77.imp"
{
// Double-sided test on FN0 (Part I)
#line 3295 "test-new/nrimp10s-77.imp"
int tmp;
#line 3295 "test-new/nrimp10s-77.imp"
if (-131072 > (tmp = FN0)) goto L_02C7;
// Double-sided test on FN0 (Part II)
#line 3295 "test-new/nrimp10s-77.imp"
if (tmp <= 131071) goto L_02C8;
#line 3295 "test-new/nrimp10s-77.imp"
}
#line 3295 "test-new/nrimp10s-77.imp"
L_02C7:;
#line 3295 "test-new/nrimp10s-77.imp"
goto U_1025;
#line 3295 "test-new/nrimp10s-77.imp"
L_02C8:;
// 3296 AREA=0; DISP=FN0
#line 3296 "test-new/nrimp10s-77.imp"
AREA = 0;
#line 3296 "test-new/nrimp10s-77.imp"
DISP = FN0;
// 3297 %RETURN
#line 3297 "test-new/nrimp10s-77.imp"
return;
// 3298 LIT: FAULT(32,0) %UNLESS 1<=CTYPE<=2 %AND 5<=CPREC<=7
#line 3298 "test-new/nrimp10s-77.imp"
U_1025:;
#line 3298 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CTYPE (Part I)
#line 3298 "test-new/nrimp10s-77.imp"
int tmp;
#line 3298 "test-new/nrimp10s-77.imp"
if (1 > (tmp = CTYPE)) goto L_02C9;
// Double-sided test on CTYPE (Part II)
#line 3298 "test-new/nrimp10s-77.imp"
if (tmp > 2) goto L_02C9;
#line 3298 "test-new/nrimp10s-77.imp"
}
#line 3298 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CPREC (Part I)
#line 3298 "test-new/nrimp10s-77.imp"
int tmp;
#line 3298 "test-new/nrimp10s-77.imp"
if (5 > (tmp = CPREC)) goto L_02C9;
// Double-sided test on CPREC (Part II)
#line 3298 "test-new/nrimp10s-77.imp"
if (tmp <= 7) goto L_02CA;
#line 3298 "test-new/nrimp10s-77.imp"
}
#line 3298 "test-new/nrimp10s-77.imp"
L_02C9:;
#line 3298 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3298 "test-new/nrimp10s-77.imp"
L_02CA:;
// 3299 STORE CONST(DISP,BYTES(CPREC),AFN)
#line 3299 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &DISP, BYTES[CPREC], AFN);
// 3300 AREA=PC; ACCESS=0
#line 3300 "test-new/nrimp10s-77.imp"
AREA = 4;
#line 3300 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 3301 %RETURN
#line 3301 "test-new/nrimp10s-77.imp"
return;
// 3302 SW(2): ! (NAME)(OPTINC)
#line 3302 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 3303 FN0=FROM AR2(P); P=P+2
#line 3303 "test-new/nrimp10s-77.imp"
FN0 = FROMAR2(P);
#line 3303 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3304 COPY TAG(FN0)
#line 3304 "test-new/nrimp10s-77.imp"
COPYTAG(FN0);
// 3305 %IF (LITL=1 %AND ARR=0) %START
#line 3305 "test-new/nrimp10s-77.imp"
if (LITL != 1) goto L_02CB;
#line 3305 "test-new/nrimp10s-77.imp"
if (ARR != 0) goto L_02CB;
// 3306 CTYPE=TYPE; CPREC=PREC
#line 3306 "test-new/nrimp10s-77.imp"
CTYPE = TYPE;
#line 3306 "test-new/nrimp10s-77.imp"
CPREC = PREC;
// 3307 ALT=TAGS(FN0)
#line 3307 "test-new/nrimp10s-77.imp"
ALT = TAGS[FN0];
// 3308 FROM123(ALT,D,FN0,FN1)
#line 3308 "test-new/nrimp10s-77.imp"
FROM123(ALT, /*?*/ &D, /*?*/ &FN0, /*?*/ &FN1);
// 3309 %IF CPREC=7 %THEN AFN=FN1
#line 3309 "test-new/nrimp10s-77.imp"
if (CPREC != 7) goto L_02CC;
#line 3309 "test-new/nrimp10s-77.imp"
AFN = FN1;
#line 3309 "test-new/nrimp10s-77.imp"
L_02CC:;
// 3310 ->CNST
#line 3310 "test-new/nrimp10s-77.imp"
goto U_1024;
// 3311 %FINISH
#line 3311 "test-new/nrimp10s-77.imp"
L_02CB:;
// 3312 %IF TYPE>=6 %OR TYPE=4 %OR (ROUT=1 %AND NAM=0) %THEN FAULT(33,FN0) %AND %RETURN
#line 3312 "test-new/nrimp10s-77.imp"
if (TYPE >= 6) goto L_02CD;
#line 3312 "test-new/nrimp10s-77.imp"
if (TYPE == 4) goto L_02CD;
#line 3312 "test-new/nrimp10s-77.imp"
if (ROUT != 1) goto L_02CE;
#line 3312 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_02CE;
#line 3312 "test-new/nrimp10s-77.imp"
L_02CD:;
#line 3312 "test-new/nrimp10s-77.imp"
FAULT(33, FN0);
#line 3312 "test-new/nrimp10s-77.imp"
return;
#line 3312 "test-new/nrimp10s-77.imp"
L_02CE:;
// 3313 %IF ROUT=1 %THEN K=FROM1(K)
#line 3313 "test-new/nrimp10s-77.imp"
if (ROUT != 1) goto L_02CF;
#line 3313 "test-new/nrimp10s-77.imp"
K = FROM1(K);
#line 3313 "test-new/nrimp10s-77.imp"
L_02CF:;
// 3314 AREA=LNB
#line 3314 "test-new/nrimp10s-77.imp"
AREA = 2;
// 3315 %IF I#RBASE %THEN AREA=SET XORYNB(XNB,I)
#line 3315 "test-new/nrimp10s-77.imp"
if (I == RBASE) goto L_02D0;
#line 3315 "test-new/nrimp10s-77.imp"
AREA = SETXORYNB(3, I);
#line 3315 "test-new/nrimp10s-77.imp"
L_02D0:;
// 3316 ALT=A(P); D=FROM AR2(P+1)
#line 3316 "test-new/nrimp10s-77.imp"
ALT = A[P];
#line 3316 "test-new/nrimp10s-77.imp"
D = FROMAR2(P + 1);
// 3317 %IF ALT=1 %THEN K=K+D
#line 3317 "test-new/nrimp10s-77.imp"
if (ALT != 1) goto L_02D1;
#line 3317 "test-new/nrimp10s-77.imp"
K = K + D;
#line 3317 "test-new/nrimp10s-77.imp"
L_02D1:;
// 3318 %IF ALT=2 %THEN K=K-D
#line 3318 "test-new/nrimp10s-77.imp"
if (ALT != 2) goto L_02D2;
#line 3318 "test-new/nrimp10s-77.imp"
K = K - D;
#line 3318 "test-new/nrimp10s-77.imp"
L_02D2:;
// 3319 P=P+1; P=P+2 %IF ALT<=2
#line 3319 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3319 "test-new/nrimp10s-77.imp"
if (ALT > 2) goto L_02D3;
#line 3319 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3319 "test-new/nrimp10s-77.imp"
L_02D3:;
// 3320 DISP=K; %RETURN
#line 3320 "test-new/nrimp10s-77.imp"
DISP = K;
#line 3320 "test-new/nrimp10s-77.imp"
return;
// 3321 SW(3): ! '('(REG)(OPTINC)')'
#line 3321 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 3322 AREA=A(P)+1; ALT=A(P+1); P=P+2
#line 3322 "test-new/nrimp10s-77.imp"
AREA = A[P] + 1;
#line 3322 "test-new/nrimp10s-77.imp"
ALT = A[P + 1];
#line 3322 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3323 DISP=0
#line 3323 "test-new/nrimp10s-77.imp"
DISP = 0;
// 3324 D=FROM AR2(P)
#line 3324 "test-new/nrimp10s-77.imp"
D = FROMAR2(P);
// 3325 %IF ALT=1 %THEN DISP=D
#line 3325 "test-new/nrimp10s-77.imp"
if (ALT != 1) goto L_02D4;
#line 3325 "test-new/nrimp10s-77.imp"
DISP = D;
#line 3325 "test-new/nrimp10s-77.imp"
L_02D4:;
// 3326 %IF ALT=2 %THEN FAULT(32,0)
#line 3326 "test-new/nrimp10s-77.imp"
if (ALT != 2) goto L_02D5;
#line 3326 "test-new/nrimp10s-77.imp"
FAULT(32, 0);
#line 3326 "test-new/nrimp10s-77.imp"
L_02D5:;
// 3327 %IF AREA=PC %THEN DISP=CA+2*DISP %ELSE DISP=4*DISP
#line 3327 "test-new/nrimp10s-77.imp"
if (AREA != 4) goto L_02D6;
#line 3327 "test-new/nrimp10s-77.imp"
DISP = CA + 2 * DISP;
#line 3327 "test-new/nrimp10s-77.imp"
goto L_02D7;
#line 3327 "test-new/nrimp10s-77.imp"
L_02D6:;
#line 3327 "test-new/nrimp10s-77.imp"
DISP = 4 * DISP;
#line 3327 "test-new/nrimp10s-77.imp"
L_02D7:;
// 3328 P=P+2 %UNLESS ALT=3
#line 3328 "test-new/nrimp10s-77.imp"
if (ALT == 3) goto L_02D8;
#line 3328 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3328 "test-new/nrimp10s-77.imp"
L_02D8:;
// 3329 %RETURN
#line 3329 "test-new/nrimp10s-77.imp"
return;
// 3330 SW(4): ! '%TOS'
#line 3330 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 3331 AREA=6; DISP=0
#line 3331 "test-new/nrimp10s-77.imp"
AREA = 6;
#line 3331 "test-new/nrimp10s-77.imp"
DISP = 0;
// 3332 %END
#line 3332 "test-new/nrimp10s-77.imp"
return;
#line 3332 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 3332 "test-new/nrimp10s-77.imp"
if (SW_index < 1 || SW_index > 4)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 3332 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 1];
#line 3332 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 3332 "test-new/nrimp10s-77.imp"
} /* end of CIND */
// ?FN3 unused
// ?FN2 unused
// 3333 EXIT: GRUSE(ACCR)=0
#line 3333 "test-new/nrimp10s-77.imp"
U_1021:;
#line 3333 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 3334 GRUSE(DR)=0
#line 3334 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 3335 GRUSE(BREG)=0
#line 3335 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 3336 GRUSE(XNB)=0 %IF OPCODE=CALL %OR OPCODE=LXN %OR OPCODE=JLK %OR OPCODE=OUT
#line 3336 "test-new/nrimp10s-77.imp"
if (OPCODE == 30) goto L_02D9;
#line 3336 "test-new/nrimp10s-77.imp"
if (OPCODE == 126) goto L_02D9;
#line 3336 "test-new/nrimp10s-77.imp"
if (OPCODE == 28) goto L_02D9;
#line 3336 "test-new/nrimp10s-77.imp"
if (OPCODE != 60) goto L_02DA;
#line 3336 "test-new/nrimp10s-77.imp"
L_02D9:;
#line 3336 "test-new/nrimp10s-77.imp"
GRUSE[3] = 0;
#line 3336 "test-new/nrimp10s-77.imp"
L_02DA:;
// 3337 GRUSE(CTB)=0 %IF OPCODE=CALL %OR OPCODE=LCT %OR OPCODE=JLK %OR OPCODE=OUT
#line 3337 "test-new/nrimp10s-77.imp"
if (OPCODE == 30) goto L_02DB;
#line 3337 "test-new/nrimp10s-77.imp"
if (OPCODE == 48) goto L_02DB;
#line 3337 "test-new/nrimp10s-77.imp"
if (OPCODE == 28) goto L_02DB;
#line 3337 "test-new/nrimp10s-77.imp"
if (OPCODE != 60) goto L_02DC;
#line 3337 "test-new/nrimp10s-77.imp"
L_02DB:;
#line 3337 "test-new/nrimp10s-77.imp"
GRUSE[5] = 0;
#line 3337 "test-new/nrimp10s-77.imp"
L_02DC:;
// 3338 %END
#line 3338 "test-new/nrimp10s-77.imp"
goto end_1011;
#line 3338 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 3338 "test-new/nrimp10s-77.imp"
if (SW_index < 1 || SW_index > 5)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 3338 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 1];
#line 3338 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 3338 "test-new/nrimp10s-77.imp"
case_F_dispatch:
#line 3338 "test-new/nrimp10s-77.imp"
if (F_index < 1 || F_index > 3)
_imp_signalf(6, 3, F_index, "->F(%d) out of bounds at %s line %d", F_index, F_file, F_line);
#line 3338 "test-new/nrimp10s-77.imp"
goto *F[F_index - 1];
#line 3338 "test-new/nrimp10s-77.imp"
case_F_missing:
_imp_signalf(8, 2, F_index, "switch jump to undefined label F(%d): at %s line %d", F_index, F_file, F_line);
#line 3338 "test-new/nrimp10s-77.imp"
case_POP_dispatch:
#line 3338 "test-new/nrimp10s-77.imp"
if (POP_index < 1 || POP_index > 6)
_imp_signalf(6, 3, POP_index, "->POP(%d) out of bounds at %s line %d", POP_index, POP_file, POP_line);
#line 3338 "test-new/nrimp10s-77.imp"
goto *POP[POP_index - 1];
#line 3338 "test-new/nrimp10s-77.imp"
case_POP_missing:
_imp_signalf(8, 2, POP_index, "switch jump to undefined label POP(%d): at %s line %d", POP_index, POP_file,
POP_line);
#line 3338 "test-new/nrimp10s-77.imp"
case_TOP_dispatch:
#line 3338 "test-new/nrimp10s-77.imp"
if (TOP_index < 1 || TOP_index > 4)
_imp_signalf(6, 3, TOP_index, "->TOP(%d) out of bounds at %s line %d", TOP_index, TOP_file, TOP_line);
#line 3338 "test-new/nrimp10s-77.imp"
goto *TOP[TOP_index - 1];
#line 3338 "test-new/nrimp10s-77.imp"
case_TOP_missing:
_imp_signalf(8, 2, TOP_index, "switch jump to undefined label TOP(%d): at %s line %d", TOP_index, TOP_file,
TOP_line);
#line 3338 "test-new/nrimp10s-77.imp"
end_1011:;
#line 3338 "test-new/nrimp10s-77.imp"
}
// 3339 ->CSSEXIT
#line 3339 "test-new/nrimp10s-77.imp"
goto U_1015;
// 3340 SW(20):
#line 3340 "test-new/nrimp10s-77.imp"
case_SW_20:;
// 3341 ! '%TRUSTEDPROGRAM'
// 3342 COMPILER=1 %IF PARMARR=0 %AND PARMCHK=0; ->CSSEXIT
#line 3342 "test-new/nrimp10s-77.imp"
if (PARMARR != 0) goto L_02DD;
#line 3342 "test-new/nrimp10s-77.imp"
if (PARMCHK != 0) goto L_02DD;
#line 3342 "test-new/nrimp10s-77.imp"
COMPILER = 1;
#line 3342 "test-new/nrimp10s-77.imp"
L_02DD:;
#line 3342 "test-new/nrimp10s-77.imp"
goto U_1015;
// 3343 SW(21): ! '%MAINEP'(NAME)
#line 3343 "test-new/nrimp10s-77.imp"
case_SW_21:;
// 3344 KK=FROM AR2(P+1)
#line 3344 "test-new/nrimp10s-77.imp"
KK = FROMAR2(P + 1);
// 3345 FAULT(58,0) %UNLESS CPRMODE=0
#line 3345 "test-new/nrimp10s-77.imp"
if (CPRMODE == 0) goto L_02DE;
#line 3345 "test-new/nrimp10s-77.imp"
FAULT(58, 0);
#line 3345 "test-new/nrimp10s-77.imp"
L_02DE:;
// 3346 MAINEP<-STRING(DICTBASE+WORD(KK))
#line 3346 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &MAINEP, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *_imp_STRING(DICTBASE + WORD[KK]);
(void *)&tmp;
}),
/*max:*/ 31);
#line 3346 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 31 chars */
#line 3346 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &MAINEP) > 31) *_imp_LENGTH((_imp_string *)/*?*/ &MAINEP) = 31;
// 3347 ->CSSEXIT
#line 3347 "test-new/nrimp10s-77.imp"
goto U_1015;
// 3348 %ROUTINE CRFORMAT(%INTEGERNAME OPHEAD)
#line 3348 "test-new/nrimp10s-77.imp"
void CRFORMAT(int *OPHEAD) {
// 3349 !***********************************************************************
// 3350 !* CONVERTS A RECORDFORMAT STATEMENT TO A LIST HEADED BY OPHEAD *
// 3351 !* FORMAT OF AN ENTRY. *
// 3352 !* S1=SUBNAME<<20!PTYPE<<4!J *
// 3353 !* S2,S3=4 16 BIT DISPLACEMENTS D2,ACC,D1,KFORM *
// 3354 !* NORMALLY D1=RECORD RELATIVE DISPLACEMENT AND ACC=LMAX(STRINGS)*
// 3355 !* FOR ARRAYS D2=FIRST ELEMENT DISPLACEMENT AND D1=DISPLACEMENT *
// 3356 !* OF RECORD RELATIVE ARRAYHEAD IN THE GLA *
// 3357 !* KFORM IS ONLY USED FOR RECORDS AND POINTS TO THE FORMAT *
// 3358 !* ON EXIT ACC HAS THE RECORD SIZE ROUNDED UP TO THE BOUNDARY *
// 3359 !* REQUIRED BY ITS LARGEST COMPONENT *
// 3360 !***********************************************************************
// 3361 %INTEGER D1,D2,NLIST,FORM,RL,MRL,UNSCAL,SC,DESC,FN,INC,Q,R,A0,A1,A2,DV,RFD,LB,OB,TYPEP,SACC
#line 3361 "test-new/nrimp10s-77.imp"
int D1;
#line 3361 "test-new/nrimp10s-77.imp"
int D2;
#line 3361 "test-new/nrimp10s-77.imp"
int NLIST;
#line 3361 "test-new/nrimp10s-77.imp"
int FORM;
#line 3361 "test-new/nrimp10s-77.imp"
int RL;
#line 3361 "test-new/nrimp10s-77.imp"
int MRL;
#line 3361 "test-new/nrimp10s-77.imp"
int UNSCAL;
#line 3361 "test-new/nrimp10s-77.imp"
int SC;
#line 3361 "test-new/nrimp10s-77.imp"
int DESC;
#line 3361 "test-new/nrimp10s-77.imp"
int FN;
#line 3361 "test-new/nrimp10s-77.imp"
int INC;
#line 3361 "test-new/nrimp10s-77.imp"
int Q;
#line 3361 "test-new/nrimp10s-77.imp"
int R;
#line 3361 "test-new/nrimp10s-77.imp"
int A0;
#line 3361 "test-new/nrimp10s-77.imp"
int A1;
#line 3361 "test-new/nrimp10s-77.imp"
int A2;
#line 3361 "test-new/nrimp10s-77.imp"
int DV;
#line 3361 "test-new/nrimp10s-77.imp"
int RFD;
#line 3361 "test-new/nrimp10s-77.imp"
int LB;
#line 3361 "test-new/nrimp10s-77.imp"
int OB;
#line 3361 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 3361 "test-new/nrimp10s-77.imp"
int SACC;
// 3362 %SWITCH RFEL(1:5)
#line 3362 "test-new/nrimp10s-77.imp"
int RFEL_index;
#line 3362 "test-new/nrimp10s-77.imp"
int RFEL_line;
#line 3362 "test-new/nrimp10s-77.imp"
char *RFEL_file;
#line 3362 "test-new/nrimp10s-77.imp"
static const void *RFEL[5] = {&&case_RFEL_missing, &&case_RFEL_missing, &&case_RFEL_missing,
&&case_RFEL_missing, &&case_RFEL_missing};
#line 3362 "test-new/nrimp10s-77.imp"
auto void SN(int Q);
#line 3362 "test-new/nrimp10s-77.imp"
auto void ROUND(void);
// 3363 %ROUTINESPEC SN(%INTEGER Q)
// 3364 %ROUTINESPEC ROUND
// 3365 NLIST=0; OPHEAD=0; FORM=0; ACC=0; OB=0
#line 3365 "test-new/nrimp10s-77.imp"
NLIST = 0;
#line 3365 "test-new/nrimp10s-77.imp"
*OPHEAD = 0;
#line 3365 "test-new/nrimp10s-77.imp"
FORM = 0;
#line 3365 "test-new/nrimp10s-77.imp"
ACC = 0;
#line 3365 "test-new/nrimp10s-77.imp"
OB = 0;
// 3366 MRL=0; INC=0; ! INC COUNTS DOWN RECORD
#line 3366 "test-new/nrimp10s-77.imp"
MRL = 0;
#line 3366 "test-new/nrimp10s-77.imp"
INC = 0;
// 3367 NEXT: ROUT=0; LITL=0; NAM=0; RFD=A(P)
#line 3367 "test-new/nrimp10s-77.imp"
U_1026:;
#line 3367 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 3367 "test-new/nrimp10s-77.imp"
LITL = 0;
#line 3367 "test-new/nrimp10s-77.imp"
NAM = 0;
#line 3367 "test-new/nrimp10s-77.imp"
RFD = A[P];
// 3368 %IF RFD<=2 %THEN P=P+1 %AND CLT
#line 3368 "test-new/nrimp10s-77.imp"
if (RFD > 2) goto L_02DF;
#line 3368 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3368 "test-new/nrimp10s-77.imp"
CLT();
#line 3368 "test-new/nrimp10s-77.imp"
L_02DF:;
// 3369 ->RFEL(RFD)
#line 3369 "test-new/nrimp10s-77.imp"
RFEL_line = __LINE__;
RFEL_file = __FILE__;
RFEL_index = RFD;
goto case_RFEL_dispatch;
// 3370 RFEL(1): ! (TYPE) (QNAME')(NAMELIST)
#line 3370 "test-new/nrimp10s-77.imp"
case_RFEL_1:;
// 3371 CQN(P); P=P+1
#line 3371 "test-new/nrimp10s-77.imp"
CQN(P);
#line 3371 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3372 PACK(PTYPE); D2=0
#line 3372 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
#line 3372 "test-new/nrimp10s-77.imp"
D2 = 0;
// 3373 RL=3
#line 3373 "test-new/nrimp10s-77.imp"
RL = 3;
// 3374 %IF NAM=0 %AND 3<=PREC<=4 %THEN RL=PREC-3
#line 3374 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_02E1;
#line 3374 "test-new/nrimp10s-77.imp"
{
// Double-sided test on PREC (Part I)
#line 3374 "test-new/nrimp10s-77.imp"
int tmp;
#line 3374 "test-new/nrimp10s-77.imp"
if (3 > (tmp = PREC)) goto L_02E1;
// Double-sided test on PREC (Part II)
#line 3374 "test-new/nrimp10s-77.imp"
if (tmp > 4) goto L_02E1;
#line 3374 "test-new/nrimp10s-77.imp"
}
#line 3374 "test-new/nrimp10s-77.imp"
RL = PREC - 3;
#line 3374 "test-new/nrimp10s-77.imp"
L_02E1:;
// 3375 AGN: ROUND ; J=0
#line 3375 "test-new/nrimp10s-77.imp"
U_1024:;
#line 3375 "test-new/nrimp10s-77.imp"
ROUND();
#line 3375 "test-new/nrimp10s-77.imp"
J = 0;
// 3376 {%UNTIL A(P-1)=2} %CYCLE
#line 3376 "test-new/nrimp10s-77.imp"
L_02E2:;
// 3377 D1=INC; SN(P)
#line 3377 "test-new/nrimp10s-77.imp"
D1 = INC;
#line 3377 "test-new/nrimp10s-77.imp"
SN(P);
// 3378 P=P+3; INC=INC+ACC
#line 3378 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3378 "test-new/nrimp10s-77.imp"
INC = INC + ACC;
// 3379 %REPEAT %UNTIL A(P-1)=2
#line 3379 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_02E3;
#line 3379 "test-new/nrimp10s-77.imp"
goto L_02E2;
#line 3379 "test-new/nrimp10s-77.imp"
L_02E3:;
// 3380 P=P+RFD>>2<<1; ! EXTRA 2 FOR RECORDS TO SKIP FORMAT
#line 3380 "test-new/nrimp10s-77.imp"
P = P + ((unsigned int)RFD >> 2 << 1);
// 3381 TRY END: -> END %IF A(P)=2
#line 3381 "test-new/nrimp10s-77.imp"
U_1025:;
#line 3381 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_02E4;
#line 3381 "test-new/nrimp10s-77.imp"
goto U_1027;
#line 3381 "test-new/nrimp10s-77.imp"
L_02E4:;
// 3382 P=P+1; -> NEXT
#line 3382 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3382 "test-new/nrimp10s-77.imp"
goto U_1026;
// 3383 RFEL(2):RFEL2: ! (TYPE)%ARRAY(NAMELIST)(BPAIR)
#line 3383 "test-new/nrimp10s-77.imp"
case_RFEL_2:;
#line 3383 "test-new/nrimp10s-77.imp"
U_1028:;
// 3384 Q=P; ARR=1; PACK(PTYPE)
#line 3384 "test-new/nrimp10s-77.imp"
Q = P;
#line 3384 "test-new/nrimp10s-77.imp"
ARR = 1;
#line 3384 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
// 3385 %IF TYPE<=2 %THEN UNSCAL=0 %AND SC=PREC %ELSE UNSCAL=1 %AND SC=3
#line 3385 "test-new/nrimp10s-77.imp"
if (TYPE > 2) goto L_02E5;
#line 3385 "test-new/nrimp10s-77.imp"
UNSCAL = 0;
#line 3385 "test-new/nrimp10s-77.imp"
SC = PREC;
#line 3385 "test-new/nrimp10s-77.imp"
goto L_02E6;
#line 3385 "test-new/nrimp10s-77.imp"
L_02E5:;
#line 3385 "test-new/nrimp10s-77.imp"
UNSCAL = 1;
#line 3385 "test-new/nrimp10s-77.imp"
SC = 3;
#line 3385 "test-new/nrimp10s-77.imp"
L_02E6:;
// 3386 %IF PREC=4 %THEN DESC=16_58000002 %ELSE DESC=SC<<27!UNSCAL<<25!(1-PARMARR)<<24
#line 3386 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_02E7;
#line 3386 "test-new/nrimp10s-77.imp"
DESC = 1476395010;
#line 3386 "test-new/nrimp10s-77.imp"
goto L_02E8;
#line 3386 "test-new/nrimp10s-77.imp"
L_02E7:;
#line 3386 "test-new/nrimp10s-77.imp"
DESC = SC << 27 | UNSCAL << 25 | 1 - PARMARR << 24;
#line 3386 "test-new/nrimp10s-77.imp"
L_02E8:;
// 3387 {%UNTIL A(P-1)=2} %CYCLE; ! UNTIL <RESTOFARRAYLIST> NULL
#line 3387 "test-new/nrimp10s-77.imp"
L_02E9:;
// 3388 P=P+3 %UNTIL A(P-1)=2
#line 3388 "test-new/nrimp10s-77.imp"
L_02EA:;
#line 3388 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3388 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_02EB;
#line 3388 "test-new/nrimp10s-77.imp"
goto L_02EA;
#line 3388 "test-new/nrimp10s-77.imp"
L_02EB:;
// 3389
// 3390 TYPEP=PTYPE; SACC=ACC
#line 3390 "test-new/nrimp10s-77.imp"
TYPEP = PTYPE;
#line 3390 "test-new/nrimp10s-77.imp"
SACC = ACC;
// 3391 DV=DOPE VECTOR(TYPE,ACC,0,FROMAR2(Q),R,LB)+12
#line 3391 "test-new/nrimp10s-77.imp"
DV = DOPEVECTOR(TYPE, ACC, 0, FROMAR2(Q), /*?*/ &R, /*?*/ &LB) + 12;
// 3392 ! DOPE VECTOR INTO SHAREABLE S.T.
// 3393 ACC=SACC; PTYPE=TYPEP; UNPACK
#line 3393 "test-new/nrimp10s-77.imp"
ACC = SACC;
#line 3393 "test-new/nrimp10s-77.imp"
PTYPE = TYPEP;
#line 3393 "test-new/nrimp10s-77.imp"
UNPACK();
// 3394 %IF TYPE=5 %OR (TYPE=1 %AND PREC=3) %THEN RL=0 %ELSE RL=3
#line 3394 "test-new/nrimp10s-77.imp"
if (TYPE == 5) goto L_02C1;
#line 3394 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_02EC;
#line 3394 "test-new/nrimp10s-77.imp"
if (PREC != 3) goto L_02EC;
#line 3394 "test-new/nrimp10s-77.imp"
L_02C1:;
#line 3394 "test-new/nrimp10s-77.imp"
RL = 0;
#line 3394 "test-new/nrimp10s-77.imp"
goto L_02ED;
#line 3394 "test-new/nrimp10s-77.imp"
L_02EC:;
#line 3394 "test-new/nrimp10s-77.imp"
RL = 3;
#line 3394 "test-new/nrimp10s-77.imp"
L_02ED:;
// 3395 ROUND
#line 3395 "test-new/nrimp10s-77.imp"
ROUND();
// 3396 {%UNTIL A(Q-1)=2} %CYCLE; ! HEAD INTO GLA FOR EACH ARRAY
#line 3396 "test-new/nrimp10s-77.imp"
L_02EE:;
// 3397 A0=R; %IF UNSCAL=0 %THEN A0=A0//ACC
#line 3397 "test-new/nrimp10s-77.imp"
A0 = R;
#line 3397 "test-new/nrimp10s-77.imp"
if (UNSCAL != 0) goto L_02EF;
#line 3397 "test-new/nrimp10s-77.imp"
A0 = ((long)A0 / (long)ACC);
#line 3397 "test-new/nrimp10s-77.imp"
L_02EF:;
// 3398 %IF PREC=4 %THEN A0=0; ! STRING DESCRIPTORS !
#line 3398 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_02F0;
#line 3398 "test-new/nrimp10s-77.imp"
A0 = 0;
#line 3398 "test-new/nrimp10s-77.imp"
L_02F0:;
// 3399 A0=A0!DESC; A1=INC
#line 3399 "test-new/nrimp10s-77.imp"
A0 = A0 | DESC;
#line 3399 "test-new/nrimp10s-77.imp"
A1 = INC;
// 3400 %IF TYPE<=3 %AND PARMARR=0=PARMCHK %AND J=1 %THEN A1=A1-LB*ACC
#line 3400 "test-new/nrimp10s-77.imp"
if (TYPE > 3) goto L_02F1;
#line 3400 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 3400 "test-new/nrimp10s-77.imp"
int tmp;
#line 3400 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_02F1;
// Double-sided test on 0 (Part II)
#line 3400 "test-new/nrimp10s-77.imp"
if (tmp != PARMCHK) goto L_02F1;
#line 3400 "test-new/nrimp10s-77.imp"
}
#line 3400 "test-new/nrimp10s-77.imp"
if (J != 1) goto L_02F1;
#line 3400 "test-new/nrimp10s-77.imp"
A1 = A1 - LB * ACC;
#line 3400 "test-new/nrimp10s-77.imp"
L_02F1:;
// 3401 A2=5<<27!3*J
#line 3401 "test-new/nrimp10s-77.imp"
A2 = 5 << 27 | 3 * J;
// 3402 PGLA(4,16,ADDR(A0))
#line 3402 "test-new/nrimp10s-77.imp"
PGLA(4, 16, _imp_ADDR(/*?*/ &A0));
// 3403 D1=GLACA-16
#line 3403 "test-new/nrimp10s-77.imp"
D1 = GLACA - 16;
// 3404 RELOCATE(D1+12,DV,1); ! RELOCATE DV POINTER
#line 3404 "test-new/nrimp10s-77.imp"
RELOCATE(D1 + 12, DV, 1);
// 3405 NOTE CREF(16_80000000!(DV<<1>>3)!(D1+12)>>2<<16, (DV&16_FFFF)<<2)
#line 3405 "test-new/nrimp10s-77.imp"
NOTECREF(-2147483648 | (unsigned int)DV << 1 >> 3 | (unsigned int)D1 + 12 >> 2 << 16, (DV & 65535) << 2);
// 3406 D2=INC
#line 3406 "test-new/nrimp10s-77.imp"
D2 = INC;
// 3407 SN(Q); INC=INC+R
#line 3407 "test-new/nrimp10s-77.imp"
SN(Q);
#line 3407 "test-new/nrimp10s-77.imp"
INC = INC + R;
// 3408 Q=Q+3
#line 3408 "test-new/nrimp10s-77.imp"
Q = Q + 3;
// 3409 %REPEAT %UNTIL A(Q-1)=2; ! HEAD INTO GLA FOR EACH ARRAY
#line 3409 "test-new/nrimp10s-77.imp"
if (A[Q - 1] == 2) goto L_02F2;
#line 3409 "test-new/nrimp10s-77.imp"
goto L_02EE;
#line 3409 "test-new/nrimp10s-77.imp"
L_02F2:;
// 3410 P=P+1; Q=P
#line 3410 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3410 "test-new/nrimp10s-77.imp"
Q = P;
// 3411 %REPEAT %UNTIL A(P-1)=2
#line 3411 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_02F3;
#line 3411 "test-new/nrimp10s-77.imp"
goto L_02E9;
#line 3411 "test-new/nrimp10s-77.imp"
L_02F3:;
// 3412 P=P+2 %IF RFD=5
#line 3412 "test-new/nrimp10s-77.imp"
if (RFD != 5) goto L_02F4;
#line 3412 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3412 "test-new/nrimp10s-77.imp"
L_02F4:;
// 3413 -> TRY END
#line 3413 "test-new/nrimp10s-77.imp"
goto U_1025;
// 3414 RFEL(3): ! %RECORD (%ARRAY) %NAME
#line 3414 "test-new/nrimp10s-77.imp"
case_RFEL_3:;
// 3415 TYPE=3; PREC=3; NAM=1
#line 3415 "test-new/nrimp10s-77.imp"
TYPE = 3;
#line 3415 "test-new/nrimp10s-77.imp"
PREC = 3;
#line 3415 "test-new/nrimp10s-77.imp"
NAM = 1;
// 3416 ARR=2-A(P+1); P=P+2
#line 3416 "test-new/nrimp10s-77.imp"
ARR = 2 - A[P + 1];
#line 3416 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3417 PACK(PTYPE); D2=0
#line 3417 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
#line 3417 "test-new/nrimp10s-77.imp"
D2 = 0;
// 3418 RL=3; ACC=8+8*ARR
#line 3418 "test-new/nrimp10s-77.imp"
RL = 3;
#line 3418 "test-new/nrimp10s-77.imp"
ACC = 8 + 8 * ARR;
// 3419 FORM=0
#line 3419 "test-new/nrimp10s-77.imp"
FORM = 0;
// 3420 ->AGN
#line 3420 "test-new/nrimp10s-77.imp"
goto U_1024;
// 3421 RFEL(4): ! RECORDS IN RECORDS
#line 3421 "test-new/nrimp10s-77.imp"
case_RFEL_4:;
// 3422 RFEL(5): ! RECORDARRAYS IN RECORDS
#line 3422 "test-new/nrimp10s-77.imp"
case_RFEL_5:;
// 3423 Q=P+FROM AR2(P+1)+1
#line 3423 "test-new/nrimp10s-77.imp"
Q = P + FROMAR2(P + 1) + 1;
// 3424 FN=FROM AR2(Q)
#line 3424 "test-new/nrimp10s-77.imp"
FN = FROMAR2(Q);
// 3425 COPY TAG(FN); ! COPY FORMAT TAG & SET ACC
#line 3425 "test-new/nrimp10s-77.imp"
COPYTAG(FN);
// 3426 FAULT(62,FN) %UNLESS PTYPE=4
#line 3426 "test-new/nrimp10s-77.imp"
if (PTYPE == 4) goto L_02F5;
#line 3426 "test-new/nrimp10s-77.imp"
FAULT(62, FN);
#line 3426 "test-new/nrimp10s-77.imp"
L_02F5:;
// 3427 TYPE=3; PREC=3; FORM=TCELL
#line 3427 "test-new/nrimp10s-77.imp"
TYPE = 3;
#line 3427 "test-new/nrimp10s-77.imp"
PREC = 3;
#line 3427 "test-new/nrimp10s-77.imp"
FORM = TCELL;
// 3428 %IF RFD=4 %THEN %START
#line 3428 "test-new/nrimp10s-77.imp"
if (RFD != 4) goto L_02F6;
// 3429 PTYPE=16_33; P=P+3; D2=0
#line 3429 "test-new/nrimp10s-77.imp"
PTYPE = 51;
#line 3429 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3429 "test-new/nrimp10s-77.imp"
D2 = 0;
// 3430 RL=3; ->AGN
#line 3430 "test-new/nrimp10s-77.imp"
RL = 3;
#line 3430 "test-new/nrimp10s-77.imp"
goto U_1024;
// 3431 %FINISH
#line 3431 "test-new/nrimp10s-77.imp"
L_02F6:;
// 3432 P=P+3; ->RFEL2
#line 3432 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3432 "test-new/nrimp10s-77.imp"
goto U_1028;
// 3433 END: ! FINISH OFF
#line 3433 "test-new/nrimp10s-77.imp"
U_1027:;
// 3434 RL=MRL; ROUND
#line 3434 "test-new/nrimp10s-77.imp"
RL = MRL;
#line 3434 "test-new/nrimp10s-77.imp"
ROUND();
// 3435 ACC=INC; ! SIZE ROUNDED APPROPRIATELY
#line 3435 "test-new/nrimp10s-77.imp"
ACC = INC;
// 3436 FAULT(98,0) %UNLESS INC<=16_7FFF
#line 3436 "test-new/nrimp10s-77.imp"
if (INC <= 32767) goto L_02F7;
#line 3436 "test-new/nrimp10s-77.imp"
FAULT(98, 0);
#line 3436 "test-new/nrimp10s-77.imp"
L_02F7:;
// 3437 CLEAR LIST(NLIST)
#line 3437 "test-new/nrimp10s-77.imp"
CLEARLIST(/*?*/ &NLIST);
// 3438 %RETURN
#line 3438 "test-new/nrimp10s-77.imp"
return;
// 3439 %ROUTINE SN(%INTEGER Q)
#line 3439 "test-new/nrimp10s-77.imp"
void SN(int Q) {
// 3440 !***********************************************************************
// 3441 !* CHECK THE SUBNAME HAS NOT BEEN USED BEFORE IN THIS FORMAT *
// 3442 !* AND ENTER IT WITH ITS DESCRIPTORS INTO THE LIST. *
// 3443 !***********************************************************************
// 3444 FNAME=FROM AR2(Q)
#line 3444 "test-new/nrimp10s-77.imp"
FNAME = FROMAR2(Q);
// 3445 FAULT2(61,0,FNAME) %UNLESS FIND(FNAME,NLIST)=-1
#line 3445 "test-new/nrimp10s-77.imp"
if (FIND(FNAME, NLIST) == -1) goto L_02F8;
#line 3445 "test-new/nrimp10s-77.imp"
FAULT2(61, 0, FNAME);
#line 3445 "test-new/nrimp10s-77.imp"
L_02F8:;
// 3446 BINSERT(OPHEAD,OB,FNAME<<20!PTYPE<<4!J,D2<<16!ACC,D1<<16!FORM)
#line 3446 "test-new/nrimp10s-77.imp"
BINSERT(OPHEAD, /*?*/ &OB, FNAME << 20 | PTYPE << 4 | J, D2 << 16 | ACC, D1 << 16 | FORM);
// 3447 PUSH(NLIST,0,FNAME,0)
#line 3447 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &NLIST, 0, FNAME, 0);
// 3448 %END
#line 3448 "test-new/nrimp10s-77.imp"
return;
#line 3448 "test-new/nrimp10s-77.imp"
} /* end of SN */
// 3449 %ROUTINE ROUND
#line 3449 "test-new/nrimp10s-77.imp"
void ROUND(void) {
// 3450 MRL=RL %IF RL>MRL
#line 3450 "test-new/nrimp10s-77.imp"
if (RL <= MRL) goto L_02F9;
#line 3450 "test-new/nrimp10s-77.imp"
MRL = RL;
#line 3450 "test-new/nrimp10s-77.imp"
L_02F9:;
// 3451 INC=INC+1 %WHILE INC&RL#0
#line 3451 "test-new/nrimp10s-77.imp"
L_02FA:;
#line 3451 "test-new/nrimp10s-77.imp"
if (INC & RL == 0) goto L_02FB;
#line 3451 "test-new/nrimp10s-77.imp"
INC = INC + 1;
#line 3451 "test-new/nrimp10s-77.imp"
goto L_02FA;
#line 3451 "test-new/nrimp10s-77.imp"
L_02FB:;
// 3452 %END
#line 3452 "test-new/nrimp10s-77.imp"
return;
#line 3452 "test-new/nrimp10s-77.imp"
} /* end of ROUND */
// 3453 %END; ! OF ROUTINE CRFORMAT
#line 3453 "test-new/nrimp10s-77.imp"
return;
#line 3453 "test-new/nrimp10s-77.imp"
case_RFEL_dispatch:
#line 3453 "test-new/nrimp10s-77.imp"
if (RFEL_index < 1 || RFEL_index > 5)
_imp_signalf(6, 3, RFEL_index, "->RFEL(%d) out of bounds at %s line %d", RFEL_index, RFEL_file, RFEL_line);
#line 3453 "test-new/nrimp10s-77.imp"
goto *RFEL[RFEL_index - 1];
#line 3453 "test-new/nrimp10s-77.imp"
case_RFEL_missing:
_imp_signalf(8, 2, RFEL_index, "switch jump to undefined label RFEL(%d): at %s line %d", RFEL_index,
RFEL_file, RFEL_line);
#line 3453 "test-new/nrimp10s-77.imp"
} /* end of CRFORMAT */
// 3454 %INTEGERFN DISPLACEMENT(%INTEGER LINK)
#line 3454 "test-new/nrimp10s-77.imp"
int DISPLACEMENT(int LINK) {
// 3455 !***********************************************************************
// 3456 !* SEARCH A FORMAT LIST FOR A SUBNAME *
// 3457 !* A(P) HAS ENAME--LINK IS HEAD OF RFORMAT LIST. RESULT IS DISP *
// 3458 !* FROM START OF RECORD *
// 3459 !***********************************************************************
// 3460 %RECORD(LISTF)%NAME FCELL,PCELL,LCELL{(LISTF)
#line 3460 "test-new/nrimp10s-77.imp"
struct LISTF *FCELL;
#line 3460 "test-new/nrimp10s-77.imp"
struct LISTF *PCELL;
#line 3460 "test-new/nrimp10s-77.imp"
struct LISTF *LCELL;
// 3461 %INTEGER RR,II,ENAME,CELL
#line 3461 "test-new/nrimp10s-77.imp"
int RR;
#line 3461 "test-new/nrimp10s-77.imp"
int II;
#line 3461 "test-new/nrimp10s-77.imp"
int ENAME;
#line 3461 "test-new/nrimp10s-77.imp"
int CELL;
// 3462 ENAME=A(P)<<8+A(P+1); CELL=0
#line 3462 "test-new/nrimp10s-77.imp"
ENAME = (A[P] << 8) + A[P + 1];
#line 3462 "test-new/nrimp10s-77.imp"
CELL = 0;
// 3463 %IF LINK#0 %THEN %START; ! CHK RECORDSPEC NOT OMITTED
#line 3463 "test-new/nrimp10s-77.imp"
if (LINK == 0) goto L_02FC;
// 3464 FCELL==ASLIST(LINK); ! ONTO FORMAT TAG CELL
#line 3464 "test-new/nrimp10s-77.imp"
FCELL = (struct LISTF *)/*?*/ &ASLIST[LINK];
// 3465 LINK=FCELL_S3&16_7FFF; ! LINK TO SIDE CHAIN
#line 3465 "test-new/nrimp10s-77.imp"
LINK = FCELL->S3 & 32767;
// 3466 CELL=LINK; II=-1; ACC=-1
#line 3466 "test-new/nrimp10s-77.imp"
CELL = LINK;
#line 3466 "test-new/nrimp10s-77.imp"
II = -1;
#line 3466 "test-new/nrimp10s-77.imp"
ACC = -1;
// 3467 %WHILE LINK>0 %CYCLE
#line 3467 "test-new/nrimp10s-77.imp"
L_02FD:;
#line 3467 "test-new/nrimp10s-77.imp"
if (LINK <= 0) goto L_02FE;
// 3468 LCELL==ASLIST(LINK)
#line 3468 "test-new/nrimp10s-77.imp"
LCELL = (struct LISTF *)/*?*/ &ASLIST[LINK];
// 3469 %IF LCELL_S1>>20=ENAME %START; ! RIGHT SUBNAME LOCATED
#line 3469 "test-new/nrimp10s-77.imp"
if ((unsigned int)LCELL->S1 >> 20 != ENAME) goto L_02FF;
// 3470 TCELL=LINK
#line 3470 "test-new/nrimp10s-77.imp"
TCELL = LINK;
// 3471 RR=LCELL_S1
#line 3471 "test-new/nrimp10s-77.imp"
RR = LCELL->S1;
// 3472 SNDISP=LCELL_S2
#line 3472 "test-new/nrimp10s-77.imp"
SNDISP = LCELL->S2;
// 3473 K=LCELL_S3
#line 3473 "test-new/nrimp10s-77.imp"
K = LCELL->S3;
// 3474 J=RR&15; PTYPE=RR>>4&16_FFFF
#line 3474 "test-new/nrimp10s-77.imp"
J = RR & 15;
#line 3474 "test-new/nrimp10s-77.imp"
PTYPE = (unsigned int)RR >> 4 & 65535;
// 3475 ACC=SNDISP&16_FFFF; SNDISP=SNDISP&16_FFFF0000//16_10000
#line 3475 "test-new/nrimp10s-77.imp"
ACC = SNDISP & 65535;
#line 3475 "test-new/nrimp10s-77.imp"
SNDISP = ((long)(SNDISP & -65536) / (long)65536);
// 3476 KFORM=K&16_FFFF; K=K>>16
#line 3476 "test-new/nrimp10s-77.imp"
KFORM = K & 65535;
#line 3476 "test-new/nrimp10s-77.imp"
K = (unsigned int)K >> 16;
// 3477 %IF LINK#CELL %START; ! NOT TOP CELL OF FORMAT
#line 3477 "test-new/nrimp10s-77.imp"
if (LINK == CELL) goto L_0300;
// 3478 PCELL_LINK=LCELL_LINK
#line 3478 "test-new/nrimp10s-77.imp"
PCELL->LINK = LCELL->LINK;
// 3479 LCELL_LINK=CELL
#line 3479 "test-new/nrimp10s-77.imp"
LCELL->LINK = CELL;
// 3480 FCELL_S3=FCELL_S3&16_FFFF0000!LINK
#line 3480 "test-new/nrimp10s-77.imp"
FCELL->S3 = FCELL->S3 & -65536 | LINK;
// 3481 %FINISH; ! ARRANGING LIST WITH THIS SUBNAME
#line 3481 "test-new/nrimp10s-77.imp"
L_0300:;
// 3482 ! AT THE TOP
// 3483 %RESULT=K
#line 3483 "test-new/nrimp10s-77.imp"
return K;
// 3484 %FINISH
#line 3484 "test-new/nrimp10s-77.imp"
L_02FF:;
// 3485 PCELL==LCELL
#line 3485 "test-new/nrimp10s-77.imp"
PCELL = (struct LISTF *)LCELL;
// 3486 LINK=LCELL_LINK
#line 3486 "test-new/nrimp10s-77.imp"
LINK = LCELL->LINK;
// 3487 %REPEAT
#line 3487 "test-new/nrimp10s-77.imp"
goto L_02FD;
#line 3487 "test-new/nrimp10s-77.imp"
L_02FE:;
// 3488 %FINISH
#line 3488 "test-new/nrimp10s-77.imp"
L_02FC:;
// 3489 FAULT(65,ENAME)
#line 3489 "test-new/nrimp10s-77.imp"
FAULT(65, ENAME);
// 3490 %IF CELL>0 %THEN PUSH(ASLIST(CELL)_LINK,ENAME<<20!7<<4,0,0)
#line 3490 "test-new/nrimp10s-77.imp"
if (CELL <= 0) goto L_0301;
#line 3490 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &ASLIST[CELL].LINK, ENAME << 20 | 7 << 4, 0, 0);
#line 3490 "test-new/nrimp10s-77.imp"
L_0301:;
// 3491 PTYPE=7; TCELL=0
#line 3491 "test-new/nrimp10s-77.imp"
PTYPE = 7;
#line 3491 "test-new/nrimp10s-77.imp"
TCELL = 0;
// 3492 %RESULT=-1
#line 3492 "test-new/nrimp10s-77.imp"
return -1;
// 3493 %END
#line 3493 "test-new/nrimp10s-77.imp"
} /* end of DISPLACEMENT */
// 3494 %INTEGERFN COPY RECORD TAG(%INTEGERNAME SUBS)
#line 3494 "test-new/nrimp10s-77.imp"
int COPYRECORDTAG(int *SUBS) {
// 3495 !***********************************************************************
// 3496 !* PRODUCE PTYPE ETC FOR A COMPOUND NAME BY CHAINING DOWN ONE *
// 3497 !* ONE OR MORE RECORD FORMAT LISTS. ON EXIT RESULT =0 IF NO *
// 3498 !* SUBNAME FOUND OR SUBNAME IS OF TYPE RECORD WITH NO FURTHER *
// 3499 !* SUBNAME ATTACHED. RESULT#0 IF BONE-FIDE SUBNAME LOCATED *
// 3500 !* ON ENTRY KFORM HAS POINTER TO THE (FIRST ) FORMAT LIST AND *
// 3501 !* P POINTS TO THE A.R. ENTRY FOR (FIRST) ENAME *
// 3502 !***********************************************************************
// 3503 %INTEGER Q,FNAME
#line 3503 "test-new/nrimp10s-77.imp"
int Q;
#line 3503 "test-new/nrimp10s-77.imp"
int FNAME;
// 3504 SUBS=0
#line 3504 "test-new/nrimp10s-77.imp"
*SUBS = 0;
// 3505 {%UNTIL TYPE#3} %CYCLE
#line 3505 "test-new/nrimp10s-77.imp"
L_0302:;
// 3506 FNAME=KFORM
#line 3506 "test-new/nrimp10s-77.imp"
FNAME = KFORM;
// 3507 P=P+2; SKIP APP
#line 3507 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3507 "test-new/nrimp10s-77.imp"
SKIPAPP();
// 3508 %RESULT=0 %IF A(P)=2 %OR FNAME<=0;! NO (FURTHER) ENAME
#line 3508 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0303;
#line 3508 "test-new/nrimp10s-77.imp"
if (FNAME > 0) goto L_0304;
#line 3508 "test-new/nrimp10s-77.imp"
L_0303:;
#line 3508 "test-new/nrimp10s-77.imp"
return 0;
#line 3508 "test-new/nrimp10s-77.imp"
L_0304:;
// 3509 SUBS=SUBS+1
#line 3509 "test-new/nrimp10s-77.imp"
*SUBS = *SUBS + 1;
// 3510 P=P+1; Q=DISPLACEMENT (FNAME)
#line 3510 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3510 "test-new/nrimp10s-77.imp"
Q = DISPLACEMENT(FNAME);
// 3511 UNPACK
#line 3511 "test-new/nrimp10s-77.imp"
UNPACK();
// 3512 %REPEAT %UNTIL TYPE#3
#line 3512 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_0305;
#line 3512 "test-new/nrimp10s-77.imp"
goto L_0302;
#line 3512 "test-new/nrimp10s-77.imp"
L_0305:;
// 3513 %RESULT=Q+1; ! GIVES 0 IF SUBNAME NOT KNOWN
#line 3513 "test-new/nrimp10s-77.imp"
return Q + 1;
// 3514 %END
#line 3514 "test-new/nrimp10s-77.imp"
} /* end of COPYRECORDTAG */
// 3515 %ROUTINE CRNAME(%INTEGER Z,REG,MODE,BS,AR,DP,%INTEGERNAME NAMEP)
#line 3515 "test-new/nrimp10s-77.imp"
void CRNAME(int Z, int REG, int MODE, int BS, int AR, int DP, int *NAMEP) {
// 3516 !***********************************************************************
// 3517 !* DEAL WITH RECORD ELEMENT NAMES.Z AS FOR CNAME.CLINK=TAGS(RN) *
// 3518 !* MODE=ACCESS FOR RECORD(NOT THE ELEMENT!) *
// 3519 !* ON EXIT BASE,AREA & DISP POINT TO REQUIRED ELEMENT *
// 3520 !* RECURSIVE CALL IS NEEDED TO DEAL WITH RECORDS IN RECORDS *
// 3521 !* DEPTH SHEWS RECURSIVE LEVELS- NEEDED TO AVOID MIS SETTING *
// 3522 !* REGISTER IN USE IF RECORDNAME IN RECORD HAS THE SAME NAME AS *
// 3523 !* A GENUINE RECORD NAME. *
// 3524 !***********************************************************************
// 3525 %INTEGER DEPTH,FNAME
#line 3525 "test-new/nrimp10s-77.imp"
int DEPTH;
#line 3525 "test-new/nrimp10s-77.imp"
int FNAME;
#line 3525 "test-new/nrimp10s-77.imp"
auto void CENAME(int MODE, int FNAME, int BS, int AR, int DP, int XD);
// 3526 %ROUTINESPEC CENAME(%INTEGER MODE,FNAME,BS,AR,DP,XD)
// 3527 DEPTH=0
#line 3527 "test-new/nrimp10s-77.imp"
DEPTH = 0;
// 3528 FNAME=KFORM; ! POINTER TO FORMAT
#line 3528 "test-new/nrimp10s-77.imp"
FNAME = KFORM;
// 3529 %IF ARR=0 %OR (Z=6 %AND A(P+2)=2) %START;! SIMPLE RECORD
#line 3529 "test-new/nrimp10s-77.imp"
if (ARR == 0) goto L_0306;
#line 3529 "test-new/nrimp10s-77.imp"
if (Z != 6) goto L_0307;
#line 3529 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_0307;
#line 3529 "test-new/nrimp10s-77.imp"
L_0306:;
// 3530 %IF A(P+2)=2 %THEN P=P+3 %ELSE NO APP
#line 3530 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_0308;
#line 3530 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3530 "test-new/nrimp10s-77.imp"
goto L_0309;
#line 3530 "test-new/nrimp10s-77.imp"
L_0308:;
#line 3530 "test-new/nrimp10s-77.imp"
NOAPP();
#line 3530 "test-new/nrimp10s-77.imp"
L_0309:;
// 3531 CENAME(MODE,FNAME,BS,AR,DP,0)
#line 3531 "test-new/nrimp10s-77.imp"
CENAME(MODE, FNAME, BS, AR, DP, 0);
// 3532 %FINISH %ELSE %START
#line 3532 "test-new/nrimp10s-77.imp"
goto L_030A;
#line 3532 "test-new/nrimp10s-77.imp"
L_0307:;
// 3533 CANAME(ARR,BS,DP)
#line 3533 "test-new/nrimp10s-77.imp"
CANAME(ARR, BS, DP);
// 3534 CENAME(ACCESS,FNAME,BASE,AREA,DISP,0)
#line 3534 "test-new/nrimp10s-77.imp"
CENAME(ACCESS, FNAME, BASE, AREA, DISP, 0);
// 3535 %FINISH; %RETURN
#line 3535 "test-new/nrimp10s-77.imp"
L_030A:;
#line 3535 "test-new/nrimp10s-77.imp"
return;
// 3536 !
// 3537 %ROUTINE CENAME(%INTEGER MODE,FNAME,BS,AR,DP,XD)
#line 3537 "test-new/nrimp10s-77.imp"
void CENAME(int MODE, int FNAME, int BS, int AR, int DP, int XD) {
#line 3537 "test-new/nrimp10s-77.imp"
auto void FETCHRAD(void);
#line 3537 "test-new/nrimp10s-77.imp"
auto void LOCALISE(int SIZE);
// 3538 !***********************************************************************
// 3539 !* FINDS OUT ABOUT SUBNAME AND ACTS ACCORDINGLY.MOSTLY ACTION *
// 3540 !* CONSISTS OF UPPING XD BY OFFSET OF THE SUBNAME BUT IS VERY *
// 3541 !* HAIRY FOR RECORDS IN RECORDS ETC *
// 3542 !* MODE IS ACCESS FOR THE RECORD *
// 3543 !***********************************************************************
// 3544 %ROUTINESPEC FETCH RAD
// 3545 %ROUTINESPEC LOCALISE(%INTEGER SIZE)
// 3546 %INTEGER Q,QQ,D,C,W
#line 3546 "test-new/nrimp10s-77.imp"
int Q;
#line 3546 "test-new/nrimp10s-77.imp"
int QQ;
#line 3546 "test-new/nrimp10s-77.imp"
int D;
#line 3546 "test-new/nrimp10s-77.imp"
int C;
#line 3546 "test-new/nrimp10s-77.imp"
int W;
// 3547 DEPTH=DEPTH+1
#line 3547 "test-new/nrimp10s-77.imp"
DEPTH = DEPTH + 1;
// 3548 %IF A(P)=2 %THEN %START; ! ENAME MISSING
#line 3548 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_030B;
// 3549 ACCESS=MODE; AREA=AR; XDISP=XD
#line 3549 "test-new/nrimp10s-77.imp"
ACCESS = MODE;
#line 3549 "test-new/nrimp10s-77.imp"
AREA = AR;
#line 3549 "test-new/nrimp10s-77.imp"
XDISP = XD;
// 3550 BASE=BS; DISP=DP; ! FOR POINTER
#line 3550 "test-new/nrimp10s-77.imp"
BASE = BS;
#line 3550 "test-new/nrimp10s-77.imp"
DISP = DP;
// 3551 %IF Z<14 %THEN %START; ! NOT A RECORD OPERATION
#line 3551 "test-new/nrimp10s-77.imp"
if (Z >= 14) goto L_030C;
// 3552 %UNLESS 3<=Z<=4 %OR Z=6 %START; ! ADDR(RECORD)
#line 3552 "test-new/nrimp10s-77.imp"
{
// Double-sided test on Z (Part I)
#line 3552 "test-new/nrimp10s-77.imp"
int tmp;
#line 3552 "test-new/nrimp10s-77.imp"
if (3 > (tmp = Z)) goto L_022E;
// Double-sided test on Z (Part II)
#line 3552 "test-new/nrimp10s-77.imp"
if (tmp <= 4) goto L_030D;
#line 3552 "test-new/nrimp10s-77.imp"
}
#line 3552 "test-new/nrimp10s-77.imp"
L_022E:;
#line 3552 "test-new/nrimp10s-77.imp"
if (Z == 6) goto L_030D;
// 3553 FAULT(64,0); BASE=RBASE; AREA=-1
#line 3553 "test-new/nrimp10s-77.imp"
FAULT(64, 0);
#line 3553 "test-new/nrimp10s-77.imp"
BASE = RBASE;
#line 3553 "test-new/nrimp10s-77.imp"
AREA = -1;
// 3554 DISP=0; ACCESS=0; PTYPE=1; UNPACK
#line 3554 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 3554 "test-new/nrimp10s-77.imp"
ACCESS = 0;
#line 3554 "test-new/nrimp10s-77.imp"
PTYPE = 1;
#line 3554 "test-new/nrimp10s-77.imp"
UNPACK();
// 3555 %FINISH
#line 3555 "test-new/nrimp10s-77.imp"
L_030D:;
// 3556 %FINISH
#line 3556 "test-new/nrimp10s-77.imp"
L_030C:;
// 3557 %RETURN
#line 3557 "test-new/nrimp10s-77.imp"
return;
// 3558 %FINISH
#line 3558 "test-new/nrimp10s-77.imp"
L_030B:;
// 3559 P=P+1; ! FIND OUT ABOUT SUBNAME
#line 3559 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3560 Q=DISPLACEMENT(FNAME); ! TCELL POINTS TO CELL HOLDING
#line 3560 "test-new/nrimp10s-77.imp"
Q = DISPLACEMENT(FNAME);
// 3561 UNPACK; ! INFO ABOUT THE SUBNAME
#line 3561 "test-new/nrimp10s-77.imp"
UNPACK();
// 3562 %IF Q=-1=ACC %OR PTYPE=7 %START; ! WRONG SUBNAME(HAS BEEN FAULTED)
#line 3562 "test-new/nrimp10s-77.imp"
{
// Double-sided test on -1 (Part I)
#line 3562 "test-new/nrimp10s-77.imp"
int tmp;
#line 3562 "test-new/nrimp10s-77.imp"
if (Q != (tmp = -1)) goto L_030E;
// Double-sided test on -1 (Part II)
#line 3562 "test-new/nrimp10s-77.imp"
if (tmp == ACC) goto L_030F;
#line 3562 "test-new/nrimp10s-77.imp"
}
#line 3562 "test-new/nrimp10s-77.imp"
L_030E:;
#line 3562 "test-new/nrimp10s-77.imp"
if (PTYPE != 7) goto L_0310;
#line 3562 "test-new/nrimp10s-77.imp"
L_030F:;
// 3563 P=P+2; SKIP APP; P=P-3
#line 3563 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3563 "test-new/nrimp10s-77.imp"
SKIPAPP();
#line 3563 "test-new/nrimp10s-77.imp"
P = P - 3;
// 3564 ACCESS=0; BASE=RBASE; DISP=0; AREA=-1
#line 3564 "test-new/nrimp10s-77.imp"
ACCESS = 0;
#line 3564 "test-new/nrimp10s-77.imp"
BASE = RBASE;
#line 3564 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 3564 "test-new/nrimp10s-77.imp"
AREA = -1;
// 3565 %RETURN
#line 3565 "test-new/nrimp10s-77.imp"
return;
// 3566 %FINISH
#line 3566 "test-new/nrimp10s-77.imp"
L_0310:;
// 3567 NAMEP=(A(P)<<8!A(P+1))<<16!NAMEP; ! NAMEP=-1 UNALTERED !
#line 3567 "test-new/nrimp10s-77.imp"
*NAMEP = (A[P] << 8 | A[P + 1]) << 16 | *NAMEP;
// 3568 ->AE %IF ARR=1; ! ARRAYS INCLUDING RECORDARRAYS
#line 3568 "test-new/nrimp10s-77.imp"
if (ARR != 1) goto L_0311;
#line 3568 "test-new/nrimp10s-77.imp"
goto U_1029;
#line 3568 "test-new/nrimp10s-77.imp"
L_0311:;
// 3569 %IF A(P+2)=2 %THEN P=P+3 %ELSE NO APP
#line 3569 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_0312;
#line 3569 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3569 "test-new/nrimp10s-77.imp"
goto L_0313;
#line 3569 "test-new/nrimp10s-77.imp"
L_0312:;
#line 3569 "test-new/nrimp10s-77.imp"
NOAPP();
#line 3569 "test-new/nrimp10s-77.imp"
L_0313:;
// 3570 %IF TYPE<=2 %OR TYPE=5 %OR (TYPE=3 %AND A(P)=2 %AND (3<=Z<=4 %OR Z=6)) %START
#line 3570 "test-new/nrimp10s-77.imp"
if (TYPE <= 2) goto L_0314;
#line 3570 "test-new/nrimp10s-77.imp"
if (TYPE == 5) goto L_0314;
#line 3570 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_0315;
#line 3570 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0315;
#line 3570 "test-new/nrimp10s-77.imp"
{
// Double-sided test on Z (Part I)
#line 3570 "test-new/nrimp10s-77.imp"
int tmp;
#line 3570 "test-new/nrimp10s-77.imp"
if (3 > (tmp = Z)) goto L_0316;
// Double-sided test on Z (Part II)
#line 3570 "test-new/nrimp10s-77.imp"
if (tmp <= 4) goto L_0314;
#line 3570 "test-new/nrimp10s-77.imp"
}
#line 3570 "test-new/nrimp10s-77.imp"
L_0316:;
#line 3570 "test-new/nrimp10s-77.imp"
if (Z != 6) goto L_0315;
#line 3570 "test-new/nrimp10s-77.imp"
L_0314:;
// 3571 ACCESS=MODE+4+4*NAM; BASE=BS;
#line 3571 "test-new/nrimp10s-77.imp"
ACCESS = MODE + 4 + 4 * NAM;
#line 3571 "test-new/nrimp10s-77.imp"
BASE = BS;
// 3572 AREA=AR; DISP=DP; XDISP=XD+Q
#line 3572 "test-new/nrimp10s-77.imp"
AREA = AR;
#line 3572 "test-new/nrimp10s-77.imp"
DISP = DP;
#line 3572 "test-new/nrimp10s-77.imp"
XDISP = XD + Q;
// 3573 %RETURN
#line 3573 "test-new/nrimp10s-77.imp"
return;
// 3574 %FINISH
#line 3574 "test-new/nrimp10s-77.imp"
L_0315:;
// 3575 !
// 3576 ! NOW CODING BECOMES HAIRY:- STILL LEFT ARE
// 3577 ! A) RECORDS IN RECORDS Q POINTS TO SECONDARY RECORD
// 3578 ! B) RECORDNAMES IN RECORDS Q HAS OFF-SET OF A POINTER
// 3579 ! C) RECORDARRAYNAMES IN RECORDS Q HAS OFF-SET A HEADER IN RECORD
// 3580 ! D) RECORDARRAYS IN RECORDS NOT YET ALLOWED
// 3581 ! Q WOULD HAVE OFF-SET OF A RECORD RELATIVE HEADER IN THE GLA
// 3582 !
// 3583 XD=XD+Q
#line 3583 "test-new/nrimp10s-77.imp"
XD = XD + Q;
// 3584 NAMEP=-1
#line 3584 "test-new/nrimp10s-77.imp"
*NAMEP = -1;
// 3585 %IF NAM=1 %THEN %START
#line 3585 "test-new/nrimp10s-77.imp"
if (NAM != 1) goto L_0317;
// 3586 %IF MODE=0 %START
#line 3586 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_0318;
// 3587 DP=DP+XD; XD=0; MODE=2
#line 3587 "test-new/nrimp10s-77.imp"
DP = DP + XD;
#line 3587 "test-new/nrimp10s-77.imp"
XD = 0;
#line 3587 "test-new/nrimp10s-77.imp"
MODE = 2;
// 3588 %FINISH %ELSE %START
#line 3588 "test-new/nrimp10s-77.imp"
goto L_0319;
#line 3588 "test-new/nrimp10s-77.imp"
L_0318:;
// 3589 LOCALISE(8); ! PICK UP RECNAME DESCR &STCK
#line 3589 "test-new/nrimp10s-77.imp"
LOCALISE(8);
// 3590 AR=AREA; DP=DISP; BS=BASE
#line 3590 "test-new/nrimp10s-77.imp"
AR = AREA;
#line 3590 "test-new/nrimp10s-77.imp"
DP = DISP;
#line 3590 "test-new/nrimp10s-77.imp"
BS = BASE;
// 3591 %FINISH
#line 3591 "test-new/nrimp10s-77.imp"
L_0319:;
// 3592 %FINISH
#line 3592 "test-new/nrimp10s-77.imp"
L_0317:;
// 3593 CENAME(MODE,KFORM,BS,AR,DP,XD)
#line 3593 "test-new/nrimp10s-77.imp"
CENAME(MODE, KFORM, BS, AR, DP, XD);
// 3594 %RETURN
#line 3594 "test-new/nrimp10s-77.imp"
return;
// 3595 AE: ! ARRAYS AND ARRAYNAMES AS ELEMEN
#line 3595 "test-new/nrimp10s-77.imp"
U_1029:;
// 3596 FROM123(TCELL,Q,SNDISP,K)
#line 3596 "test-new/nrimp10s-77.imp"
FROM123(TCELL, /*?*/ &Q, /*?*/ &SNDISP, /*?*/ &K);
// 3597 ACC=SNDISP&16_FFFF; SNDISP=SNDISP&16_FFFF0000//16_10000
#line 3597 "test-new/nrimp10s-77.imp"
ACC = SNDISP & 65535;
#line 3597 "test-new/nrimp10s-77.imp"
SNDISP = ((long)(SNDISP & -65536) / (long)65536);
// 3598 KFORM=K&16_FFFF; K=K>>16
#line 3598 "test-new/nrimp10s-77.imp"
KFORM = K & 65535;
#line 3598 "test-new/nrimp10s-77.imp"
K = (unsigned int)K >> 16;
// 3599 C=ACC; D=SNDISP; Q=K; QQ=KFORM
#line 3599 "test-new/nrimp10s-77.imp"
C = ACC;
#line 3599 "test-new/nrimp10s-77.imp"
D = SNDISP;
#line 3599 "test-new/nrimp10s-77.imp"
Q = K;
#line 3599 "test-new/nrimp10s-77.imp"
QQ = KFORM;
// 3600 %IF (Z=6 %OR Z=12) %AND A(P+2)=2 %START;! 'GET ARRAYHEAD' CALL
#line 3600 "test-new/nrimp10s-77.imp"
if (Z == 6) goto L_031A;
#line 3600 "test-new/nrimp10s-77.imp"
if (Z != 12) goto L_031B;
#line 3600 "test-new/nrimp10s-77.imp"
L_031A:;
#line 3600 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_031B;
// 3601 P=P+3
#line 3601 "test-new/nrimp10s-77.imp"
P = P + 3;
// 3602 %IF NAM=1 %THEN %START
#line 3602 "test-new/nrimp10s-77.imp"
if (NAM != 1) goto L_031C;
// 3603 ACCESS=MODE+8; BASE=BS
#line 3603 "test-new/nrimp10s-77.imp"
ACCESS = MODE + 8;
#line 3603 "test-new/nrimp10s-77.imp"
BASE = BS;
// 3604 AREA=AR; DISP=DP; XDISP=XD+Q
#line 3604 "test-new/nrimp10s-77.imp"
AREA = AR;
#line 3604 "test-new/nrimp10s-77.imp"
DISP = DP;
#line 3604 "test-new/nrimp10s-77.imp"
XDISP = XD + Q;
// 3605 %RETURN
#line 3605 "test-new/nrimp10s-77.imp"
return;
// 3606 %FINISH
#line 3606 "test-new/nrimp10s-77.imp"
L_031C:;
// 3607 !
// 3608 ! PASSING AN ARRAY IN A RECORD BY NAME MUST CONSTRUCT PROPER ARRAYHEAD
// 3609 ! FROM THE RECORD RELATIVE ONE AT Q(GLA)
// 3610 !
// 3611 NAMEP=-1
#line 3611 "test-new/nrimp10s-77.imp"
*NAMEP = -1;
// 3612 FETCH RAD
#line 3612 "test-new/nrimp10s-77.imp"
FETCHRAD();
// 3613 AREA=-1; DISP=Q
#line 3613 "test-new/nrimp10s-77.imp"
AREA = -1;
#line 3613 "test-new/nrimp10s-77.imp"
DISP = Q;
// 3614 BASE=0; ACCESS=0;
#line 3614 "test-new/nrimp10s-77.imp"
BASE = 0;
#line 3614 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 3615 CREATE AH(1)
#line 3615 "test-new/nrimp10s-77.imp"
CREATEAH(1);
// 3616 %FINISH %ELSE %START; ! ARRAY ELEMENTS IN RECORDS
#line 3616 "test-new/nrimp10s-77.imp"
goto L_031D;
#line 3616 "test-new/nrimp10s-77.imp"
L_031B:;
// 3617 NAMEP=-1
#line 3617 "test-new/nrimp10s-77.imp"
*NAMEP = -1;
// 3618 %IF NAM=1 %THEN %START; ! ARRAYNAMES-FULLHEAD IN RECORD
#line 3618 "test-new/nrimp10s-77.imp"
if (NAM != 1) goto L_031E;
// 3619 XD=XD+Q
#line 3619 "test-new/nrimp10s-77.imp"
XD = XD + Q;
// 3620 LOCALISE(16); ! MOVE HEAD UNDER LNB
#line 3620 "test-new/nrimp10s-77.imp"
LOCALISE(16);
// 3621 CANAME(3,BASE,DISP); ! ARRAY MODE SETS DISP,AREA&BASE
#line 3621 "test-new/nrimp10s-77.imp"
CANAME(3, BASE, DISP);
// 3622 %FINISH %ELSE %START; ! ARRAY RELATIVE HEAD IN GLA
#line 3622 "test-new/nrimp10s-77.imp"
goto L_031F;
#line 3622 "test-new/nrimp10s-77.imp"
L_031E:;
// 3623 %IF MODE=0 %OR MODE=2 %%START
#line 3623 "test-new/nrimp10s-77.imp"
if (MODE == 0) goto L_0320;
#line 3623 "test-new/nrimp10s-77.imp"
if (MODE != 2) goto L_0321;
#line 3623 "test-new/nrimp10s-77.imp"
L_0320:;
// 3624 %IF MODE=0 %THEN W=DP-4 %ELSE W=DP+4
#line 3624 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_0322;
#line 3624 "test-new/nrimp10s-77.imp"
W = DP - 4;
#line 3624 "test-new/nrimp10s-77.imp"
goto L_0323;
#line 3624 "test-new/nrimp10s-77.imp"
L_0322:;
#line 3624 "test-new/nrimp10s-77.imp"
W = DP + 4;
#line 3624 "test-new/nrimp10s-77.imp"
L_0323:;
// 3625 %FINISH %ELSE %START
#line 3625 "test-new/nrimp10s-77.imp"
goto L_0324;
#line 3625 "test-new/nrimp10s-77.imp"
L_0321:;
// 3626 FETCH RAD; ! RECORD ADDR TO ACC
#line 3626 "test-new/nrimp10s-77.imp"
FETCHRAD();
// 3627 GET WSP(W,1)
#line 3627 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &W, 1);
// 3628 PSF1(ST,1,W); XD=0
#line 3628 "test-new/nrimp10s-77.imp"
PSF1(72, 1, W);
#line 3628 "test-new/nrimp10s-77.imp"
XD = 0;
// 3629 BS=RBASE
#line 3629 "test-new/nrimp10s-77.imp"
BS = RBASE;
// 3630 %FINISH
#line 3630 "test-new/nrimp10s-77.imp"
L_0324:;
// 3631 CANAME(3,0,Q); ! RECORD REL ARRAY ACCESS
#line 3631 "test-new/nrimp10s-77.imp"
CANAME(3, 0, Q);
// 3632 ! CAN RETURN ACCESS=1 OR 3 ONLY
// 3633 %IF PARMARR=0=PARMCHK %AND ACCESS=3 %AND (PREC=3 %OR TYPE>=3) %START
#line 3633 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 3633 "test-new/nrimp10s-77.imp"
int tmp;
#line 3633 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_0325;
// Double-sided test on 0 (Part II)
#line 3633 "test-new/nrimp10s-77.imp"
if (tmp != PARMCHK) goto L_0325;
#line 3633 "test-new/nrimp10s-77.imp"
}
#line 3633 "test-new/nrimp10s-77.imp"
if (ACCESS != 3) goto L_0325;
#line 3633 "test-new/nrimp10s-77.imp"
if (PREC == 3) goto L_0326;
#line 3633 "test-new/nrimp10s-77.imp"
if (TYPE < 3) goto L_0325;
#line 3633 "test-new/nrimp10s-77.imp"
L_0326:;
// 3634 PSORLF1(ADB,0,AREA CODE2(BS),W)
#line 3634 "test-new/nrimp10s-77.imp"
PSORLF1(32, 0, AREACODE2(BS), W);
// 3635 PSF1(ADB,0,XD) %UNLESS XD=0
#line 3635 "test-new/nrimp10s-77.imp"
if (XD == 0) goto L_0327;
#line 3635 "test-new/nrimp10s-77.imp"
PSF1(32, 0, XD);
#line 3635 "test-new/nrimp10s-77.imp"
L_0327:;
// 3636 GRUSE(BREG)=0
#line 3636 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 3637 %FINISH %ELSE %START
#line 3637 "test-new/nrimp10s-77.imp"
goto L_0328;
#line 3637 "test-new/nrimp10s-77.imp"
L_0325:;
// 3638 GET IN ACC(DR,2,0,AREA CODE,Q)
#line 3638 "test-new/nrimp10s-77.imp"
GETINACC(1, 2, 0, AREACODE(), Q);
// 3639 PSORLF1(INCA,0,AREA CODE2(BS),W)
#line 3639 "test-new/nrimp10s-77.imp"
PSORLF1(20, 0, AREACODE2(BS), W);
// 3640 %IF ACCESS=1 %THEN ACCESS=2 %AND AREA=7 %AND XD=XD+NUMMOD*BYTES(PREC)
#line 3640 "test-new/nrimp10s-77.imp"
if (ACCESS != 1) goto L_0329;
#line 3640 "test-new/nrimp10s-77.imp"
ACCESS = 2;
#line 3640 "test-new/nrimp10s-77.imp"
AREA = 7;
#line 3640 "test-new/nrimp10s-77.imp"
XD = XD + NUMMOD * BYTES[PREC];
#line 3640 "test-new/nrimp10s-77.imp"
L_0329:;
// 3641 PSF1(INCA,0,XD) %UNLESS XD=0
#line 3641 "test-new/nrimp10s-77.imp"
if (XD == 0) goto L_032A;
#line 3641 "test-new/nrimp10s-77.imp"
PSF1(20, 0, XD);
#line 3641 "test-new/nrimp10s-77.imp"
L_032A:;
// 3642 FORGET (DR)
#line 3642 "test-new/nrimp10s-77.imp"
FORGET(1);
// 3643 AREA=7; DISP=0; ! AND ACCESS = 2 OR 3 ONLY
#line 3643 "test-new/nrimp10s-77.imp"
AREA = 7;
#line 3643 "test-new/nrimp10s-77.imp"
DISP = 0;
// 3644 %IF TYPE=3 %AND A(P)=1 %START; ! WILL BE A FURTHER CALL
#line 3644 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_032B;
#line 3644 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_032B;
// 3645 ! ON ROUTINE CENAME
// 3646 GET WSP(DISP,2)
#line 3646 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &DISP, 2);
// 3647 PSF1(STD,1,DISP)
#line 3647 "test-new/nrimp10s-77.imp"
PSF1(88, 1, DISP);
// 3648 AREA=LNB; BASE=RBASE
#line 3648 "test-new/nrimp10s-77.imp"
AREA = 2;
#line 3648 "test-new/nrimp10s-77.imp"
BASE = RBASE;
// 3649 %FINISH
#line 3649 "test-new/nrimp10s-77.imp"
L_032B:;
// 3650 %FINISH
#line 3650 "test-new/nrimp10s-77.imp"
L_0328:;
// 3651 %FINISH
#line 3651 "test-new/nrimp10s-77.imp"
L_031F:;
// 3652 %IF TYPE=3 %THEN CENAME(ACCESS,QQ,BASE,AREA,DISP,0)
#line 3652 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_032C;
#line 3652 "test-new/nrimp10s-77.imp"
CENAME(ACCESS, QQ, BASE, AREA, DISP, 0);
#line 3652 "test-new/nrimp10s-77.imp"
L_032C:;
// 3653 %FINISH
#line 3653 "test-new/nrimp10s-77.imp"
L_031D:;
// 3654 %RETURN
#line 3654 "test-new/nrimp10s-77.imp"
return;
// 3655 %ROUTINE FETCH RAD
#line 3655 "test-new/nrimp10s-77.imp"
void FETCHRAD(void) {
// 3656 !***********************************************************************
// 3657 !* SET ACC TO 32 BIT ADDRESS OF RECORD. *
// 3658 !***********************************************************************
// 3659 ACCESS=MODE+4
#line 3659 "test-new/nrimp10s-77.imp"
ACCESS = MODE + 4;
// 3660 AREA=AR; BASE=BS
#line 3660 "test-new/nrimp10s-77.imp"
AREA = AR;
#line 3660 "test-new/nrimp10s-77.imp"
BASE = BS;
// 3661 DISP=DP; XDISP=XD
#line 3661 "test-new/nrimp10s-77.imp"
DISP = DP;
#line 3661 "test-new/nrimp10s-77.imp"
XDISP = XD;
// 3662 NAMEOP(4,ACCR,4,-1)
#line 3662 "test-new/nrimp10s-77.imp"
NAMEOP(4, 0, 4, -1);
// 3663 %END
#line 3663 "test-new/nrimp10s-77.imp"
return;
#line 3663 "test-new/nrimp10s-77.imp"
} /* end of FETCHRAD */
// 3664 %ROUTINE LOCALISE(%INTEGER SIZE)
#line 3664 "test-new/nrimp10s-77.imp"
void LOCALISE(int SIZE) {
// 3665 !***********************************************************************
// 3666 !* REMOVES A DESCRIPTOR OR ARRAYHEAD FROM A RECORD AND STORES *
// 3667 !* IT IN A TEMPORARY UNDER LNB. *
// 3668 !***********************************************************************
// 3669 %INTEGER HOLE
#line 3669 "test-new/nrimp10s-77.imp"
int HOLE;
// 3670 ACCESS=MODE+4
#line 3670 "test-new/nrimp10s-77.imp"
ACCESS = MODE + 4;
// 3671 AREA=AR; BASE=BS; DISP=DP
#line 3671 "test-new/nrimp10s-77.imp"
AREA = AR;
#line 3671 "test-new/nrimp10s-77.imp"
BASE = BS;
#line 3671 "test-new/nrimp10s-77.imp"
DISP = DP;
// 3672 XDISP=XD
#line 3672 "test-new/nrimp10s-77.imp"
XDISP = XD;
// 3673 NAMEOP(2,ACCR,SIZE,-1)
#line 3673 "test-new/nrimp10s-77.imp"
NAMEOP(2, 0, SIZE, -1);
// 3674 GET WSP(HOLE,SIZE>>2)
#line 3674 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &HOLE, (unsigned int)SIZE >> 2);
// 3675 PSF1(ST,1,HOLE)
#line 3675 "test-new/nrimp10s-77.imp"
PSF1(72, 1, HOLE);
// 3676 MODE=2; AREA=LNB
#line 3676 "test-new/nrimp10s-77.imp"
MODE = 2;
#line 3676 "test-new/nrimp10s-77.imp"
AREA = 2;
// 3677 BASE=RBASE; DISP=HOLE; XD=0
#line 3677 "test-new/nrimp10s-77.imp"
BASE = RBASE;
#line 3677 "test-new/nrimp10s-77.imp"
DISP = HOLE;
#line 3677 "test-new/nrimp10s-77.imp"
XD = 0;
// 3678 %END; ! OF ROUTINE LOCALISE
#line 3678 "test-new/nrimp10s-77.imp"
return;
#line 3678 "test-new/nrimp10s-77.imp"
} /* end of LOCALISE */
// 3679 %END; ! OF ROUTINE CENAME
#line 3679 "test-new/nrimp10s-77.imp"
return;
#line 3679 "test-new/nrimp10s-77.imp"
} /* end of CENAME */
// 3680 %END;
#line 3680 "test-new/nrimp10s-77.imp"
return;
#line 3680 "test-new/nrimp10s-77.imp"
} /* end of CRNAME */
// ?REG unused
// 3681 ; ! OF ROUTINE CRNAME
#line 3681 "test-new/nrimp10s-77.imp"
void CSTREXP(int MODE, int REG) {
// 3681 %ROUTINE CSTREXP(%INTEGER MODE,REG)
// 3682 !***********************************************************************
// 3683 !* PLANT IN-LINE CODE FOR CONCATENATION. A WORK AREA UNDER *
// 3684 !* BASE REGISTER COVER IS USUALLY REQUIRED. THE CURRENT LENGTH *
// 3685 !* OF STRING IN THE WORK AREA IS KEPT IN A REGISTER (BREG) *
// 3686 !* WHICH IS PROTECTED THROUGH THE NORMAL INTERMEDIATE-RESULT *
// 3687 !* MECHANISMS. *
// 3688 !* ON ENTRY:- *
// 3689 !* MODE=0 NORMAL. WK AREA NOT USED FOR ONE OPERAND EXPSSNS *
// 3690 !* MODE=1 STRING MUST GO TO WORK AREA *
// 3691 !* (AND TO COME) *
// 3692 !* MODE=3 CONCATENATE INTO LHS OF =ASSNMNT (E.G. A=B.C) *
// 3693 !* MODE=4 OPTIMISE S=S.T BY NOT COPYING S *
// 3694 !* 2**4 BIT OF MODE IS SET IF WK-AREA NOT TO BE FREED ON EXIT *
// 3695 !* ON EXIT:- *
// 3696 !* BASE,DISP & INDEX DEFINE RESULT *
// 3697 !* VALUE#0 %IF RESULT IN A WORK AREA(CCOND MUST KNOW) *
// 3698 !* STRINGL SET IF STRING LENGTH KNOWN. STRFNRES DEFINES LENREG *
// 3699 !***********************************************************************
// 3700 %INTEGER PP,WKAREA,DOTS,REXP,ERR,CLEN,KEEPWA,FNAM
#line 3700 "test-new/nrimp10s-77.imp"
int PP;
#line 3700 "test-new/nrimp10s-77.imp"
int WKAREA;
#line 3700 "test-new/nrimp10s-77.imp"
int DOTS;
#line 3700 "test-new/nrimp10s-77.imp"
int REXP;
#line 3700 "test-new/nrimp10s-77.imp"
int ERR;
#line 3700 "test-new/nrimp10s-77.imp"
int CLEN;
#line 3700 "test-new/nrimp10s-77.imp"
int KEEPWA;
#line 3700 "test-new/nrimp10s-77.imp"
int FNAM;
#line 3700 "test-new/nrimp10s-77.imp"
auto int STROP(int REG);
// 3701 %INTEGERFNSPEC STROP(%INTEGER REG)
// 3702 KEEPWA=MODE&16; MODE=MODE&15
#line 3702 "test-new/nrimp10s-77.imp"
KEEPWA = MODE & 16;
#line 3702 "test-new/nrimp10s-77.imp"
MODE = MODE & 15;
// 3703 PP=P; STRINGL=0; FNAM=0; WKAREA=0
#line 3703 "test-new/nrimp10s-77.imp"
PP = P;
#line 3703 "test-new/nrimp10s-77.imp"
STRINGL = 0;
#line 3703 "test-new/nrimp10s-77.imp"
FNAM = 0;
#line 3703 "test-new/nrimp10s-77.imp"
WKAREA = 0;
// 3704 REXP=2-A(P+1+FROM AR2(P+1)); ! =0 %IF ONE OPERAND EXP
#line 3704 "test-new/nrimp10s-77.imp"
REXP = 2 - A[P + 1 + FROMAR2(P + 1)];
// 3705 -> NORMAL %UNLESS A(P+3)=4 %AND REXP=0 %AND MODE=0
#line 3705 "test-new/nrimp10s-77.imp"
if (A[P + 3] != 4) goto L_032D;
#line 3705 "test-new/nrimp10s-77.imp"
if (REXP != 0) goto L_032D;
#line 3705 "test-new/nrimp10s-77.imp"
if (MODE == 0) goto L_032E;
#line 3705 "test-new/nrimp10s-77.imp"
L_032D:;
#line 3705 "test-new/nrimp10s-77.imp"
goto U_102A;
#line 3705 "test-new/nrimp10s-77.imp"
L_032E:;
// 3706 -> SIMPLE %IF A(P+4)=2
#line 3706 "test-new/nrimp10s-77.imp"
if (A[P + 4] != 2) goto L_032F;
#line 3706 "test-new/nrimp10s-77.imp"
goto U_1021;
#line 3706 "test-new/nrimp10s-77.imp"
L_032F:;
// 3707 -> NORMAL %UNLESS A(P+4)=1
#line 3707 "test-new/nrimp10s-77.imp"
if (A[P + 4] == 1) goto L_0330;
#line 3707 "test-new/nrimp10s-77.imp"
goto U_102A;
#line 3707 "test-new/nrimp10s-77.imp"
L_0330:;
// 3708 ! COPY TAG(FROM AR2(P+5))
// 3709 ! %IF PTYPE=SNPT %THEN PTYPE=TSNAME(K)
// 3710 ! -> NORMAL %UNLESS ROUT=0 ; ! BEWARE OF MAP=FN
// 3711 ! -> NORMAL %IF PARMARR=1 %AND(ARR#0 %OR A(P+7)=1)
// 3712 SIMPLE: P=P+4
#line 3712 "test-new/nrimp10s-77.imp"
U_1021:;
#line 3712 "test-new/nrimp10s-77.imp"
P = P + 4;
// 3713 ERR=STROP(REG)
#line 3713 "test-new/nrimp10s-77.imp"
ERR = STROP(REG);
// 3714 -> ERROR %UNLESS ERR=0
#line 3714 "test-new/nrimp10s-77.imp"
if (ERR == 0) goto L_0331;
#line 3714 "test-new/nrimp10s-77.imp"
goto U_1022;
#line 3714 "test-new/nrimp10s-77.imp"
L_0331:;
// 3715 VALUE=WKAREA
#line 3715 "test-new/nrimp10s-77.imp"
VALUE = WKAREA;
// 3716 P=P+1; STRFNRES=0
#line 3716 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3716 "test-new/nrimp10s-77.imp"
STRFNRES = 0;
// 3717 %RETURN
#line 3717 "test-new/nrimp10s-77.imp"
return;
// 3718 ERROR: FAULT2(ERR,0,FNAM)
#line 3718 "test-new/nrimp10s-77.imp"
U_1022:;
#line 3718 "test-new/nrimp10s-77.imp"
FAULT2(ERR, 0, FNAM);
// 3719 BASE=RBASE; DISP=0
#line 3719 "test-new/nrimp10s-77.imp"
BASE = RBASE;
#line 3719 "test-new/nrimp10s-77.imp"
DISP = 0;
// 3720 VALUE=0; ACCESS=0
#line 3720 "test-new/nrimp10s-77.imp"
VALUE = 0;
#line 3720 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 3721 P=PP; SKIP EXP
#line 3721 "test-new/nrimp10s-77.imp"
P = PP;
#line 3721 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 3722 %RETURN
#line 3722 "test-new/nrimp10s-77.imp"
return;
// 3723 NORMAL: CLEN=0; P=P+3; ! LENGTH OF CONSTANT PART
#line 3723 "test-new/nrimp10s-77.imp"
U_102A:;
#line 3723 "test-new/nrimp10s-77.imp"
CLEN = 0;
#line 3723 "test-new/nrimp10s-77.imp"
P = P + 3;
// 3724 ERR=72; ->ERROR %UNLESS A(P)=4
#line 3724 "test-new/nrimp10s-77.imp"
ERR = 72;
#line 3724 "test-new/nrimp10s-77.imp"
if (A[P] == 4) goto L_0332;
#line 3724 "test-new/nrimp10s-77.imp"
goto U_1022;
#line 3724 "test-new/nrimp10s-77.imp"
L_0332:;
// 3725 P=P+1
#line 3725 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3726 GET WSP(WKAREA,268); ! GET NEXT OPERAND
#line 3726 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &WKAREA, 268);
// 3727 DOTS=0; ! NO OPERATORS YET
#line 3727 "test-new/nrimp10s-77.imp"
DOTS = 0;
// 3728 NEXT: STRINGL=0
#line 3728 "test-new/nrimp10s-77.imp"
U_1023:;
#line 3728 "test-new/nrimp10s-77.imp"
STRINGL = 0;
// 3729 ERR=STROP(DR); ! GET NEXT OPERAND
#line 3729 "test-new/nrimp10s-77.imp"
ERR = STROP(1);
// 3730 -> ERROR %UNLESS ERR=0
#line 3730 "test-new/nrimp10s-77.imp"
if (ERR == 0) goto L_0333;
#line 3730 "test-new/nrimp10s-77.imp"
goto U_1022;
#line 3730 "test-new/nrimp10s-77.imp"
L_0333:;
// 3731 %IF REGISTER(ACCR)#0 %THEN BOOT OUT(ACCR)
#line 3731 "test-new/nrimp10s-77.imp"
if (REGISTER[0] == 0) goto L_0334;
#line 3731 "test-new/nrimp10s-77.imp"
BOOTOUT(0);
#line 3731 "test-new/nrimp10s-77.imp"
L_0334:;
// 3732 PSF1(LB,0,WKAREA); ! BYTE DISP FROM LNB
#line 3732 "test-new/nrimp10s-77.imp"
PSF1(122, 0, WKAREA);
// 3733 PPJ(0,19+DOTS); ! TO SUBROUTINE 19 OR 20
#line 3733 "test-new/nrimp10s-77.imp"
PPJ(0, 19 + DOTS);
// 3734 %IF A(P)=2 %THEN -> TIDY; ! NO MORE OPERATIONS
#line 3734 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0335;
#line 3734 "test-new/nrimp10s-77.imp"
goto U_102B;
#line 3734 "test-new/nrimp10s-77.imp"
L_0335:;
// 3735 ERR=72; -> ERROR %UNLESS A(P+1)=CONCOP; ! CONCATENATE
#line 3735 "test-new/nrimp10s-77.imp"
ERR = 72;
#line 3735 "test-new/nrimp10s-77.imp"
if (A[P + 1] == 13) goto L_0336;
#line 3735 "test-new/nrimp10s-77.imp"
goto U_1022;
#line 3735 "test-new/nrimp10s-77.imp"
L_0336:;
// 3736 DOTS=DOTS!1
#line 3736 "test-new/nrimp10s-77.imp"
DOTS = DOTS | 1;
// 3737 P=P+2; -> NEXT
#line 3737 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 3737 "test-new/nrimp10s-77.imp"
goto U_1023;
// 3738 TIDY: ! FINISH OFF
#line 3738 "test-new/nrimp10s-77.imp"
U_102B:;
// 3739 VALUE=WKAREA
#line 3739 "test-new/nrimp10s-77.imp"
VALUE = WKAREA;
// 3740 P=P+1; ! PAST REST OF EXPRN
#line 3740 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3741 RETURN WSP(WKAREA,268) %IF KEEPWA=0
#line 3741 "test-new/nrimp10s-77.imp"
if (KEEPWA != 0) goto L_0337;
#line 3741 "test-new/nrimp10s-77.imp"
RETURNWSP(WKAREA, 268);
#line 3741 "test-new/nrimp10s-77.imp"
L_0337:;
// 3742 STRINGL=0
#line 3742 "test-new/nrimp10s-77.imp"
STRINGL = 0;
// 3743 %RETURN
#line 3743 "test-new/nrimp10s-77.imp"
return;
// 3744 %INTEGERFN STROP(%INTEGER REG)
#line 3744 "test-new/nrimp10s-77.imp"
int STROP(int REG) {
// 3745 !***********************************************************************
// 3746 !* DEALS WITH OPERAND FOR CONCATENATION. RETURN RESULT=0 FOR *
// 3747 !* VALID OPERAND OTHERWISE AN ERROR NUMBER. *
// 3748 !***********************************************************************
// 3749 %INTEGER CTYPE,VAL,MODE
#line 3749 "test-new/nrimp10s-77.imp"
int CTYPE;
#line 3749 "test-new/nrimp10s-77.imp"
int VAL;
#line 3749 "test-new/nrimp10s-77.imp"
int MODE;
// 3750 MODE=A(P); ! ALTERNATIVE OF OPERAND
#line 3750 "test-new/nrimp10s-77.imp"
MODE = A[P];
// 3751 %RESULT=75 %IF MODE>2
#line 3751 "test-new/nrimp10s-77.imp"
if (MODE <= 2) goto L_0338;
#line 3751 "test-new/nrimp10s-77.imp"
return 75;
#line 3751 "test-new/nrimp10s-77.imp"
L_0338:;
// 3752 %IF MODE#1 %THEN %START
#line 3752 "test-new/nrimp10s-77.imp"
if (MODE == 1) goto L_0339;
// 3753 CTYPE=A(P+1); ! GET CONST TYPE & LOSE AMCK FLAGS
#line 3753 "test-new/nrimp10s-77.imp"
CTYPE = A[P + 1];
// 3754 %IF CTYPE=16_35 %THEN %START
#line 3754 "test-new/nrimp10s-77.imp"
if (CTYPE != 53) goto L_033A;
// 3755 STRINGL=A(P+6)
#line 3755 "test-new/nrimp10s-77.imp"
STRINGL = A[P + 6];
// 3756 DISP=FROM AR4(P+2)
#line 3756 "test-new/nrimp10s-77.imp"
DISP = FROMAR4(P + 2);
// 3757 P=P+STRINGL+7
#line 3757 "test-new/nrimp10s-77.imp"
P = P + STRINGL + 7;
// 3758 %FINISH %ELSE %RESULT=71
#line 3758 "test-new/nrimp10s-77.imp"
goto L_033B;
#line 3758 "test-new/nrimp10s-77.imp"
L_033A:;
#line 3758 "test-new/nrimp10s-77.imp"
return 71;
#line 3758 "test-new/nrimp10s-77.imp"
L_033B:;
// 3759 PF1(LDRL,0,PC,STRLINK)
#line 3759 "test-new/nrimp10s-77.imp"
PF1(112, 0, 4, STRLINK);
// 3760 PSF1(INCA,0,DISP) %IF DISP#0
#line 3760 "test-new/nrimp10s-77.imp"
if (DISP == 0) goto L_033C;
#line 3760 "test-new/nrimp10s-77.imp"
PSF1(20, 0, DISP);
#line 3760 "test-new/nrimp10s-77.imp"
L_033C:;
// 3761 %IF STRINGL#1 %THEN %START
#line 3761 "test-new/nrimp10s-77.imp"
if (STRINGL == 1) goto L_033D;
// 3762 %IF STRINGL<=63 %THEN PSF1(LDB,0,STRINGL) %ELSE PF1(LDB,2,7,0);! ((DR))
#line 3762 "test-new/nrimp10s-77.imp"
if (STRINGL > 63) goto L_033E;
#line 3762 "test-new/nrimp10s-77.imp"
PSF1(118, 0, STRINGL);
#line 3762 "test-new/nrimp10s-77.imp"
goto L_033F;
#line 3762 "test-new/nrimp10s-77.imp"
L_033E:;
#line 3762 "test-new/nrimp10s-77.imp"
PF1(118, 2, 7, 0);
#line 3762 "test-new/nrimp10s-77.imp"
L_033F:;
// 3763 %FINISH
#line 3763 "test-new/nrimp10s-77.imp"
L_033D:;
// 3764 GRUSE(DR)=0
#line 3764 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 3765 %IF REG=ACCR %THEN COPY DR
#line 3765 "test-new/nrimp10s-77.imp"
if (REG != 0) goto L_0340;
#line 3765 "test-new/nrimp10s-77.imp"
COPYDR();
#line 3765 "test-new/nrimp10s-77.imp"
L_0340:;
// 3766 %FINISH %ELSE %START
#line 3766 "test-new/nrimp10s-77.imp"
goto L_0341;
#line 3766 "test-new/nrimp10s-77.imp"
L_0339:;
// 3767 P=P+1; ! MUST CHECK FIRST
#line 3767 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3768 REDUCE TAG; ! SINCE CNAME ONLY LOADS STRINGS
#line 3768 "test-new/nrimp10s-77.imp"
REDUCETAG();
// 3769 ! AND LONGINTS TO DR!
// 3770 %IF 5#TYPE#7 %THEN FNAM=FROMAR2(P) %AND %RESULT=71
#line 3770 "test-new/nrimp10s-77.imp"
{
// Double-sided test on TYPE (Part I)
#line 3770 "test-new/nrimp10s-77.imp"
int tmp;
#line 3770 "test-new/nrimp10s-77.imp"
if (5 == (tmp = TYPE)) goto L_0342;
// Double-sided test on TYPE (Part II)
#line 3770 "test-new/nrimp10s-77.imp"
if (tmp == 7) goto L_0342;
#line 3770 "test-new/nrimp10s-77.imp"
}
#line 3770 "test-new/nrimp10s-77.imp"
FNAM = FROMAR2(P);
#line 3770 "test-new/nrimp10s-77.imp"
return 71;
#line 3770 "test-new/nrimp10s-77.imp"
L_0342:;
// 3771 CNAME(2,REG)
#line 3771 "test-new/nrimp10s-77.imp"
CNAME(2, REG);
// 3772 STRINGL=0
#line 3772 "test-new/nrimp10s-77.imp"
STRINGL = 0;
// 3773 %IF ROUT#0 %AND NAM<=1 %START;! WAS FUNCTION NOT MAP
#line 3773 "test-new/nrimp10s-77.imp"
if (ROUT == 0) goto L_0343;
#line 3773 "test-new/nrimp10s-77.imp"
if (NAM > 1) goto L_0343;
// 3774 %IF WKAREA=0 %AND KEEPWA#0 %THEN WKAREA=STRFNRES %ELSE RETURN WSP(STRFNRES,268)
#line 3774 "test-new/nrimp10s-77.imp"
if (WKAREA != 0) goto L_0344;
#line 3774 "test-new/nrimp10s-77.imp"
if (KEEPWA == 0) goto L_0344;
#line 3774 "test-new/nrimp10s-77.imp"
WKAREA = STRFNRES;
#line 3774 "test-new/nrimp10s-77.imp"
goto L_0345;
#line 3774 "test-new/nrimp10s-77.imp"
L_0344:;
#line 3774 "test-new/nrimp10s-77.imp"
RETURNWSP(STRFNRES, 268);
#line 3774 "test-new/nrimp10s-77.imp"
L_0345:;
// 3775 %FINISH
#line 3775 "test-new/nrimp10s-77.imp"
L_0343:;
// 3776 %FINISH
#line 3776 "test-new/nrimp10s-77.imp"
L_0341:;
// 3777 %RESULT=0
#line 3777 "test-new/nrimp10s-77.imp"
return 0;
// 3778 %END;
#line 3778 "test-new/nrimp10s-77.imp"
} /* end of STROP */
// ?VAL unused
// 3779 ; ! OF INTEGERFN STROP
#line 3779 "test-new/nrimp10s-77.imp"
return;
#line 3779 "test-new/nrimp10s-77.imp"
} /* end of CSTREXP */
// 3779 %END; ! OF ROUTINE CSTREXP
// 3780 %ROUTINE CRES (%INTEGER LAB)
#line 3780 "test-new/nrimp10s-77.imp"
void CRES(int LAB) {
// 3781 !**********************************************************************
// 3782 !* COMPILES A RESOLUTION E.G A->B.(C).D.(E).F AND JUMPS TO LAB *
// 3783 !* ON FAILURE. (LAB=0 FOR UNCONDITIONAL RESOLUTION TO PERM ON *
// 3784 !* FAILURE ). *
// 3785 !* THE METHOD IS TO CALL A SUBROUTINE PASSING 3 PARAMS:- *
// 3786 !* P1 POINTS TO LHS(A) *
// 3787 !* P2 STRING TO CONTAIN FRAGMENT (PASSED BY NAME) *
// 3788 !* P3 THE EXPRESSION PASSED AS DESCRIPTOR *
// 3789 !* SUBROUTINE TRIES TO PERFORM THE RESOLUTION AND SETS THE *
// 3790 !* CONDITION CODE =8 IF IT SUCCEEDS. *
// 3791 !* *
// 3792 !* ON ENTRY LHS IS DEFINED BY DESCRIPTOR REG. *
// 3793 !* P POINTS TO P(+') OF RHS DEFINED AS (+')(OPERAND)(RESTOFEXP) *
// 3794 !* *
// 3795 !$ THE ROUTINE IS COMPACT BUT DIFFICULT TO FOLLOW (OR ALTER) *
// 3796 !* THE TIME IN PERM IS LARGE SO IT IS NOT WORTHWHILE TO PERSUE *
// 3797 !* CODE EFFICIENCY TOO INDUSTRIOUSLY . *
// 3798 !**********************************************************************
// 3799 %INTEGER P1,P2,SEXPRN,W,LAST,ERR,FNAM
#line 3799 "test-new/nrimp10s-77.imp"
int P1;
#line 3799 "test-new/nrimp10s-77.imp"
int P2;
#line 3799 "test-new/nrimp10s-77.imp"
int SEXPRN;
#line 3799 "test-new/nrimp10s-77.imp"
int W;
#line 3799 "test-new/nrimp10s-77.imp"
int LAST;
#line 3799 "test-new/nrimp10s-77.imp"
int ERR;
#line 3799 "test-new/nrimp10s-77.imp"
int FNAM;
// 3800 %RECORD (RD) R{(RD)
#line 3800 "test-new/nrimp10s-77.imp"
struct RD R;
// 3801 LAST=0; FNAM=0; ! =1 WHEN END OF EXPRNSN FOUND
#line 3801 "test-new/nrimp10s-77.imp"
LAST = 0;
#line 3801 "test-new/nrimp10s-77.imp"
FNAM = 0;
// 3802 SEXPRN=0; ! RESOLUTION(BRKTD) EXPRESSNS
#line 3802 "test-new/nrimp10s-77.imp"
SEXPRN = 0;
// 3803 ERR=74; ! NORMAL CRES FAULT
#line 3803 "test-new/nrimp10s-77.imp"
ERR = 74;
// 3804 PSF1(INCA,0,1); ! TO FIRST CHAR
#line 3804 "test-new/nrimp10s-77.imp"
PSF1(20, 0, 1);
// 3805 P1=P; P=P+3
#line 3805 "test-new/nrimp10s-77.imp"
P1 = P;
#line 3805 "test-new/nrimp10s-77.imp"
P = P + 3;
// 3806 ->RES %IF A(P)=4; ! LHS MUST BE A STRING
#line 3806 "test-new/nrimp10s-77.imp"
if (A[P] != 4) goto L_0346;
#line 3806 "test-new/nrimp10s-77.imp"
goto U_102C;
#line 3806 "test-new/nrimp10s-77.imp"
L_0346:;
// 3807 ! BUT THIS CHECKED BEFORE CALL
// 3808 ERR=72
#line 3808 "test-new/nrimp10s-77.imp"
ERR = 72;
// 3809 ERROR: FAULT2(ERR,0,FNAM)
#line 3809 "test-new/nrimp10s-77.imp"
U_102D:;
#line 3809 "test-new/nrimp10s-77.imp"
FAULT2(ERR, 0, FNAM);
// 3810 P=P1; SKIP EXP; %RETURN
#line 3810 "test-new/nrimp10s-77.imp"
P = P1;
#line 3810 "test-new/nrimp10s-77.imp"
SKIPEXP();
#line 3810 "test-new/nrimp10s-77.imp"
return;
// 3811 RES: P=P+1; ! TO P(OPERAND)
#line 3811 "test-new/nrimp10s-77.imp"
U_102C:;
#line 3811 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3812 PSF1(PRCL,0,4)
#line 3812 "test-new/nrimp10s-77.imp"
PSF1(24, 0, 4);
// 3813 %IF SEXPRN=0 %THEN W=STD %ELSE W=ST
#line 3813 "test-new/nrimp10s-77.imp"
if (SEXPRN != 0) goto L_0347;
#line 3813 "test-new/nrimp10s-77.imp"
W = 88;
#line 3813 "test-new/nrimp10s-77.imp"
goto L_0348;
#line 3813 "test-new/nrimp10s-77.imp"
L_0347:;
#line 3813 "test-new/nrimp10s-77.imp"
W = 72;
#line 3813 "test-new/nrimp10s-77.imp"
L_0348:;
// 3814 PF1(W,0,TOS,0)
#line 3814 "test-new/nrimp10s-77.imp"
PF1(W, 0, 6, 0);
// 3815 %IF A(P)=3 %THEN PSF1(LSD,0,0) %AND GRUSE(ACCR)=0 %ELSE %START;! B OMITTED
#line 3815 "test-new/nrimp10s-77.imp"
if (A[P] != 3) goto L_0349;
#line 3815 "test-new/nrimp10s-77.imp"
PSF1(100, 0, 0);
#line 3815 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
#line 3815 "test-new/nrimp10s-77.imp"
goto L_034A;
#line 3815 "test-new/nrimp10s-77.imp"
L_0349:;
// 3816 ->ERROR %UNLESS A(P)=1; ! P(OPERAND)=NAME
#line 3816 "test-new/nrimp10s-77.imp"
if (A[P] == 1) goto L_034B;
#line 3816 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3816 "test-new/nrimp10s-77.imp"
L_034B:;
// 3817 P=P+1; P2=P
#line 3817 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 3817 "test-new/nrimp10s-77.imp"
P2 = P;
// 3818 CNAME(3,ACCR)
#line 3818 "test-new/nrimp10s-77.imp"
CNAME(3, 0);
// 3819 %IF TYPE#5 %THEN ERR=71 %AND FNAM=FROMAR2(P2) %AND ->ERROR
#line 3819 "test-new/nrimp10s-77.imp"
if (TYPE == 5) goto L_034C;
#line 3819 "test-new/nrimp10s-77.imp"
ERR = 71;
#line 3819 "test-new/nrimp10s-77.imp"
FNAM = FROMAR2(P2);
#line 3819 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3819 "test-new/nrimp10s-77.imp"
L_034C:;
// 3820 %IF A(P+1)#CONCOP %THEN ERR=72 %AND ->ERROR
#line 3820 "test-new/nrimp10s-77.imp"
if (A[P + 1] == 13) goto L_034D;
#line 3820 "test-new/nrimp10s-77.imp"
ERR = 72;
#line 3820 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3820 "test-new/nrimp10s-77.imp"
L_034D:;
// 3821 P=P+2
#line 3821 "test-new/nrimp10s-77.imp"
P = P + 2;
// 3822 %FINISH
#line 3822 "test-new/nrimp10s-77.imp"
L_034A:;
// 3823 PF1(ST,0,TOS,0); ! B (OR DUMMY) TO P2
#line 3823 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 3824 ->ERROR %UNLESS A(P)=3; ! P(OPERAND)='('(EXPR)')'
#line 3824 "test-new/nrimp10s-77.imp"
if (A[P] == 3) goto L_034E;
#line 3824 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3824 "test-new/nrimp10s-77.imp"
L_034E:;
// 3825 SEXPRN=SEXPRN+1; P=P+1
#line 3825 "test-new/nrimp10s-77.imp"
SEXPRN = SEXPRN + 1;
#line 3825 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3826 CSTREXP(0,DR); ! TO REGISTER DR
#line 3826 "test-new/nrimp10s-77.imp"
CSTREXP(0, 1);
// 3827 !
// 3828 PF1(STD,0,TOS,0)
#line 3828 "test-new/nrimp10s-77.imp"
PF1(88, 0, 6, 0);
// 3829 PSF1(RALN,0,11)
#line 3829 "test-new/nrimp10s-77.imp"
PSF1(108, 0, 11);
// 3830 PPJ(-1,16)
#line 3830 "test-new/nrimp10s-77.imp"
PPJ(-1, 16);
// 3831 ! DEAL WITH CC#8 IE RESLN FAILED
// 3832 %IF LAB#0 %THEN ENTER JUMP(7,LAB,B'11') %ELSE PPJ(7,12)
#line 3832 "test-new/nrimp10s-77.imp"
if (LAB == 0) goto L_034F;
#line 3832 "test-new/nrimp10s-77.imp"
ENTERJUMP(7, LAB, 3);
#line 3832 "test-new/nrimp10s-77.imp"
goto L_0350;
#line 3832 "test-new/nrimp10s-77.imp"
L_034F:;
#line 3832 "test-new/nrimp10s-77.imp"
PPJ(7, 12);
#line 3832 "test-new/nrimp10s-77.imp"
L_0350:;
// 3833 !
// 3834 -> END %IF A(P)=2
#line 3834 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0351;
#line 3834 "test-new/nrimp10s-77.imp"
goto U_102A;
#line 3834 "test-new/nrimp10s-77.imp"
L_0351:;
// 3835 %IF A(P+1)#CONCOP %THEN ERR=72 %AND ->ERROR
#line 3835 "test-new/nrimp10s-77.imp"
if (A[P + 1] == 13) goto L_0352;
#line 3835 "test-new/nrimp10s-77.imp"
ERR = 72;
#line 3835 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3835 "test-new/nrimp10s-77.imp"
L_0352:;
// 3836 ->ERROR %UNLESS A(P+2)=1
#line 3836 "test-new/nrimp10s-77.imp"
if (A[P + 2] == 1) goto L_0353;
#line 3836 "test-new/nrimp10s-77.imp"
goto U_102D;
#line 3836 "test-new/nrimp10s-77.imp"
L_0353:;
// 3837 P2=P+1; P=P2+1
#line 3837 "test-new/nrimp10s-77.imp"
P2 = P + 1;
#line 3837 "test-new/nrimp10s-77.imp"
P = P2 + 1;
// 3838 P=P+3 %AND SKIP APP %UNTIL A(P)=2
#line 3838 "test-new/nrimp10s-77.imp"
L_0354:;
#line 3838 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 3838 "test-new/nrimp10s-77.imp"
SKIPAPP();
#line 3838 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0355;
#line 3838 "test-new/nrimp10s-77.imp"
goto L_0354;
#line 3838 "test-new/nrimp10s-77.imp"
L_0355:;
// 3839 %IF A(P+1)=1 %THEN P=P2 %AND ->RES
#line 3839 "test-new/nrimp10s-77.imp"
if (A[P + 1] != 1) goto L_0356;
#line 3839 "test-new/nrimp10s-77.imp"
P = P2;
#line 3839 "test-new/nrimp10s-77.imp"
goto U_102C;
#line 3839 "test-new/nrimp10s-77.imp"
L_0356:;
// 3840 P1=P+1
#line 3840 "test-new/nrimp10s-77.imp"
P1 = P + 1;
// 3841 REGISTER(ACCR)=1
#line 3841 "test-new/nrimp10s-77.imp"
REGISTER[0] = 1;
// 3842 OLINK(ACCR)=ADDR(R)
#line 3842 "test-new/nrimp10s-77.imp"
OLINK[0] = _imp_ADDR(/*?*/ &R);
// 3843 R_PTYPE=1; R_XB=ACCR
#line 3843 "test-new/nrimp10s-77.imp"
R.PTYPE = 1;
#line 3843 "test-new/nrimp10s-77.imp"
R.XB = 0;
// 3844 R_FLAG=9
#line 3844 "test-new/nrimp10s-77.imp"
R.FLAG = 9;
// 3845 P=P2+2; CNAME(1,DR)
#line 3845 "test-new/nrimp10s-77.imp"
P = P2 + 2;
#line 3845 "test-new/nrimp10s-77.imp"
CNAME(1, 1);
// 3846 %IF R_FLAG#9 %THEN PF1(LSD,0,TOS,0)
#line 3846 "test-new/nrimp10s-77.imp"
if (R.FLAG == 9) goto L_0357;
#line 3846 "test-new/nrimp10s-77.imp"
PF1(100, 0, 6, 0);
#line 3846 "test-new/nrimp10s-77.imp"
L_0357:;
// 3847 REGISTER(ACCR)=0
#line 3847 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 3848 PF1(STUH,0,BREG,0)
#line 3848 "test-new/nrimp10s-77.imp"
PF1(74, 0, 7, 0);
// 3849 PF1(LUH,0,BREG,0)
#line 3849 "test-new/nrimp10s-77.imp"
PF1(106, 0, 7, 0);
// 3850 PF2(MVL,0,0,0,0,0)
#line 3850 "test-new/nrimp10s-77.imp"
PF2(176, 0, 0, 0, 0, 0);
// 3851 %IF ROUT#0 %OR NAM#0 %THEN PPJ(0,18);! ASSNMNT CHECK (Q.V)
#line 3851 "test-new/nrimp10s-77.imp"
if (ROUT != 0) goto L_0358;
#line 3851 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_0359;
#line 3851 "test-new/nrimp10s-77.imp"
L_0358:;
#line 3851 "test-new/nrimp10s-77.imp"
PPJ(0, 18);
#line 3851 "test-new/nrimp10s-77.imp"
L_0359:;
// 3852 PF2(MV,1,1,0,0,UNASSPAT&255)
#line 3852 "test-new/nrimp10s-77.imp"
PF2(178, 1, 1, 0, 0, -2122219135 & 255);
// 3853 GRUSE(ACCR)=0
#line 3853 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 3854 %IF PARMARR=1 %START
#line 3854 "test-new/nrimp10s-77.imp"
if (PARMARR != 1) goto L_035A;
// 3855 PSF1(USH,0,8)
#line 3855 "test-new/nrimp10s-77.imp"
PSF1(200, 0, 8);
// 3856 PSF1(USH,0,-40)
#line 3856 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -40);
// 3857 PPJ(36,9)
#line 3857 "test-new/nrimp10s-77.imp"
PPJ(36, 9);
// 3858 %FINISH
#line 3858 "test-new/nrimp10s-77.imp"
L_035A:;
// 3859 P=P1
#line 3859 "test-new/nrimp10s-77.imp"
P = P1;
// 3860 END:
#line 3860 "test-new/nrimp10s-77.imp"
U_102A:;
// 3861 P=P+1
#line 3861 "test-new/nrimp10s-77.imp"
P = P + 1;
// 3862 %END
#line 3862 "test-new/nrimp10s-77.imp"
return;
#line 3862 "test-new/nrimp10s-77.imp"
} /* end of CRES */
// 3863 %ROUTINE SAVE AUX STACK
#line 3863 "test-new/nrimp10s-77.imp"
void SAVEAUXSTACK(void) {
// 3864 !***********************************************************************
// 3865 !* COPY AUX STACK DESCRPTR & POINTER INTO CURRENT STACK FRAME *
// 3866 !* FIVE WORDS ARE USED FOR THIS PURPOSE:- *
// 3867 !* 1&2 HOLD AUX STACK DESCRIPTOR *
// 3868 !* 3 HOLDS VALUE AT BLK ENTRY FOR USE AT EXIT *
// 3869 !* 4 HOLDS STACKTOP VALUE AFTER ALL ARRAY DECLNS(FOR %ONS) *
// 3870 !* 5 HOLD STACKLIMIT FOR CHECKING AT ARRAY DECLARATIONS *
// 3871 !* THE LATTER IS OMITTED INPARM=OPT *
// 3872 !***********************************************************************
// 3873 %INTEGER XYNB, DR0, DR1
#line 3873 "test-new/nrimp10s-77.imp"
int XYNB;
#line 3873 "test-new/nrimp10s-77.imp"
int DR0;
#line 3873 "test-new/nrimp10s-77.imp"
int DR1;
// 3874 %IF AUXST=0 %THEN %START; ! FIRST REF PUT REF IN PLT
#line 3874 "test-new/nrimp10s-77.imp"
if (AUXST != 0) goto L_035B;
// 3875 DR0=16_30000001; DR1=0
#line 3875 "test-new/nrimp10s-77.imp"
DR0 = 805306369;
#line 3875 "test-new/nrimp10s-77.imp"
DR1 = 0;
// 3876 PGLA(8,8,ADDR(DR0))
#line 3876 "test-new/nrimp10s-77.imp"
PGLA(8, 8, _imp_ADDR(/*?*/ &DR0));
// 3877 AUXST=GLACA-8
#line 3877 "test-new/nrimp10s-77.imp"
AUXST = GLACA - 8;
// 3878 GXREF(AUXSTEP,2,16_02000008,AUXST+4)
#line 3878 "test-new/nrimp10s-77.imp"
GXREF(
#line 3878 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string11) tmp = AUXSTEP /*q*/;
(_imp_string31 *)&tmp;
})
#line 3878 "test-new/nrimp10s-77.imp"
,
2, 33554440, AUXST + 4);
// 3879 %FINISH
#line 3879 "test-new/nrimp10s-77.imp"
L_035B:;
// 3880 %IF AUXSBASE(LEVEL)=0 %START
#line 3880 "test-new/nrimp10s-77.imp"
if (AUXSBASE[LEVEL] != 0) goto L_035C;
// 3881 XYNB=SET XORYNB(-1,-1)
#line 3881 "test-new/nrimp10s-77.imp"
XYNB = SETXORYNB(-1, -1);
// 3882 PF1(LD,2,XYNB,AUXST)
#line 3882 "test-new/nrimp10s-77.imp"
PF1(120, 2, XYNB, AUXST);
// 3883 %IF PARMOPT#0 %THEN %START
#line 3883 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_035D;
// 3884 PF1(LSS,1,0,2); ! PICK UP STACKTOP
#line 3884 "test-new/nrimp10s-77.imp"
PF1(98, 1, 0, 2);
// 3885 PSF1(ST,1,N+16)
#line 3885 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N + 16);
// 3886 %FINISH
#line 3886 "test-new/nrimp10s-77.imp"
L_035D:;
// 3887 PF1(LSS,2,7,0)
#line 3887 "test-new/nrimp10s-77.imp"
PF1(98, 2, 7, 0);
// 3888 PSF1(STD,1,N)
#line 3888 "test-new/nrimp10s-77.imp"
PSF1(88, 1, N);
// 3889 PSF1(ST,1,N+8)
#line 3889 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N + 8);
// 3890 AUXSBASE(LEVEL)=N; N=N+16
#line 3890 "test-new/nrimp10s-77.imp"
AUXSBASE[LEVEL] = N;
#line 3890 "test-new/nrimp10s-77.imp"
N = N + 16;
// 3891 %IF PARMOPT#0 %THEN N=N+4
#line 3891 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_035E;
#line 3891 "test-new/nrimp10s-77.imp"
N = N + 4;
#line 3891 "test-new/nrimp10s-77.imp"
L_035E:;
// 3892 GRUSE(DR)=0; GRUSE(ACCR)=11; GRINF1(ACCR)=0
#line 3892 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
#line 3892 "test-new/nrimp10s-77.imp"
GRUSE[0] = 11;
#line 3892 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 3893 %FINISH
#line 3893 "test-new/nrimp10s-77.imp"
L_035C:;
// 3894 %END
#line 3894 "test-new/nrimp10s-77.imp"
return;
#line 3894 "test-new/nrimp10s-77.imp"
} /* end of SAVEAUXSTACK */
// 3895 %ROUTINE RESET AUX STACK
#line 3895 "test-new/nrimp10s-77.imp"
void RESETAUXSTACK(void) {
// 3896 !***********************************************************************
// 3897 !* IF ANY ARRAYS HAVE BEEN PUT ON THE AUXSTACK THEN UNDECLARE *
// 3898 !***********************************************************************
// 3899 %IF AUXSBASE(LEVEL)#0 %START
#line 3899 "test-new/nrimp10s-77.imp"
if (AUXSBASE[LEVEL] == 0) goto L_035F;
// 3900 PSF1(LB,1,AUXSBASE(LEVEL)+8)
#line 3900 "test-new/nrimp10s-77.imp"
PSF1(122, 1, AUXSBASE[LEVEL] + 8);
// 3901 PSF1(STB,2,AUXSBASE(LEVEL))
#line 3901 "test-new/nrimp10s-77.imp"
PSF1(90, 2, AUXSBASE[LEVEL]);
// 3902 GRUSE(BREG)=0
#line 3902 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 3903 %FINISH
#line 3903 "test-new/nrimp10s-77.imp"
L_035F:;
// 3904 %END
#line 3904 "test-new/nrimp10s-77.imp"
return;
#line 3904 "test-new/nrimp10s-77.imp"
} /* end of RESETAUXSTACK */
// 3905 %ROUTINE RT EXIT
#line 3905 "test-new/nrimp10s-77.imp"
void RTEXIT(void) {
// 3906 !***********************************************************************
// 3907 !* THIS ROUTINE COMPILES CODE FOR ROUTINE EXIT(IE '%RETURN') *
// 3908 !***********************************************************************
// 3909 RESET AUX STACK
#line 3909 "test-new/nrimp10s-77.imp"
RESETAUXSTACK();
// 3910 PSF1(EXIT,0,-16_40)
#line 3910 "test-new/nrimp10s-77.imp"
PSF1(56, 0, -64);
// 3911 %END
#line 3911 "test-new/nrimp10s-77.imp"
return;
#line 3911 "test-new/nrimp10s-77.imp"
} /* end of RTEXIT */
// 3912 %ROUTINE CLAIM ST FRAME(%INTEGER AT,VALUE)
#line 3912 "test-new/nrimp10s-77.imp"
void CLAIMSTFRAME(int AT, int VALUE) {
// 3913 !***********************************************************************
// 3914 !* FILL ASF INSTN IN RT ENTRY SEQUENCE TO CLAIM THE STACKFRAME *
// 3915 !***********************************************************************
// 3916 %INTEGER INSTR, WK
#line 3916 "test-new/nrimp10s-77.imp"
int INSTR;
#line 3916 "test-new/nrimp10s-77.imp"
int WK;
// 3917 WK=AT>>18; ! BYTES CLAIMED BY ENTRY SEQ
#line 3917 "test-new/nrimp10s-77.imp"
WK = (unsigned int)AT >> 18;
// 3918 AT=AT&16_3FFFF; ! ADRR OF ASF INSTRN
#line 3918 "test-new/nrimp10s-77.imp"
AT = AT & 262143;
// 3919 INSTR=(ASF+12*PARMCHK)<<24!3<<23!(VALUE-WK+3)>>2
#line 3919 "test-new/nrimp10s-77.imp"
INSTR = 110 + 12 * PARMCHK << 24 | 3 << 23 | (unsigned int)VALUE - WK + 3 >> 2;
// 3920 PLUG(1,AT,INSTR,4)
#line 3920 "test-new/nrimp10s-77.imp"
PLUG(1, AT, INSTR, 4);
// 3921 %END
#line 3921 "test-new/nrimp10s-77.imp"
return;
#line 3921 "test-new/nrimp10s-77.imp"
} /* end of CLAIMSTFRAME */
// 3922 %ROUTINE CEND (%INTEGER KKK)
#line 3922 "test-new/nrimp10s-77.imp"
void CEND(int KKK) {
// 3923 !***********************************************************************
// 3924 !* DEAL WITH ALL OCCURENCES OF '%END' *
// 3925 !* KKK=PTYPE(>=16_1000) FOR ROUTINES,FNS AND MAPS *
// 3926 !* KKK=0 FOR ENDS OF '%BEGIN' BLOCKS *
// 3927 !* KKK=1 FOR '%ENDOFPROGRAM' *
// 3928 !* %ENDOFPROGRAM IS REALLY TWO ENDS. THE FIRST IS THE USERS *
// 3929 !* AND THE SECOND IS PERMS. KKK=2 FOR A RECURSIVE CALL OF CEND *
// 3930 !* ON END OF PROGRAM TO DEAL WITH THE %END CORRESPONDING TO *
// 3931 !* THE %BEGIN COMPILED IN THE INITIALISATION SEQUENCE *
// 3932 !***********************************************************************
// 3933 %INTEGER KP,JJ,BIT
#line 3933 "test-new/nrimp10s-77.imp"
int KP;
#line 3933 "test-new/nrimp10s-77.imp"
int JJ;
#line 3933 "test-new/nrimp10s-77.imp"
int BIT;
#line 3933 "test-new/nrimp10s-77.imp"
auto void DTABLE(int LEVEL);
// 3934 %ROUTINESPEC DTABLE(%INTEGER LEVEL)
// 3935 SET LINE %UNLESS KKK=2
#line 3935 "test-new/nrimp10s-77.imp"
if (KKK == 2) goto L_0360;
#line 3935 "test-new/nrimp10s-77.imp"
SETLINE();
#line 3935 "test-new/nrimp10s-77.imp"
L_0360:;
// 3936 FORGET(-1)
#line 3936 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 3937 BIT=1<<LEVEL
#line 3937 "test-new/nrimp10s-77.imp"
BIT = 1 << LEVEL;
// 3938 !
// 3939 ! NOW PLANT AN ERROR EXIT FOR FNS AND MAPS - CONTROL SHOULD BE RETURNED
// 3940 ! VIA %RESULT= AN SHOULD NEVVER REACH THE %END INSTRUCTION
// 3941 !
// 3942 %IF KKK&16_3FFF>16_1000 %AND COMPILER=0 %AND LAST INST=0 %THEN PPJ(15,10); ! RUN FAULT 11
#line 3942 "test-new/nrimp10s-77.imp"
if (KKK & 16383 <= 4096) goto L_0361;
#line 3942 "test-new/nrimp10s-77.imp"
if (COMPILER != 0) goto L_0361;
#line 3942 "test-new/nrimp10s-77.imp"
if (LASTINST != 0) goto L_0361;
#line 3942 "test-new/nrimp10s-77.imp"
PPJ(15, 10);
#line 3942 "test-new/nrimp10s-77.imp"
L_0361:;
// 3943 NMAX=N %IF N>NMAX; ! WORK SPACE POINTER
#line 3943 "test-new/nrimp10s-77.imp"
if (N <= NMAX) goto L_0362;
#line 3943 "test-new/nrimp10s-77.imp"
NMAX = N;
#line 3943 "test-new/nrimp10s-77.imp"
L_0362:;
// 3944 !
// 3945 ! CLEAR OUT THE LABEL LIST FAULTING LABELS WITH JUMPS OUTSTANDING
// 3946 ! AS NOT SET AND COMMENTING ON LABELS NOT USED
// 3947 !
// 3948 %WHILE LABEL(LEVEL)#0 %CYCLE
#line 3948 "test-new/nrimp10s-77.imp"
L_0363:;
#line 3948 "test-new/nrimp10s-77.imp"
if (LABEL[LEVEL] == 0) goto L_0364;
// 3949 POP(LABEL(LEVEL),I,J,KP)
#line 3949 "test-new/nrimp10s-77.imp"
POP(/*?*/ &LABEL[LEVEL], /*?*/ &I, /*?*/ &J, /*?*/ &KP);
// 3950 I=I>>24
#line 3950 "test-new/nrimp10s-77.imp"
I = (unsigned int)I >> 24;
// 3951 %IF J&16_FFFF#0 %THEN %START
#line 3951 "test-new/nrimp10s-77.imp"
if (J & 65535 == 0) goto L_0365;
// 3952 J=J&16_FFFF
#line 3952 "test-new/nrimp10s-77.imp"
J = J & 65535;
// 3953 %IF 0<KP<=MAX ULAB %THEN FAULT2(11,FROM3(J),KP)
#line 3953 "test-new/nrimp10s-77.imp"
{
// Double-sided test on KP (Part I)
#line 3953 "test-new/nrimp10s-77.imp"
int tmp;
#line 3953 "test-new/nrimp10s-77.imp"
if (0 >= (tmp = KP)) goto L_0366;
// Double-sided test on KP (Part II)
#line 3953 "test-new/nrimp10s-77.imp"
if (tmp > MAXULAB) goto L_0366;
#line 3953 "test-new/nrimp10s-77.imp"
}
#line 3953 "test-new/nrimp10s-77.imp"
FAULT2(11, FROM3(J), KP);
#line 3953 "test-new/nrimp10s-77.imp"
L_0366:;
// 3954 CLEAR LIST(J)
#line 3954 "test-new/nrimp10s-77.imp"
CLEARLIST(/*?*/ &J);
// 3955 %FINISH %ELSE %START
#line 3955 "test-new/nrimp10s-77.imp"
goto L_0367;
#line 3955 "test-new/nrimp10s-77.imp"
L_0365:;
// 3956 %IF I=0 %AND KP<MAX ULAB %THEN WARN(3,KP)
#line 3956 "test-new/nrimp10s-77.imp"
if (I != 0) goto L_0368;
#line 3956 "test-new/nrimp10s-77.imp"
if (KP >= MAXULAB) goto L_0368;
#line 3956 "test-new/nrimp10s-77.imp"
WARN(3, KP);
#line 3956 "test-new/nrimp10s-77.imp"
L_0368:;
// 3957 %FINISH
#line 3957 "test-new/nrimp10s-77.imp"
L_0367:;
// 3958 %REPEAT
#line 3958 "test-new/nrimp10s-77.imp"
goto L_0363;
#line 3958 "test-new/nrimp10s-77.imp"
L_0364:;
// 3959 !
// 3960 %CYCLE JJ=0,1,4
#line 3960 "test-new/nrimp10s-77.imp"
// %for JJ = 0, 1, 4 %cycle
#line 3960 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 4;
#line 3960 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle JJ = 0, 1, 4");
_control = JJ = _initial - _increment;
#line 3960 "test-new/nrimp10s-77.imp"
L_0369:
#line 3960 "test-new/nrimp10s-77.imp"
if (JJ != _control) _imp_signal(4, 2, 0, "Corrupt control variable JJ");
#line 3960 "test-new/nrimp10s-77.imp"
if (JJ == _final) goto L_036A;
#line 3960 "test-new/nrimp10s-77.imp"
_control += _increment;
JJ += _increment;
// 3961 CLEAR LIST(AVL WSP(JJ,LEVEL));! RELEASE TEMPORARY LOCATIONS
#line 3961 "test-new/nrimp10s-77.imp"
CLEARLIST(/*?*/ &AVLWSP[JJ][LEVEL]);
// 3962 %REPEAT
#line 3962 "test-new/nrimp10s-77.imp"
goto L_0369;
#line 3962 "test-new/nrimp10s-77.imp"
}
#line 3962 "test-new/nrimp10s-77.imp"
L_036A:;
// 3963 !
// 3964 DTABLE(LEVEL); ! OUTPUT DIAGNOSTIC TABLES
#line 3964 "test-new/nrimp10s-77.imp"
DTABLE(LEVEL);
// 3965 !
// 3966 ! CLEAR DECLARATIONS - POP UP ANY GLOBAL NAMES THAT WERE REDECLARED
// 3967 ! DESTROY SIDE CHAINS FOR ROUTINES,FORMATS AND SWITCHES
// 3968 !
// 3969 !
// 3970 ! NOW CLAIM THE STACK FRAME BY FILING THE ASF IN THE BLOCK ENTRY CODING
// 3971 !
// 3972 NMAX=(NMAX+7)&(-8)
#line 3972 "test-new/nrimp10s-77.imp"
NMAX = NMAX + 7 & -8;
// 3973 %IF KKK=2 %THEN %RETURN
#line 3973 "test-new/nrimp10s-77.imp"
if (KKK != 2) goto L_036C;
#line 3973 "test-new/nrimp10s-77.imp"
return;
#line 3973 "test-new/nrimp10s-77.imp"
L_036C:;
// 3974 %IF KKK>=16_1000 %OR KKK=1 %THEN CLAIM ST FRAME(SET(RLEVEL),NMAX)
#line 3974 "test-new/nrimp10s-77.imp"
if (KKK >= 4096) goto L_036B;
#line 3974 "test-new/nrimp10s-77.imp"
if (KKK != 1) goto L_036D;
#line 3974 "test-new/nrimp10s-77.imp"
L_036B:;
#line 3974 "test-new/nrimp10s-77.imp"
CLAIMSTFRAME(SET[RLEVEL], NMAX);
#line 3974 "test-new/nrimp10s-77.imp"
L_036D:;
// 3975 !
// 3976 ! NOW PLANT THE BLOCK EXIT SEQUENCE
// 3977 !
// 3978 %IF KKK&16_3FFF=16_1000 %AND LAST INST=0 %THEN RT EXIT
#line 3978 "test-new/nrimp10s-77.imp"
if (KKK & 16383 != 4096) goto L_036E;
#line 3978 "test-new/nrimp10s-77.imp"
if (LASTINST != 0) goto L_036E;
#line 3978 "test-new/nrimp10s-77.imp"
RTEXIT();
#line 3978 "test-new/nrimp10s-77.imp"
L_036E:;
// 3979 PPJ(15,21) %IF KKK=1 %AND LAST INST=0;! %STOP AT %ENDOFPROGRAM
#line 3979 "test-new/nrimp10s-77.imp"
if (KKK != 1) goto L_036F;
#line 3979 "test-new/nrimp10s-77.imp"
if (LASTINST != 0) goto L_036F;
#line 3979 "test-new/nrimp10s-77.imp"
PPJ(15, 21);
#line 3979 "test-new/nrimp10s-77.imp"
L_036F:;
// 3980 %IF KKK=0 %THEN %START; ! BEGIN BLOCK EXIT
#line 3980 "test-new/nrimp10s-77.imp"
if (KKK != 0) goto L_0370;
// 3981 %IF PARMTRACE=1 %THEN %START; ! RESTORE DIAGS POINTERS
#line 3981 "test-new/nrimp10s-77.imp"
if (PARMTRACE != 1) goto L_0371;
// 3982 PSF1(LD,1,12)
#line 3982 "test-new/nrimp10s-77.imp"
PSF1(120, 1, 12);
// 3983 DIAG POINTER(LEVEL-1)
#line 3983 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL - 1);
// 3984 PSF1(STD,1,12)
#line 3984 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
// 3985 %FINISH
#line 3985 "test-new/nrimp10s-77.imp"
L_0371:;
// 3986 %IF STACK#0 %START
#line 3986 "test-new/nrimp10s-77.imp"
if (STACK == 0) goto L_0372;
// 3987 JJ=NMDECS(LEVEL)>>14
#line 3987 "test-new/nrimp10s-77.imp"
JJ = (unsigned int)NMDECS[LEVEL] >> 14;
// 3988 %IF JJ#0 %THEN %START; ! ARRAYS TO BE UNDECLARED
#line 3988 "test-new/nrimp10s-77.imp"
if (JJ == 0) goto L_0373;
// 3989 PF1(STSF,0,TOS,0)
#line 3989 "test-new/nrimp10s-77.imp"
PF1(94, 0, 6, 0);
// 3990 PF1(LSS,0,TOS,0)
#line 3990 "test-new/nrimp10s-77.imp"
PF1(98, 0, 6, 0);
// 3991 PSF1(ISB,1,JJ)
#line 3991 "test-new/nrimp10s-77.imp"
PSF1(226, 1, JJ);
// 3992 PSF1(USH,0,-2)
#line 3992 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -2);
// 3993 PF1(ST,0,TOS,0)
#line 3993 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 3994 PF1(ASF,0,TOS,0)
#line 3994 "test-new/nrimp10s-77.imp"
PF1(110, 0, 6, 0);
// 3995 GRUSE(ACCR)=0
#line 3995 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 3996 %FINISH
#line 3996 "test-new/nrimp10s-77.imp"
L_0373:;
// 3997 %FINISH %ELSE RESET AUX STACK
#line 3997 "test-new/nrimp10s-77.imp"
goto L_0374;
#line 3997 "test-new/nrimp10s-77.imp"
L_0372:;
#line 3997 "test-new/nrimp10s-77.imp"
RESETAUXSTACK();
#line 3997 "test-new/nrimp10s-77.imp"
L_0374:;
// 3998 %FINISH
#line 3998 "test-new/nrimp10s-77.imp"
L_0370:;
// 3999 !
// 4000 ! RETURN TO PREVIOUS LEVEL PROVIDED THERE IS A VALID ONE !
// 4001 !
// 4002 %UNLESS LEVEL>2 %OR (LEVEL=2 %AND CPRMODE=2) %THEN %START
#line 4002 "test-new/nrimp10s-77.imp"
if (LEVEL > 2) goto L_0375;
#line 4002 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_0376;
#line 4002 "test-new/nrimp10s-77.imp"
if (CPRMODE == 2) goto L_0375;
#line 4002 "test-new/nrimp10s-77.imp"
L_0376:;
// 4003 %IF KKK=1 %AND LEVEL=2 %THEN KKK=2 %ELSE FAULT(14,0) %AND %STOP
#line 4003 "test-new/nrimp10s-77.imp"
if (KKK != 1) goto L_0377;
#line 4003 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_0377;
#line 4003 "test-new/nrimp10s-77.imp"
KKK = 2;
#line 4003 "test-new/nrimp10s-77.imp"
goto L_0378;
#line 4003 "test-new/nrimp10s-77.imp"
L_0377:;
#line 4003 "test-new/nrimp10s-77.imp"
FAULT(14, 0);
#line 4003 "test-new/nrimp10s-77.imp"
_imp_stop(0);
#line 4003 "test-new/nrimp10s-77.imp"
L_0378:;
// 4004 %FINISH
#line 4004 "test-new/nrimp10s-77.imp"
L_0375:;
// 4005 LEVEL=LEVEL-1
#line 4005 "test-new/nrimp10s-77.imp"
LEVEL = LEVEL - 1;
// 4006 %IF KKK>=16_1000 %THEN %START
#line 4006 "test-new/nrimp10s-77.imp"
if (KKK < 4096) goto L_0379;
// 4007 RLEVEL=RLEVEL-1
#line 4007 "test-new/nrimp10s-77.imp"
RLEVEL = RLEVEL - 1;
// 4008 RBASE=RLEVEL
#line 4008 "test-new/nrimp10s-77.imp"
RBASE = RLEVEL;
// 4009 %FINISH
#line 4009 "test-new/nrimp10s-77.imp"
L_0379:;
// 4010 !
// 4011 ! RESTORE INFORMATION ABOUT THE (NEW) CURRENT LEVEL
// 4012 !
// 4013 POP(LEVELINF,KP,N,KP)
#line 4013 "test-new/nrimp10s-77.imp"
POP(/*?*/ &LEVELINF, /*?*/ &KP, /*?*/ &N, /*?*/ &KP);
// 4014 NMAX=N>>16 %IF KKK>=16_1000
#line 4014 "test-new/nrimp10s-77.imp"
if (KKK < 4096) goto L_037A;
#line 4014 "test-new/nrimp10s-77.imp"
NMAX = (unsigned int)N >> 16;
#line 4014 "test-new/nrimp10s-77.imp"
L_037A:;
// 4015 N=N&16_7FFF
#line 4015 "test-new/nrimp10s-77.imp"
N = N & 32767;
// 4016 %IF KKK=2 %THEN CEND(KKK); ! ROUND AGAIN FOR 'ENDOFPROGRAM'
#line 4016 "test-new/nrimp10s-77.imp"
if (KKK != 2) goto L_037B;
#line 4016 "test-new/nrimp10s-77.imp"
CEND(KKK);
#line 4016 "test-new/nrimp10s-77.imp"
L_037B:;
// 4017 !
// 4018 ! COMPLETE THE JUMP AROUND ALL NON-EXTERNAL ROUTINES EXCEPT WHEN
// 4019 ! %TRUSTEDPROGRAM IS IN OPERATION.
// 4020 !
// 4021 %IF ASL WARN#0 %THEN ASL WARN=0 %AND EPILOGUE
#line 4021 "test-new/nrimp10s-77.imp"
if (ASLWARN == 0) goto L_037C;
#line 4021 "test-new/nrimp10s-77.imp"
ASLWARN = 0;
#line 4021 "test-new/nrimp10s-77.imp"
EPILOGUE();
#line 4021 "test-new/nrimp10s-77.imp"
L_037C:;
// 4022 %IF KKK>=16_1000 %AND COMPILER=0 %AND(RLEVEL>0 %OR CPRMODE#2) %THEN %START
#line 4022 "test-new/nrimp10s-77.imp"
if (KKK < 4096) goto L_037D;
#line 4022 "test-new/nrimp10s-77.imp"
if (COMPILER != 0) goto L_037D;
#line 4022 "test-new/nrimp10s-77.imp"
if (RLEVEL > 0) goto L_037E;
#line 4022 "test-new/nrimp10s-77.imp"
if (CPRMODE == 2) goto L_037D;
#line 4022 "test-new/nrimp10s-77.imp"
L_037E:;
// 4023 JJ=NEXTP+6
#line 4023 "test-new/nrimp10s-77.imp"
JJ = NEXTP + 6;
// 4024 %UNLESS A(NEXTP+5)=11 %AND A(JJ+FROMAR2(JJ))=2 %START
#line 4024 "test-new/nrimp10s-77.imp"
if (A[NEXTP + 5] != 11) goto L_037F;
#line 4024 "test-new/nrimp10s-77.imp"
if (A[JJ + FROMAR2(JJ)] == 2) goto L_0380;
#line 4024 "test-new/nrimp10s-77.imp"
L_037F:;
// 4025 JJ=ENTER LAB(JROUND(LEVEL+1),0)
#line 4025 "test-new/nrimp10s-77.imp"
JJ = ENTERLAB(JROUND[LEVEL + 1], 0);
// 4026 JROUND(LEVEL+1)=0
#line 4026 "test-new/nrimp10s-77.imp"
JROUND[LEVEL + 1] = 0;
// 4027 %FINISH
#line 4027 "test-new/nrimp10s-77.imp"
L_0380:;
// 4028 %FINISH
#line 4028 "test-new/nrimp10s-77.imp"
L_037D:;
// 4029 %RETURN
#line 4029 "test-new/nrimp10s-77.imp"
return;
// 4030 !
// 4031 ! LAYOUT OF DIAGNOSIC TABLES
// 4032 ! ****** ** ********* ******
// 4033 !
// 4034 ! THE BOUND FIELD OF PLT DESCRIPTOR STORED AT (LNB+3 & LNB+4) IF
// 4035 ! USED TO CONTAIN A DISPLACEMENT RELATIVE TO THE START OF SST OF THE
// 4036 ! DIAGNOSTIC TABLES FOR THE BLOCK OR ROUTINE BEING EXECUTED.
// 4037 ! A ZERO BOUND MEANS NO DIAGNOSTIC REQUESTED.(NB THIS MAY MEAN A DUMMY
// 4038 ! FIRST WORD IN THE SST).
// 4039 ! THE ABSOLUTE ADDRESS OF THE SST FOR THE CURRENT CODE SEGMENT WILL
// 4040 ! ALWAYS BE FOUND IN THE STANDARD 10 WORDS OF THE GLA/PLT
// 4041 !
// 4042 ! FORM OF THE TABLES:-
// 4043 !
// 4044 ! WORD 0 = LINE OF RT IN SOURCE PROG <<16 ! LINE NO POSN(FROM LNB)
// 4045 ! WORD 1 = (12 LANG DEPENDENT BITS)<<18 ! ENVIRONMENT
// 4046 ! ( TOP 2 BITS OF LANG DEPENDENT HAS LITL FROM PTYPE)
// 4047 ! ( BOTTOM 4 BITS HAVE TEXTUAL LEVEL)
// 4048 ! WORD 2 = DISPLAY POSN (FROM LNB)<<16 ! RT TYPE INFO
// 4049 ! WORD 3 = ZERO FOR BLKS OR STRING(<=11BYTES) BEING THE
// 4050 ! RT NAME. THIS WILL TAKE WORDS 4 AND 5 IF NEEDED
// 4051 ! WORD 6 = LANGUAGE DEPENDENT INFO . IMP ON CONDITIONS ETC
// 4052 !
// 4053 ! THE REST IS MADE UP OF VARIABLE ENTRIES AND THE SECTION IS TERMINATED BY
// 4054 ! A WORD OF 16_FFFFFFFF
// 4055 !
// 4056 ! EACH VARIABLE ENTRY CONSISTS OF THE VARIABLE WORD FOLLOWED BY
// 4057 ! THE VARIABLE NAME AS A STRING. THE WORD CONSISTS OF
// 4058 ! BITS 2**31 TO 2**20 TYPE INFORMATION (MAY BE LANGUAGE DEPENDENT
// 4059 ! BIT 2**19 =0 UNDER LNB =1 IN GLA
// 4060 ! BITS 2**18 TO 2**0 DISPLACEMENT FROM LNB(GLA) IN BYTES
// 4061 !
// 4062 !
// 4063 ! THE ENVIRONMENT IS A POINTER (RELATIVE TO SST) OF THE NEXT OUTERMOST
// 4064 ! BLOCK OR A POINTER TO GLOBAL OWNS, EXTERNAL OR COMMON AREAS
// 4065 ! A ZERO MEANS NO ENCLOSING BLOCK. WORD1=WORD3=0 IS AN
// 4066 ! IMP MAIN PROGRAM AND WILL TERMINATE THE DIAGNOSTICS.
// 4067 !
// 4068 %ROUTINE DTABLE(%INTEGER LEVEL)
#line 4068 "test-new/nrimp10s-77.imp"
void DTABLE(int LEVEL) {
// 4069 !***********************************************************************
// 4070 !* THIS ROUTINE LOOKS AT THE DECLARATIONS FOR THE CURRENT LEVEL & *
// 4071 !* SETS UP THE SEGMENT OF SHARABLE SYMBOL TABLES TO DESCRIBE THEM.*
// 4072 !* FOR MAIN PROGRAMS OR EXTERNAL ROUTINES THE 'GLOBAL' VARIABLES *
// 4073 !* (IF ANY) ARE ALSO INCLUDED. *
// 4074 !***********************************************************************
// 4075 %STRING(31) RT NAME
#line 4075 "test-new/nrimp10s-77.imp"
_imp_string31 RTNAME;
// 4076 %STRING(11) LOCAL NAME
#line 4076 "test-new/nrimp10s-77.imp"
_imp_string11 LOCALNAME;
// 4077 %RECORD(LISTF)%NAME LCELL{(LISTF)
#line 4077 "test-new/nrimp10s-77.imp"
struct LISTF *LCELL;
// 4078 %CONSTINTEGER LARRROUT=16_F300
// 4079 %INTEGER DPTR,LNUM,ML,KK,JJ,Q,DEND,BIT,S1,S2,S3,S4,LANGD,II
#line 4079 "test-new/nrimp10s-77.imp"
int DPTR;
#line 4079 "test-new/nrimp10s-77.imp"
int LNUM;
#line 4079 "test-new/nrimp10s-77.imp"
int ML;
#line 4079 "test-new/nrimp10s-77.imp"
int KK;
#line 4079 "test-new/nrimp10s-77.imp"
int JJ;
#line 4079 "test-new/nrimp10s-77.imp"
int Q;
#line 4079 "test-new/nrimp10s-77.imp"
int DEND;
#line 4079 "test-new/nrimp10s-77.imp"
int BIT;
#line 4079 "test-new/nrimp10s-77.imp"
int S1;
#line 4079 "test-new/nrimp10s-77.imp"
int S2;
#line 4079 "test-new/nrimp10s-77.imp"
int S3;
#line 4079 "test-new/nrimp10s-77.imp"
int S4;
#line 4079 "test-new/nrimp10s-77.imp"
int LANGD;
#line 4079 "test-new/nrimp10s-77.imp"
int II;
// 4080 %INTEGERARRAY DD(0:500); ! BUFFER FOR SEGMENT OF SST
#line 4080 "test-new/nrimp10s-77.imp"
int DD[501];
// 4081 !
// 4082 ! FILL ALL OUTSTANDING REFERENCES TO THIS DIAGS BLOCK
// 4083 !
// 4084 BIT=1<<LEVEL
#line 4084 "test-new/nrimp10s-77.imp"
BIT = 1 << LEVEL;
// 4085 LANGD=KKK>>14<<30!LEVEL<<18; ! GET LITL FROM PTYPE
#line 4085 "test-new/nrimp10s-77.imp"
LANGD = (unsigned int)KKK >> 14 << 30 | LEVEL << 18;
// 4086 %WHILE RAL(LEVEL)#0 %CYCLE
#line 4086 "test-new/nrimp10s-77.imp"
L_0381:;
#line 4086 "test-new/nrimp10s-77.imp"
if (RAL[LEVEL] == 0) goto L_0382;
// 4087 POP(RAL(LEVEL),Q,JJ,KK)
#line 4087 "test-new/nrimp10s-77.imp"
POP(/*?*/ &RAL[LEVEL], /*?*/ &Q, /*?*/ &JJ, /*?*/ &KK);
// 4088 PLUG(Q,JJ,KK!SSTL,4)
#line 4088 "test-new/nrimp10s-77.imp"
PLUG(Q, JJ, KK | SSTL, 4);
// 4089 %REPEAT
#line 4089 "test-new/nrimp10s-77.imp"
goto L_0381;
#line 4089 "test-new/nrimp10s-77.imp"
L_0382:;
// 4090 PUSH(RAL(LEVEL-1),4,SSTL+4,LANGD) %IF PARMTRACE#0
#line 4090 "test-new/nrimp10s-77.imp"
if (PARMTRACE == 0) goto L_0383;
#line 4090 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &RAL[LEVEL - 1], 4, SSTL + 4, LANGD);
#line 4090 "test-new/nrimp10s-77.imp"
L_0383:;
// 4091 DD(0)=L(LEVEL)<<16!(DIAGINF(LEVEL))
#line 4091 "test-new/nrimp10s-77.imp"
DD[0] = L[LEVEL] << 16 | DIAGINF[LEVEL];
// 4092 DD(1)=LANGD
#line 4092 "test-new/nrimp10s-77.imp"
DD[1] = LANGD;
// 4093 DD(2)=DISPLAY(RLEVEL)<<16!FLAG(LEVEL)&16_3FFF
#line 4093 "test-new/nrimp10s-77.imp"
DD[2] = DISPLAY[RLEVEL] << 16 | FLAG[LEVEL] & 16383;
// 4094 ML=M(LEVEL); ! ROUTINE NAME(=0 FOR %BEGIN)
#line 4094 "test-new/nrimp10s-77.imp"
ML = M[LEVEL];
// 4095 LNUM=BYTEINTEGER(DICTBASE+ML); ! LENGTH OF THE NAME
#line 4095 "test-new/nrimp10s-77.imp"
LNUM = *_imp_BYTEINTEGER(DICTBASE + ML);
// 4096 DPTR=4; DEND=0
#line 4096 "test-new/nrimp10s-77.imp"
DPTR = 4;
#line 4096 "test-new/nrimp10s-77.imp"
DEND = 0;
// 4097 %IF LNUM=0 %THEN DD(3)=0 %ELSE %START
#line 4097 "test-new/nrimp10s-77.imp"
if (LNUM != 0) goto L_0384;
#line 4097 "test-new/nrimp10s-77.imp"
DD[3] = 0;
#line 4097 "test-new/nrimp10s-77.imp"
goto L_0385;
#line 4097 "test-new/nrimp10s-77.imp"
L_0384:;
// 4098 Q=DICTBASE+ML
#line 4098 "test-new/nrimp10s-77.imp"
Q = DICTBASE + ML;
// 4099 RT NAME<-STRING(Q); ! FOR RTS MOVE IN 1ST 32 CHARS
#line 4099 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &RTNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *_imp_STRING(Q);
(void *)&tmp;
}),
/*max:*/ 31);
#line 4099 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 31 chars */
#line 4099 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &RTNAME) > 31) *_imp_LENGTH((_imp_string *)/*?*/ &RTNAME) = 31;
// 4100 LNUM=BYTE INTEGER(ADDR(RT NAME))
#line 4100 "test-new/nrimp10s-77.imp"
LNUM = *_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &RTNAME));
// 4101 STRING(ADDR(DD(3)))=RTNAME; ! AND UPDATE POINTER PAST
#line 4101 "test-new/nrimp10s-77.imp"
*_imp_STRING(_imp_ADDR(/*?*/ &DD[3])) = RTNAME;
// 4102 DPTR=DPTR+LNUM>>2; ! ACTUAL NO OF CHARS
#line 4102 "test-new/nrimp10s-77.imp"
DPTR = DPTR + ((unsigned int)LNUM >> 2);
// 4103 %FINISH
#line 4103 "test-new/nrimp10s-77.imp"
L_0385:;
// 4104 DD(DPTR)=ONWORD(LEVEL); ! ON CONDITION WORD
#line 4104 "test-new/nrimp10s-77.imp"
DD[DPTR] = ONWORD[LEVEL];
// 4105 DPTR=DPTR+1
#line 4105 "test-new/nrimp10s-77.imp"
DPTR = DPTR + 1;
// 4106 JJ=NAMES(LEVEL)
#line 4106 "test-new/nrimp10s-77.imp"
JJ = NAMES[LEVEL];
// 4107 %WHILE 0<=JJ<16_3FFF %CYCLE
#line 4107 "test-new/nrimp10s-77.imp"
L_0386:;
#line 4107 "test-new/nrimp10s-77.imp"
{
// Double-sided test on JJ (Part I)
#line 4107 "test-new/nrimp10s-77.imp"
int tmp;
#line 4107 "test-new/nrimp10s-77.imp"
if (0 > (tmp = JJ)) goto L_0387;
// Double-sided test on JJ (Part II)
#line 4107 "test-new/nrimp10s-77.imp"
if (tmp >= 16383) goto L_0387;
#line 4107 "test-new/nrimp10s-77.imp"
}
// 4108 LCELL==ASLIST(TAGS(JJ))
#line 4108 "test-new/nrimp10s-77.imp"
LCELL = (struct LISTF *)/*?*/ &ASLIST[TAGS[JJ]];
// 4109 ! OBTAIN NEXT NAME FORM DECLNS
// 4110 %IF LCELL_S1&16_F000=0 %THEN WARN(2,JJ)
#line 4110 "test-new/nrimp10s-77.imp"
if (LCELL->S1 & 61440 != 0) goto L_0388;
#line 4110 "test-new/nrimp10s-77.imp"
WARN(2, JJ);
#line 4110 "test-new/nrimp10s-77.imp"
L_0388:;
// 4111 !
// 4112 ! GET ONLY THE MINIMUM OF DETALS NECESSARY
// 4113 !
// 4114 S1=LCELL_S1; S2=LCELL_S2
#line 4114 "test-new/nrimp10s-77.imp"
S1 = LCELL->S1;
#line 4114 "test-new/nrimp10s-77.imp"
S2 = LCELL->S2;
// 4115 S3=LCELL_S3; S4=LCELL_LINK
#line 4115 "test-new/nrimp10s-77.imp"
S3 = LCELL->S3;
#line 4115 "test-new/nrimp10s-77.imp"
S4 = LCELL->LINK;
// 4116 LCELL_LINK=ASL; ASL=TAGS(JJ)
#line 4116 "test-new/nrimp10s-77.imp"
LCELL->LINK = ASL;
#line 4116 "test-new/nrimp10s-77.imp"
ASL = TAGS[JJ];
// 4117 TAGS(JJ)=S4&16_3FFFF
#line 4117 "test-new/nrimp10s-77.imp"
TAGS[JJ] = S4 & 262143;
// 4118 PTYPE=S1>>16; TYPE=PTYPE&15
#line 4118 "test-new/nrimp10s-77.imp"
PTYPE = (unsigned int)S1 >> 16;
#line 4118 "test-new/nrimp10s-77.imp"
TYPE = PTYPE & 15;
// 4119 I=S1>>4&15
#line 4119 "test-new/nrimp10s-77.imp"
I = (unsigned int)S1 >> 4 & 15;
// 4120 J=S1&15
#line 4120 "test-new/nrimp10s-77.imp"
J = S1 & 15;
// 4121 K=S3>>16
#line 4121 "test-new/nrimp10s-77.imp"
K = (unsigned int)S3 >> 16;
// 4122 !
// 4123 ! ALLOW OWNS (LITL=0) AND EXTERNALS (=2) NOT CONSTS(=1) OR EXTRINSIC(=3)
// 4124 !
// 4125 %IF PARMDIAG#0 %AND PTYPE&16_7300<=16_200 %AND DPTR<497 %AND (TYPE=1 %OR TYPE=2 %OR TYPE=5) %START
#line 4125 "test-new/nrimp10s-77.imp"
if (PARMDIAG == 0) goto L_0389;
#line 4125 "test-new/nrimp10s-77.imp"
if (PTYPE & 29440 > 512) goto L_0389;
#line 4125 "test-new/nrimp10s-77.imp"
if (DPTR >= 497) goto L_0389;
#line 4125 "test-new/nrimp10s-77.imp"
if (TYPE == 1) goto L_038A;
#line 4125 "test-new/nrimp10s-77.imp"
if (TYPE == 2) goto L_038A;
#line 4125 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_0389;
#line 4125 "test-new/nrimp10s-77.imp"
L_038A:;
// 4126 Q=DICTBASE+WORD(JJ); ! ADDRESS OF NAME
#line 4126 "test-new/nrimp10s-77.imp"
Q = DICTBASE + WORD[JJ];
// 4127 %IF I=0 %THEN II=1 %ELSE II=0; ! GLA OR LNB BIT
#line 4127 "test-new/nrimp10s-77.imp"
if (I != 0) goto L_038B;
#line 4127 "test-new/nrimp10s-77.imp"
II = 1;
#line 4127 "test-new/nrimp10s-77.imp"
goto L_038C;
#line 4127 "test-new/nrimp10s-77.imp"
L_038B:;
#line 4127 "test-new/nrimp10s-77.imp"
II = 0;
#line 4127 "test-new/nrimp10s-77.imp"
L_038C:;
// 4128 DD(DPTR)=PTYPE<<20!II<<18!K
#line 4128 "test-new/nrimp10s-77.imp"
DD[DPTR] = PTYPE << 20 | II << 18 | K;
// 4129 LOCAL NAME<-STRING(Q); ! TEXT OF NAME FROM DICTIONARY
#line 4129 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &LOCALNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *_imp_STRING(Q);
(void *)&tmp;
}),
/*max:*/ 11);
#line 4129 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 11 chars */
#line 4129 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &LOCALNAME) > 11) *_imp_LENGTH((_imp_string *)/*?*/ &LOCALNAME) = 11;
// 4130 LNUM=BYTE INTEGER(ADDR(LOCAL NAME))
#line 4130 "test-new/nrimp10s-77.imp"
LNUM = *_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &LOCALNAME));
// 4131 STRING(ADDR(DD(DPTR))+4)=LOCAL NAME;! MOVE IN NAME
#line 4131 "test-new/nrimp10s-77.imp"
*_imp_STRING(_imp_ADDR(/*?*/ &DD[DPTR]) + 4) = LOCALNAME;
// 4132 DPTR=DPTR+(LNUM+8)>>2
#line 4132 "test-new/nrimp10s-77.imp"
DPTR = DPTR + ((unsigned int)LNUM + 8 >> 2);
// 4133 %FINISH
#line 4133 "test-new/nrimp10s-77.imp"
L_0389:;
// 4134 %IF J=15 %AND S2#0 %THEN FAULT2(28,0,JJ)
#line 4134 "test-new/nrimp10s-77.imp"
if (J != 15) goto L_038D;
#line 4134 "test-new/nrimp10s-77.imp"
if (S2 == 0) goto L_038D;
#line 4134 "test-new/nrimp10s-77.imp"
FAULT2(28, 0, JJ);
#line 4134 "test-new/nrimp10s-77.imp"
L_038D:;
// 4135 ! SPEC&CALLED BUT NO BODY GIVEN
// 4136 %IF PTYPE&16_3000#0 %OR TYPE=4 %OR TYPE=6 %THEN CLEAR LIST(K) %ELSE %START
#line 4136 "test-new/nrimp10s-77.imp"
if (PTYPE & 12288 != 0) goto L_038E;
#line 4136 "test-new/nrimp10s-77.imp"
if (TYPE == 4) goto L_038E;
#line 4136 "test-new/nrimp10s-77.imp"
if (TYPE != 6) goto L_038F;
#line 4136 "test-new/nrimp10s-77.imp"
L_038E:;
#line 4136 "test-new/nrimp10s-77.imp"
CLEARLIST(/*?*/ &K);
#line 4136 "test-new/nrimp10s-77.imp"
goto L_0390;
#line 4136 "test-new/nrimp10s-77.imp"
L_038F:;
// 4137 %IF I#0 %AND K>511 %AND PTYPE&LARRROUT=0 %AND TYPE#7 %THEN WARN(5,JJ)
#line 4137 "test-new/nrimp10s-77.imp"
if (I == 0) goto L_0391;
#line 4137 "test-new/nrimp10s-77.imp"
if (K <= 511) goto L_0391;
#line 4137 "test-new/nrimp10s-77.imp"
if (PTYPE & 62208 != 0) goto L_0391;
#line 4137 "test-new/nrimp10s-77.imp"
if (TYPE == 7) goto L_0391;
#line 4137 "test-new/nrimp10s-77.imp"
WARN(5, JJ);
#line 4137 "test-new/nrimp10s-77.imp"
L_0391:;
// 4138 %FINISH
#line 4138 "test-new/nrimp10s-77.imp"
L_0390:;
// 4139 JJ=S4>>18
#line 4139 "test-new/nrimp10s-77.imp"
JJ = (unsigned int)S4 >> 18;
// 4140 %REPEAT
#line 4140 "test-new/nrimp10s-77.imp"
goto L_0386;
#line 4140 "test-new/nrimp10s-77.imp"
L_0387:;
// 4141 DD(DPTR)=-1; ! 'END OF SEGMENT' MARK
#line 4141 "test-new/nrimp10s-77.imp"
DD[DPTR] = -1;
// 4142 DPTR=DPTR<<2+4
#line 4142 "test-new/nrimp10s-77.imp"
DPTR = (DPTR << 2) + 4;
// 4143 %IF PARMTRACE=1 %THEN %START
#line 4143 "test-new/nrimp10s-77.imp"
if (PARMTRACE != 1) goto L_0392;
// 4144 LPUT(4,DPTR,SSTL,ADDR(DD(0)));! ADD TO SHARABLE SYM TABS
#line 4144 "test-new/nrimp10s-77.imp"
LPUT(4, DPTR, SSTL, _imp_ADDR(/*?*/ &DD[0]));
// 4145 SSTL=SSTL+DPTR
#line 4145 "test-new/nrimp10s-77.imp"
SSTL = SSTL + DPTR;
// 4146 %FINISH
#line 4146 "test-new/nrimp10s-77.imp"
L_0392:;
// 4147 %END; ! OF ROUTINE DTABLE
#line 4147 "test-new/nrimp10s-77.imp"
return;
#line 4147 "test-new/nrimp10s-77.imp"
} /* end of DTABLE */
// 4148 %END
#line 4148 "test-new/nrimp10s-77.imp"
return;
#line 4148 "test-new/nrimp10s-77.imp"
} /* end of CEND */
// 4149 %ROUTINE MAKE DECS(%INTEGER Q)
#line 4149 "test-new/nrimp10s-77.imp"
void MAKEDECS(int Q) {
// 4150 !***********************************************************************
// 4151 !* Q IS TO AR ENTRY FOR HEAD OF LINKED DECLARATIONS *
// 4152 !***********************************************************************
// 4153 %INTEGER QQ,HEAD,PRIO,COUNT,SL
#line 4153 "test-new/nrimp10s-77.imp"
int QQ;
#line 4153 "test-new/nrimp10s-77.imp"
int HEAD;
#line 4153 "test-new/nrimp10s-77.imp"
int PRIO;
#line 4153 "test-new/nrimp10s-77.imp"
int COUNT;
#line 4153 "test-new/nrimp10s-77.imp"
int SL;
// 4154 %INTEGERNAME THEAD
#line 4154 "test-new/nrimp10s-77.imp"
int *THEAD;
// 4155 %RECORD(LISTF)%NAME CELL{(LISTF)
#line 4155 "test-new/nrimp10s-77.imp"
struct LISTF *CELL;
// 4156 SL=LINE; QQ=FROM AR4(Q)
#line 4156 "test-new/nrimp10s-77.imp"
SL = LINE;
#line 4156 "test-new/nrimp10s-77.imp"
QQ = FROMAR4(Q);
// 4157 HEAD=0; COUNT=0
#line 4157 "test-new/nrimp10s-77.imp"
HEAD = 0;
#line 4157 "test-new/nrimp10s-77.imp"
COUNT = 0;
// 4158 %WHILE QQ#0 %CYCLE
#line 4158 "test-new/nrimp10s-77.imp"
L_0393:;
#line 4158 "test-new/nrimp10s-77.imp"
if (QQ == 0) goto L_0394;
// 4159 COUNT=COUNT+1
#line 4159 "test-new/nrimp10s-77.imp"
COUNT = COUNT + 1;
// 4160 ABORT %UNLESS A(QQ+5)=8; ! LINE IS A DECLARATION
#line 4160 "test-new/nrimp10s-77.imp"
if (A[QQ + 5] == 8) goto L_0395;
#line 4160 "test-new/nrimp10s-77.imp"
ABORT();
#line 4160 "test-new/nrimp10s-77.imp"
L_0395:;
// 4161 P=QQ+10; CLT
#line 4161 "test-new/nrimp10s-77.imp"
P = QQ + 10;
#line 4161 "test-new/nrimp10s-77.imp"
CLT();
// 4162 %IF PREC=3 %OR A(P)#1 %OR A(P+1)# 3 %START
#line 4162 "test-new/nrimp10s-77.imp"
if (PREC == 3) goto L_0396;
#line 4162 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0396;
#line 4162 "test-new/nrimp10s-77.imp"
if (A[P + 1] == 3) goto L_0397;
#line 4162 "test-new/nrimp10s-77.imp"
L_0396:;
// 4163 INSERT AT END(HEAD,16_FFFF,QQ,0) %IF A(P)=1
#line 4163 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0398;
#line 4163 "test-new/nrimp10s-77.imp"
INSERTATEND(/*?*/ &HEAD, 65535, QQ, 0);
#line 4163 "test-new/nrimp10s-77.imp"
L_0398:;
// 4164 %FINISH %ELSE %START
#line 4164 "test-new/nrimp10s-77.imp"
goto L_0399;
#line 4164 "test-new/nrimp10s-77.imp"
L_0397:;
// 4165 PRIO=PREC<<4!TYPE
#line 4165 "test-new/nrimp10s-77.imp"
PRIO = PREC << 4 | TYPE;
// 4166 THEAD==HEAD
#line 4166 "test-new/nrimp10s-77.imp"
THEAD = (int *)/*?*/ &HEAD;
// 4167 %CYCLE
#line 4167 "test-new/nrimp10s-77.imp"
L_039A:;
// 4168 CELL==ASLIST(THEAD)
#line 4168 "test-new/nrimp10s-77.imp"
CELL = (struct LISTF *)/*?*/ &ASLIST[*THEAD];
// 4169 %IF THEAD=0 %OR PRIO<CELL_S1 %THEN PUSH(THEAD,PRIO,QQ,0) %AND %EXIT
#line 4169 "test-new/nrimp10s-77.imp"
if (*THEAD == 0) goto L_0296;
#line 4169 "test-new/nrimp10s-77.imp"
if (PRIO >= CELL->S1) goto L_039B;
#line 4169 "test-new/nrimp10s-77.imp"
L_0296:;
#line 4169 "test-new/nrimp10s-77.imp"
PUSH(THEAD, PRIO, QQ, 0);
#line 4169 "test-new/nrimp10s-77.imp"
goto L_039C;
#line 4169 "test-new/nrimp10s-77.imp"
L_039B:;
// 4170 THEAD==CELL_LINK
#line 4170 "test-new/nrimp10s-77.imp"
THEAD = (int *)/*?*/ &CELL->LINK;
// 4171 %REPEAT
#line 4171 "test-new/nrimp10s-77.imp"
goto L_039A;
#line 4171 "test-new/nrimp10s-77.imp"
L_039C:;
// 4172 %FINISH
#line 4172 "test-new/nrimp10s-77.imp"
L_0399:;
// 4173 QQ=FROM AR4(QQ+6)
#line 4173 "test-new/nrimp10s-77.imp"
QQ = FROMAR4(QQ + 6);
// 4174 %REPEAT
#line 4174 "test-new/nrimp10s-77.imp"
goto L_0393;
#line 4174 "test-new/nrimp10s-77.imp"
L_0394:;
// 4175 !
// 4176 ! NOW MAKE THE ORDEREED DECLARATIONS
// 4177 ! FIRST GRAB TWO TEMPORARIES IF SPACE IS LIKELY TO BE TIGHT
// 4178 !
// 4179 %IF COUNT>=7 %START
#line 4179 "test-new/nrimp10s-77.imp"
if (COUNT < 7) goto L_039D;
// 4180 GET WSP(QQ,2); ! A DIUBLE WORD
#line 4180 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &QQ, 2);
// 4181 %IF AVL WSP(1,LEVEL)=0 %THEN GET WSP(QQ,1)
#line 4181 "test-new/nrimp10s-77.imp"
if (AVLWSP[1][LEVEL] != 0) goto L_039E;
#line 4181 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &QQ, 1);
#line 4181 "test-new/nrimp10s-77.imp"
L_039E:;
// 4182 %FINISH
#line 4182 "test-new/nrimp10s-77.imp"
L_039D:;
// 4183 %WHILE HEAD#0 %CYCLE
#line 4183 "test-new/nrimp10s-77.imp"
L_039F:;
#line 4183 "test-new/nrimp10s-77.imp"
if (HEAD == 0) goto L_03A0;
// 4184 POP(HEAD,PRIO,QQ,COUNT)
#line 4184 "test-new/nrimp10s-77.imp"
POP(/*?*/ &HEAD, /*?*/ &PRIO, /*?*/ &QQ, /*?*/ &COUNT);
// 4185 LINE=FROM AR2(QQ+3)
#line 4185 "test-new/nrimp10s-77.imp"
LINE = FROMAR2(QQ + 3);
// 4186 P=QQ+10; CLT
#line 4186 "test-new/nrimp10s-77.imp"
P = QQ + 10;
#line 4186 "test-new/nrimp10s-77.imp"
CLT();
// 4187 ROUT=0; LITL=0
#line 4187 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 4187 "test-new/nrimp10s-77.imp"
LITL = 0;
// 4188 CQN(P+1); P=P+2
#line 4188 "test-new/nrimp10s-77.imp"
CQN(P + 1);
#line 4188 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4189 DECLARE SCALARS(1,0)
#line 4189 "test-new/nrimp10s-77.imp"
DECLARESCALARS(1, 0);
// 4190 %REPEAT
#line 4190 "test-new/nrimp10s-77.imp"
goto L_039F;
#line 4190 "test-new/nrimp10s-77.imp"
L_03A0:;
// 4191 LINE=SL
#line 4191 "test-new/nrimp10s-77.imp"
LINE = SL;
// 4192 %END
#line 4192 "test-new/nrimp10s-77.imp"
return;
#line 4192 "test-new/nrimp10s-77.imp"
} /* end of MAKEDECS */
// 4193 %ROUTINE DECLARE SCALARS(%INTEGER PERMIT,XTRA)
#line 4193 "test-new/nrimp10s-77.imp"
void DECLARESCALARS(int PERMIT, int XTRA) {
// 4194 !***********************************************************************
// 4195 !* THIS ROUTINE DECLARES A LIST OF SCALARS FROM INFORMATION *
// 4196 !* IN THE GLOBAL VARIABLES ROUT,NAM,ARR,PREC,TYPE & ACC.IT WORKS *
// 4197 !* OUT ROUNDING FACTORS FOR ITSELF. *
// 4198 !* P POINTS TO THE NAMELIST ON ENTRY AND IS UPDATED. *
// 4199 !***********************************************************************
// 4200 %INTEGER INC,Q,SCHAIN,DMADE,NPARMS,D0,SCAL NAME,TYPEP
#line 4200 "test-new/nrimp10s-77.imp"
int INC;
#line 4200 "test-new/nrimp10s-77.imp"
int Q;
#line 4200 "test-new/nrimp10s-77.imp"
int SCHAIN;
#line 4200 "test-new/nrimp10s-77.imp"
int DMADE;
#line 4200 "test-new/nrimp10s-77.imp"
int NPARMS;
#line 4200 "test-new/nrimp10s-77.imp"
int D0;
#line 4200 "test-new/nrimp10s-77.imp"
int SCALNAME;
#line 4200 "test-new/nrimp10s-77.imp"
int TYPEP;
// 4201 PACK(PTYPE); J=0
#line 4201 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
#line 4201 "test-new/nrimp10s-77.imp"
J = 0;
// 4202 INC=ACC; DMADE=0; SNDISP=0
#line 4202 "test-new/nrimp10s-77.imp"
INC = ACC;
#line 4202 "test-new/nrimp10s-77.imp"
DMADE = 0;
#line 4202 "test-new/nrimp10s-77.imp"
SNDISP = 0;
// 4203 %IF PTYPE=16_33 %THEN INC=(INC+3)&(-4)
#line 4203 "test-new/nrimp10s-77.imp"
if (PTYPE != 51) goto L_03A1;
#line 4203 "test-new/nrimp10s-77.imp"
INC = INC + 3 & -4;
#line 4203 "test-new/nrimp10s-77.imp"
L_03A1:;
// 4204 %IF NAM#0 %AND ROUT=0 %AND ARR=0 %THEN INC=8
#line 4204 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_03A2;
#line 4204 "test-new/nrimp10s-77.imp"
if (ROUT != 0) goto L_03A2;
#line 4204 "test-new/nrimp10s-77.imp"
if (ARR != 0) goto L_03A2;
#line 4204 "test-new/nrimp10s-77.imp"
INC = 8;
#line 4204 "test-new/nrimp10s-77.imp"
L_03A2:;
// 4205 %IF NAM>0 %AND ARR>0 %THEN INC=16
#line 4205 "test-new/nrimp10s-77.imp"
if (NAM <= 0) goto L_03A3;
#line 4205 "test-new/nrimp10s-77.imp"
if (ARR <= 0) goto L_03A3;
#line 4205 "test-new/nrimp10s-77.imp"
INC = 16;
#line 4205 "test-new/nrimp10s-77.imp"
L_03A3:;
// 4206 %IF PTYPE=16_35 %AND ACC=0 %THEN FAULT(70,0)
#line 4206 "test-new/nrimp10s-77.imp"
if (PTYPE != 53) goto L_03A4;
#line 4206 "test-new/nrimp10s-77.imp"
if (ACC != 0) goto L_03A4;
#line 4206 "test-new/nrimp10s-77.imp"
FAULT(70, 0);
#line 4206 "test-new/nrimp10s-77.imp"
L_03A4:;
// 4207 %IF PERMIT#0 %AND (INC=8 %OR INC=16) %THEN ODD ALIGN
#line 4207 "test-new/nrimp10s-77.imp"
if (PERMIT == 0) goto L_03A5;
#line 4207 "test-new/nrimp10s-77.imp"
if (INC == 8) goto L_03A6;
#line 4207 "test-new/nrimp10s-77.imp"
if (INC != 16) goto L_03A5;
#line 4207 "test-new/nrimp10s-77.imp"
L_03A6:;
#line 4207 "test-new/nrimp10s-77.imp"
ODDALIGN();
#line 4207 "test-new/nrimp10s-77.imp"
L_03A5:;
// 4208 %IF PTYPE=16_33 %OR (PTYPE=16_35 %AND PERMIT#0)%START
#line 4208 "test-new/nrimp10s-77.imp"
if (PTYPE == 51) goto L_03A7;
#line 4208 "test-new/nrimp10s-77.imp"
if (PTYPE != 53) goto L_03A8;
#line 4208 "test-new/nrimp10s-77.imp"
if (PERMIT == 0) goto L_03A8;
#line 4208 "test-new/nrimp10s-77.imp"
L_03A7:;
// 4209 D0=16_18000000+ACC
#line 4209 "test-new/nrimp10s-77.imp"
D0 = 402653184 + ACC;
// 4210 STORE CONST(Q,4,ADDR(D0))
#line 4210 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &Q, 4, _imp_ADDR(/*?*/ &D0));
// 4211 PF1(LDTB,0,PC,Q)
#line 4211 "test-new/nrimp10s-77.imp"
PF1(116, 0, 4, Q);
// 4212 GRUSE(DR)=0
#line 4212 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 4213 %FINISH
#line 4213 "test-new/nrimp10s-77.imp"
L_03A8:;
// 4214 %IF PTYPE=16_35 %START
#line 4214 "test-new/nrimp10s-77.imp"
if (PTYPE != 53) goto L_03A9;
// 4215 INC=8
#line 4215 "test-new/nrimp10s-77.imp"
INC = 8;
// 4216 %IF PERMIT#0 %START
#line 4216 "test-new/nrimp10s-77.imp"
if (PERMIT == 0) goto L_03AA;
// 4217 PF1(STSF,0,TOS,0)
#line 4217 "test-new/nrimp10s-77.imp"
PF1(94, 0, 6, 0);
// 4218 PF1(LDA,0,TOS,0)
#line 4218 "test-new/nrimp10s-77.imp"
PF1(114, 0, 6, 0);
// 4219 %FINISH
#line 4219 "test-new/nrimp10s-77.imp"
L_03AA:;
// 4220 %FINISH
#line 4220 "test-new/nrimp10s-77.imp"
L_03A9:;
// 4221 N=(N+3)&(-4)
#line 4221 "test-new/nrimp10s-77.imp"
N = N + 3 & -4;
// 4222 %IF PTYPE=16_33 %THEN %START
#line 4222 "test-new/nrimp10s-77.imp"
if (PTYPE != 51) goto L_03AB;
// 4223 PSF1(LDA,1,PTR OFFSET(RBASE))
#line 4223 "test-new/nrimp10s-77.imp"
PSF1(114, 1, PTROFFSET(RBASE));
// 4224 PSF1(INCA,0,N+8)
#line 4224 "test-new/nrimp10s-77.imp"
PSF1(20, 0, N + 8);
// 4225 %FINISH
#line 4225 "test-new/nrimp10s-77.imp"
L_03AB:;
// 4226 {%UNTIL A(P-1)=2} %CYCLE; ! DOWN THE NAMELIST
#line 4226 "test-new/nrimp10s-77.imp"
L_03AC:;
// 4227 DMADE=DMADE+1
#line 4227 "test-new/nrimp10s-77.imp"
DMADE = DMADE + 1;
// 4228 SCAL NAME=FROM AR2(P)
#line 4228 "test-new/nrimp10s-77.imp"
SCALNAME = FROMAR2(P);
// 4229 %IF PTYPE=16_31 %AND PERMIT=0 %THEN N=N+3;! BYTE PARAMS
#line 4229 "test-new/nrimp10s-77.imp"
if (PTYPE != 49) goto L_03AD;
#line 4229 "test-new/nrimp10s-77.imp"
if (PERMIT != 0) goto L_03AD;
#line 4229 "test-new/nrimp10s-77.imp"
N = N + 3;
#line 4229 "test-new/nrimp10s-77.imp"
L_03AD:;
// 4230 %IF PTYPE=16_41 %AND PERMIT=0 %THEN N=N+2
#line 4230 "test-new/nrimp10s-77.imp"
if (PTYPE != 65) goto L_03AE;
#line 4230 "test-new/nrimp10s-77.imp"
if (PERMIT != 0) goto L_03AE;
#line 4230 "test-new/nrimp10s-77.imp"
N = N + 2;
#line 4230 "test-new/nrimp10s-77.imp"
L_03AE:;
// 4231 SCHAIN=N
#line 4231 "test-new/nrimp10s-77.imp"
SCHAIN = N;
// 4232 KFORM=XTRA
#line 4232 "test-new/nrimp10s-77.imp"
KFORM = XTRA;
// 4233 %IF ROUT=1 %THEN %START
#line 4233 "test-new/nrimp10s-77.imp"
if (ROUT != 1) goto L_03AF;
// 4234 TYPEP=PTYPE; ! CHANGED BY CFPLIST!
#line 4234 "test-new/nrimp10s-77.imp"
TYPEP = PTYPE;
// 4235 Q=P
#line 4235 "test-new/nrimp10s-77.imp"
Q = P;
// 4236 P=P+3 %UNTIL A(P-1)=2; ! TO FPP
#line 4236 "test-new/nrimp10s-77.imp"
L_03B0:;
#line 4236 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 4236 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_03B1;
#line 4236 "test-new/nrimp10s-77.imp"
goto L_03B0;
#line 4236 "test-new/nrimp10s-77.imp"
L_03B1:;
// 4237 CFPLIST(SCHAIN,NPARMS)
#line 4237 "test-new/nrimp10s-77.imp"
CFPLIST(/*?*/ &SCHAIN, /*?*/ &NPARMS);
// 4238 P=Q
#line 4238 "test-new/nrimp10s-77.imp"
P = Q;
// 4239 J=13
#line 4239 "test-new/nrimp10s-77.imp"
J = 13;
// 4240 KFORM=NPARMS; ! NO OF PARAMS OF FORMAL
#line 4240 "test-new/nrimp10s-77.imp"
KFORM = NPARMS;
// 4241 ACC=N; ! DISPLACEMENT TO MIDCELL
#line 4241 "test-new/nrimp10s-77.imp"
ACC = N;
// 4242 PTYPE=TYPEP; UNPACK
#line 4242 "test-new/nrimp10s-77.imp"
PTYPE = TYPEP;
#line 4242 "test-new/nrimp10s-77.imp"
UNPACK();
// 4243 %FINISH
#line 4243 "test-new/nrimp10s-77.imp"
L_03AF:;
// 4244 P=P+3
#line 4244 "test-new/nrimp10s-77.imp"
P = P + 3;
// 4245 %IF PTYPE=16_33 %THEN %START
#line 4245 "test-new/nrimp10s-77.imp"
if (PTYPE != 51) goto L_03B2;
// 4246 PSF1(STD,1,N)
#line 4246 "test-new/nrimp10s-77.imp"
PSF1(88, 1, N);
// 4247 N=N+8; SCHAIN=N
#line 4247 "test-new/nrimp10s-77.imp"
N = N + 8;
#line 4247 "test-new/nrimp10s-77.imp"
SCHAIN = N;
// 4248 %IF A(P-1)=1 %THEN PSF1(INCA,0,INC+8)
#line 4248 "test-new/nrimp10s-77.imp"
if (A[P - 1] != 1) goto L_03B3;
#line 4248 "test-new/nrimp10s-77.imp"
PSF1(20, 0, INC + 8);
#line 4248 "test-new/nrimp10s-77.imp"
L_03B3:;
// 4249 %FINISH
#line 4249 "test-new/nrimp10s-77.imp"
L_03B2:;
// 4250 %IF PTYPE=16_35 %AND PERMIT#0 %START
#line 4250 "test-new/nrimp10s-77.imp"
if (PTYPE != 53) goto L_03B4;
#line 4250 "test-new/nrimp10s-77.imp"
if (PERMIT == 0) goto L_03B4;
// 4251 PSF1(STD,1,N)
#line 4251 "test-new/nrimp10s-77.imp"
PSF1(88, 1, N);
// 4252 %IF A(P-1)=1 %THEN PSF1(INCA,0,(ACC+3)&(-4)) %ELSE %START
#line 4252 "test-new/nrimp10s-77.imp"
if (A[P - 1] != 1) goto L_03B5;
#line 4252 "test-new/nrimp10s-77.imp"
PSF1(20, 0, ACC + 3 & -4);
#line 4252 "test-new/nrimp10s-77.imp"
goto L_03B6;
#line 4252 "test-new/nrimp10s-77.imp"
L_03B5:;
// 4253 Q=((ACC+3)>>2)*DMADE
#line 4253 "test-new/nrimp10s-77.imp"
Q = ((unsigned int)ACC + 3 >> 2) * DMADE;
// 4254 PSF1(ASF+12*PARMCHK,0,Q)
#line 4254 "test-new/nrimp10s-77.imp"
PSF1(110 + 12 * PARMCHK, 0, Q);
// 4255 %IF PARMCHK#0 %THEN PPJ(0,4)
#line 4255 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_03B7;
#line 4255 "test-new/nrimp10s-77.imp"
PPJ(0, 4);
#line 4255 "test-new/nrimp10s-77.imp"
L_03B7:;
// 4256 %FINISH
#line 4256 "test-new/nrimp10s-77.imp"
L_03B6:;
// 4257 %FINISH
#line 4257 "test-new/nrimp10s-77.imp"
L_03B4:;
// 4258 STORE TAG(SCAL NAME,SCHAIN)
#line 4258 "test-new/nrimp10s-77.imp"
STORETAG(SCALNAME, SCHAIN);
// 4259 N=N+INC
#line 4259 "test-new/nrimp10s-77.imp"
N = N + INC;
// 4260 %REPEAT %UNTIL A(P-1)=2
#line 4260 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_03B8;
#line 4260 "test-new/nrimp10s-77.imp"
goto L_03AC;
#line 4260 "test-new/nrimp10s-77.imp"
L_03B8:;
// 4261 N=(N+3)&(-4) %IF PERMIT#0;! NO ROUNDING AMONG PARAMS
#line 4261 "test-new/nrimp10s-77.imp"
if (PERMIT == 0) goto L_03B9;
#line 4261 "test-new/nrimp10s-77.imp"
N = N + 3 & -4;
#line 4261 "test-new/nrimp10s-77.imp"
L_03B9:;
// 4262 %END
#line 4262 "test-new/nrimp10s-77.imp"
return;
#line 4262 "test-new/nrimp10s-77.imp"
} /* end of DECLARESCALARS */
// 4263 %INTEGERFN DOPE VECTOR(%INTEGER TYPEP,ELSIZE,MODE,IDEN,%INTEGERNAME ASIZE,LB)
#line 4263 "test-new/nrimp10s-77.imp"
int DOPEVECTOR(int TYPEP, int ELSIZE, int MODE, int IDEN, int *ASIZE, int *LB) {
// 4264 !***********************************************************************
// 4265 !* CONSTRUCTS THE DOPE-VECTOR FOR A CONSTANT ARRAY IN THE *
// 4266 !* SHAREABLE SYMBOL TABLES AND RETURNS ITS DISPLACEMENT AS RESULT*
// 4267 !* EVENTUALLY ALL NON DYNAMIC DOPE VECTORS SHOULD GO VIA HERE *
// 4268 !* P IS TO ALT (MUST BE 1!) OF P<BPAIR> *
// 4269 !* DOPE VECTOR CONSISTS OF :- *
// 4270 !* DESRIPTOR (SCALED WORD) POINTING AT FIRST TRIPLE BND=3*ND *
// 4271 !* SIZE (IN BYTES OF ENTIRE ARRAY) FOR STACK ADJUSTMENT *
// 4272 !* AND ND TRIPLES EACH CONSISTING OF:- *
// 4273 !* LBI - THE LOWER BOUND OF THE ITH DIMENSION *
// 4274 !* MI - THE STRIDE FOR THE ITH DIMENSION *
// 4275 !* CBI THE UPPER CHECK =(UBI-LBI+1)*MI *
// 4276 !* WHERE M1=1(SCALED ARRAYS) OR THE ELEMENT SIZE AND *
// 4277 !* MI = M(I-1)*RANGE(I-1) *
// 4278 !* MODE=0 DV MUST BE CONST, MODE#0 CAN BE DYNAMIC *
// 4279 !* P TO ALT (ALWAYS=1) OF P(BPAIR) *
// 4280 !***********************************************************************
// 4281 %INTEGER I, JJ, K, ND, D, UNSCAL, M0, HEAD, NOPS, TYPEPP, PIN, PTR
#line 4281 "test-new/nrimp10s-77.imp"
int I;
#line 4281 "test-new/nrimp10s-77.imp"
int JJ;
#line 4281 "test-new/nrimp10s-77.imp"
int K;
#line 4281 "test-new/nrimp10s-77.imp"
int ND;
#line 4281 "test-new/nrimp10s-77.imp"
int D;
#line 4281 "test-new/nrimp10s-77.imp"
int UNSCAL;
#line 4281 "test-new/nrimp10s-77.imp"
int M0;
#line 4281 "test-new/nrimp10s-77.imp"
int HEAD;
#line 4281 "test-new/nrimp10s-77.imp"
int NOPS;
#line 4281 "test-new/nrimp10s-77.imp"
int TYPEPP;
#line 4281 "test-new/nrimp10s-77.imp"
int PIN;
#line 4281 "test-new/nrimp10s-77.imp"
int PTR;
// 4282 %RECORD(LISTF)%NAME LCELL{(LISTF)
#line 4282 "test-new/nrimp10s-77.imp"
struct LISTF *LCELL;
// 4283 %INTEGERARRAY LBH,LBB,UBH,UBB(0:12)
#line 4283 "test-new/nrimp10s-77.imp"
int LBH[13];
#line 4283 "test-new/nrimp10s-77.imp"
int LBB[13];
#line 4283 "test-new/nrimp10s-77.imp"
int UBH[13];
#line 4283 "test-new/nrimp10s-77.imp"
int UBB[13];
// 4284 %INTEGERARRAY DV(0:39); ! ENOUGH FOR 12 DIMENSIONS
#line 4284 "test-new/nrimp10s-77.imp"
int DV[40];
// 4285 ND=0; NOPS=0; TYPEPP=0; PIN=P
#line 4285 "test-new/nrimp10s-77.imp"
ND = 0;
#line 4285 "test-new/nrimp10s-77.imp"
NOPS = 0;
#line 4285 "test-new/nrimp10s-77.imp"
TYPEPP = 0;
#line 4285 "test-new/nrimp10s-77.imp"
PIN = P;
// 4286 %IF TYPEP>2 %OR (TYPEP=1 %AND PREC=4) %THEN UNSCAL=1 %AND M0=ELSIZE %ELSE UNSCAL=0 %AND M0=1
#line 4286 "test-new/nrimp10s-77.imp"
if (TYPEP > 2) goto L_03BA;
#line 4286 "test-new/nrimp10s-77.imp"
if (TYPEP != 1) goto L_03BB;
#line 4286 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_03BB;
#line 4286 "test-new/nrimp10s-77.imp"
L_03BA:;
#line 4286 "test-new/nrimp10s-77.imp"
UNSCAL = 1;
#line 4286 "test-new/nrimp10s-77.imp"
M0 = ELSIZE;
#line 4286 "test-new/nrimp10s-77.imp"
goto L_03BC;
#line 4286 "test-new/nrimp10s-77.imp"
L_03BB:;
#line 4286 "test-new/nrimp10s-77.imp"
UNSCAL = 0;
#line 4286 "test-new/nrimp10s-77.imp"
M0 = 1;
#line 4286 "test-new/nrimp10s-77.imp"
L_03BC:;
// 4287 {%UNTIL A(P)=2} %CYCLE
#line 4287 "test-new/nrimp10s-77.imp"
L_03BD:;
// 4288 ND=ND+1; P=P+4
#line 4288 "test-new/nrimp10s-77.imp"
ND = ND + 1;
#line 4288 "test-new/nrimp10s-77.imp"
P = P + 4;
// 4289 LBH(ND)=0; LBB(ND)=0
#line 4289 "test-new/nrimp10s-77.imp"
LBH[ND] = 0;
#line 4289 "test-new/nrimp10s-77.imp"
LBB[ND] = 0;
// 4290 UBB(ND)=0; UBH(ND)=0
#line 4290 "test-new/nrimp10s-77.imp"
UBB[ND] = 0;
#line 4290 "test-new/nrimp10s-77.imp"
UBH[ND] = 0;
// 4291 TORP(LBH(ND),LBB(ND),NOPS)
#line 4291 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &LBH[ND], /*?*/ &LBB[ND], /*?*/ &NOPS);
// 4292 P=P+3
#line 4292 "test-new/nrimp10s-77.imp"
P = P + 3;
// 4293 TYPEPP=TYPEPP!TYPE
#line 4293 "test-new/nrimp10s-77.imp"
TYPEPP = TYPEPP | TYPE;
// 4294 TORP(UBH(ND),UBB(ND),NOPS)
#line 4294 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &UBH[ND], /*?*/ &UBB[ND], /*?*/ &NOPS);
// 4295 TYPEPP=TYPEPP!TYPE
#line 4295 "test-new/nrimp10s-77.imp"
TYPEPP = TYPEPP | TYPE;
// 4296 %REPEAT %UNTIL A(P)=2
#line 4296 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_03BE;
#line 4296 "test-new/nrimp10s-77.imp"
goto L_03BD;
#line 4296 "test-new/nrimp10s-77.imp"
L_03BE:;
// 4297 P=P+1
#line 4297 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4298 ->NONCONST %UNLESS TYPEPP=1 %AND NOPS&16_40040000=0
#line 4298 "test-new/nrimp10s-77.imp"
if (TYPEPP != 1) goto L_03BF;
#line 4298 "test-new/nrimp10s-77.imp"
if (NOPS & 1074003968 == 0) goto L_03C0;
#line 4298 "test-new/nrimp10s-77.imp"
L_03BF:;
#line 4298 "test-new/nrimp10s-77.imp"
goto U_1024;
#line 4298 "test-new/nrimp10s-77.imp"
L_03C0:;
// 4299 !
// 4300 ! NOW ONE CAN WORK OUT AND FILL IN THE TRIPLES
// 4301 !
// 4302 PTR=1
#line 4302 "test-new/nrimp10s-77.imp"
PTR = 1;
// 4303 %CYCLE D=ND,-1,1
#line 4303 "test-new/nrimp10s-77.imp"
// %for D = ND, -1, 1 %cycle
#line 4303 "test-new/nrimp10s-77.imp"
{
int _control, _initial = ND, _increment = -1, _final = 1;
#line 4303 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle D = ND, -1, 1");
_control = D = _initial - _increment;
#line 4303 "test-new/nrimp10s-77.imp"
L_03C1:
#line 4303 "test-new/nrimp10s-77.imp"
if (D != _control) _imp_signal(4, 2, 0, "Corrupt control variable D");
#line 4303 "test-new/nrimp10s-77.imp"
if (D == _final) goto L_03C2;
#line 4303 "test-new/nrimp10s-77.imp"
_control += _increment;
D -= 1;
// 4304 K=3*D
#line 4304 "test-new/nrimp10s-77.imp"
K = 3 * D;
// 4305 EXPOP(LBH(PTR),ACCR,NOPS,16_251)
#line 4305 "test-new/nrimp10s-77.imp"
EXPOP(LBH[PTR], 0, NOPS, 593);
// 4306 EXPOPND_D=0 %AND FAULT(41,0) %UNLESS EXPOPND_FLAG<=1 %AND EXPOPND_PTYPE=16_51
#line 4306 "test-new/nrimp10s-77.imp"
if (EXPOPND.FLAG > 1) goto L_03C4;
#line 4306 "test-new/nrimp10s-77.imp"
if (EXPOPND.PTYPE == 81) goto L_03C5;
#line 4306 "test-new/nrimp10s-77.imp"
L_03C4:;
#line 4306 "test-new/nrimp10s-77.imp"
EXPOPND.D = 0;
#line 4306 "test-new/nrimp10s-77.imp"
FAULT(41, 0);
#line 4306 "test-new/nrimp10s-77.imp"
L_03C5:;
// 4307 DV(K)=EXPOPND_D
#line 4307 "test-new/nrimp10s-77.imp"
DV[K] = EXPOPND.D;
// 4308 DV(K+1)=M0
#line 4308 "test-new/nrimp10s-77.imp"
DV[K + 1] = M0;
// 4309 EXPOP(UBH(PTR),ACCR,NOPS,16_251)
#line 4309 "test-new/nrimp10s-77.imp"
EXPOP(UBH[PTR], 0, NOPS, 593);
// 4310 EXPOPND_D=10 %AND FAULT(41,0) %UNLESS EXPOPND_FLAG<=1 %AND EXPOPND_PTYPE=16_51
#line 4310 "test-new/nrimp10s-77.imp"
if (EXPOPND.FLAG > 1) goto L_03C6;
#line 4310 "test-new/nrimp10s-77.imp"
if (EXPOPND.PTYPE == 81) goto L_03C7;
#line 4310 "test-new/nrimp10s-77.imp"
L_03C6:;
#line 4310 "test-new/nrimp10s-77.imp"
EXPOPND.D = 10;
#line 4310 "test-new/nrimp10s-77.imp"
FAULT(41, 0);
#line 4310 "test-new/nrimp10s-77.imp"
L_03C7:;
// 4311 JJ=EXPOPND_D
#line 4311 "test-new/nrimp10s-77.imp"
JJ = EXPOPND.D;
// 4312 M0=M0*(JJ-DV(K)+1)
#line 4312 "test-new/nrimp10s-77.imp"
M0 = M0 * (JJ - DV[K] + 1);
// 4313 FAULT2(38,1-M0,IDEN) %UNLESS JJ>=DV(K)
#line 4313 "test-new/nrimp10s-77.imp"
if (JJ >= DV[K]) goto L_03C8;
#line 4313 "test-new/nrimp10s-77.imp"
FAULT2(38, 1 - M0, IDEN);
#line 4313 "test-new/nrimp10s-77.imp"
L_03C8:;
// 4314 DV(K+2)=M0
#line 4314 "test-new/nrimp10s-77.imp"
DV[K + 2] = M0;
// 4315 PTR=PTR+1
#line 4315 "test-new/nrimp10s-77.imp"
PTR = PTR + 1;
// 4316 %REPEAT
#line 4316 "test-new/nrimp10s-77.imp"
goto L_03C1;
#line 4316 "test-new/nrimp10s-77.imp"
}
#line 4316 "test-new/nrimp10s-77.imp"
L_03C2:;
// 4317 !
// 4318 %IF UNSCAL=0 %THEN M0=M0*ELSIZE
#line 4318 "test-new/nrimp10s-77.imp"
if (UNSCAL != 0) goto L_03C9;
#line 4318 "test-new/nrimp10s-77.imp"
M0 = M0 * ELSIZE;
#line 4318 "test-new/nrimp10s-77.imp"
L_03C9:;
// 4319 %IF ND=1 %THEN LB=DV(3)
#line 4319 "test-new/nrimp10s-77.imp"
if (ND != 1) goto L_03CA;
#line 4319 "test-new/nrimp10s-77.imp"
*LB = DV[3];
#line 4319 "test-new/nrimp10s-77.imp"
L_03CA:;
// 4320 ASIZE=M0
#line 4320 "test-new/nrimp10s-77.imp"
*ASIZE = M0;
// 4321 DV(2)=ASIZE
#line 4321 "test-new/nrimp10s-77.imp"
DV[2] = *ASIZE;
// 4322 DV(1)=12
#line 4322 "test-new/nrimp10s-77.imp"
DV[1] = 12;
// 4323 DV(0)=5<<27!3*ND; ! DESPTR FOR DV
#line 4323 "test-new/nrimp10s-77.imp"
DV[0] = 5 << 27 | 3 * ND;
// 4324 K=3*ND+2
#line 4324 "test-new/nrimp10s-77.imp"
K = 3 * ND + 2;
// 4325 J=ND; ! DIMENSIONALITY FOR DECLN
#line 4325 "test-new/nrimp10s-77.imp"
J = ND;
// 4326 HEAD=DVHEADS(ND)
#line 4326 "test-new/nrimp10s-77.imp"
HEAD = DVHEADS[ND];
// 4327 %WHILE HEAD#0 %CYCLE
#line 4327 "test-new/nrimp10s-77.imp"
L_03CB:;
#line 4327 "test-new/nrimp10s-77.imp"
if (HEAD == 0) goto L_03CC;
// 4328 LCELL==ASLIST(HEAD)
#line 4328 "test-new/nrimp10s-77.imp"
LCELL = (struct LISTF *)/*?*/ &ASLIST[HEAD];
// 4329 %IF LCELL_S2=ASIZE %AND LCELL_S3=DV(5) %START
#line 4329 "test-new/nrimp10s-77.imp"
if (LCELL->S2 != *ASIZE) goto L_03CD;
#line 4329 "test-new/nrimp10s-77.imp"
if (LCELL->S3 != DV[5]) goto L_03CD;
// 4330 %CYCLE D=0,1,K
#line 4330 "test-new/nrimp10s-77.imp"
// %for D = 0, 1, K %cycle
#line 4330 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = K;
#line 4330 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle D = 0, 1, K");
_control = D = _initial - _increment;
#line 4330 "test-new/nrimp10s-77.imp"
L_03CE:
#line 4330 "test-new/nrimp10s-77.imp"
if (D != _control) _imp_signal(4, 2, 0, "Corrupt control variable D");
#line 4330 "test-new/nrimp10s-77.imp"
if (D == _final) goto L_03CF;
#line 4330 "test-new/nrimp10s-77.imp"
_control += _increment;
D += _increment;
// 4331 ->ON %UNLESS DV(D)=CTABLE_val(D+LCELL_S1)
#line 4331 "test-new/nrimp10s-77.imp"
if (DV[D] == CTABLE->VAL[D + LCELL->S1]) goto L_03D1;
#line 4331 "test-new/nrimp10s-77.imp"
goto U_1025;
#line 4331 "test-new/nrimp10s-77.imp"
L_03D1:;
// 4332 %REPEAT
#line 4332 "test-new/nrimp10s-77.imp"
goto L_03CE;
#line 4332 "test-new/nrimp10s-77.imp"
}
#line 4332 "test-new/nrimp10s-77.imp"
L_03CF:;
// 4333 %RESULT=16_80000000!4*LCELL_S1
#line 4333 "test-new/nrimp10s-77.imp"
return -2147483648 | 4 * LCELL->S1;
// 4334 %FINISH
#line 4334 "test-new/nrimp10s-77.imp"
L_03CD:;
// 4335 ON:
#line 4335 "test-new/nrimp10s-77.imp"
U_1025:;
// 4336 HEAD=LCELL_LINK
#line 4336 "test-new/nrimp10s-77.imp"
HEAD = LCELL->LINK;
// 4337 %REPEAT
#line 4337 "test-new/nrimp10s-77.imp"
goto L_03CB;
#line 4337 "test-new/nrimp10s-77.imp"
L_03CC:;
// 4338 %IF CONST PTR&1#0 %THEN CONST HOLE=CONST PTR %AND CONST PTR=CONST PTR+1
#line 4338 "test-new/nrimp10s-77.imp"
if (CONSTPTR & 1 == 0) goto L_03D2;
#line 4338 "test-new/nrimp10s-77.imp"
CONSTHOLE = CONSTPTR;
#line 4338 "test-new/nrimp10s-77.imp"
CONSTPTR = CONSTPTR + 1;
#line 4338 "test-new/nrimp10s-77.imp"
L_03D2:;
// 4339 I=4*CONST PTR!16_80000000
#line 4339 "test-new/nrimp10s-77.imp"
I = 4 * CONSTPTR | -2147483648;
// 4340 PUSH(DVHEADS(ND),CONSTPTR,ASIZE,DV(5))
#line 4340 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &DVHEADS[ND], CONSTPTR, *ASIZE, DV[5]);
// 4341 %CYCLE D=0,1,K
#line 4341 "test-new/nrimp10s-77.imp"
// %for D = 0, 1, K %cycle
#line 4341 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = K;
#line 4341 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle D = 0, 1, K");
_control = D = _initial - _increment;
#line 4341 "test-new/nrimp10s-77.imp"
L_03D3:
#line 4341 "test-new/nrimp10s-77.imp"
if (D != _control) _imp_signal(4, 2, 0, "Corrupt control variable D");
#line 4341 "test-new/nrimp10s-77.imp"
if (D == _final) goto L_03D4;
#line 4341 "test-new/nrimp10s-77.imp"
_control += _increment;
D += _increment;
// 4342 CTABLE_val(CONST PTR)=DV(D)
#line 4342 "test-new/nrimp10s-77.imp"
CTABLE->VAL[CONSTPTR] = DV[D];
// 4343 CONST PTR=CONST PTR+1
#line 4343 "test-new/nrimp10s-77.imp"
CONSTPTR = CONSTPTR + 1;
// 4344 %REPEAT
#line 4344 "test-new/nrimp10s-77.imp"
goto L_03D3;
#line 4344 "test-new/nrimp10s-77.imp"
}
#line 4344 "test-new/nrimp10s-77.imp"
L_03D4:;
// 4345 %IF CONST PTR>CONST LIMIT %THEN FAULT(107,0)
#line 4345 "test-new/nrimp10s-77.imp"
if (CONSTPTR <= CONSTLIMIT) goto L_03D5;
#line 4345 "test-new/nrimp10s-77.imp"
FAULT(107, 0);
#line 4345 "test-new/nrimp10s-77.imp"
L_03D5:;
// 4346 WAYOUT:
#line 4346 "test-new/nrimp10s-77.imp"
U_1027:;
// 4347 %CYCLE D=ND,-1,1
#line 4347 "test-new/nrimp10s-77.imp"
// %for D = ND, -1, 1 %cycle
#line 4347 "test-new/nrimp10s-77.imp"
{
int _control, _initial = ND, _increment = -1, _final = 1;
#line 4347 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle D = ND, -1, 1");
_control = D = _initial - _increment;
#line 4347 "test-new/nrimp10s-77.imp"
L_03D6:
#line 4347 "test-new/nrimp10s-77.imp"
if (D != _control) _imp_signal(4, 2, 0, "Corrupt control variable D");
#line 4347 "test-new/nrimp10s-77.imp"
if (D == _final) goto L_03D7;
#line 4347 "test-new/nrimp10s-77.imp"
_control += _increment;
D -= 1;
// 4348 ASLIST(LBB(D))_LINK=ASL
#line 4348 "test-new/nrimp10s-77.imp"
ASLIST[LBB[D]].LINK = ASL;
// 4349 ASL=LBH(D)
#line 4349 "test-new/nrimp10s-77.imp"
ASL = LBH[D];
// 4350 ASLIST(UBB(D))_LINK=ASL
#line 4350 "test-new/nrimp10s-77.imp"
ASLIST[UBB[D]].LINK = ASL;
// 4351 ASL=UBH(D)
#line 4351 "test-new/nrimp10s-77.imp"
ASL = UBH[D];
// 4352 %REPEAT
#line 4352 "test-new/nrimp10s-77.imp"
goto L_03D6;
#line 4352 "test-new/nrimp10s-77.imp"
}
#line 4352 "test-new/nrimp10s-77.imp"
L_03D7:;
// 4353 %RESULT =I
#line 4353 "test-new/nrimp10s-77.imp"
return I;
// 4354 NONCONST: ! NOT A CONST DV
#line 4354 "test-new/nrimp10s-77.imp"
U_1024:;
// 4355 J=ND; I=-1
#line 4355 "test-new/nrimp10s-77.imp"
J = ND;
#line 4355 "test-new/nrimp10s-77.imp"
I = -1;
// 4356 LB=0; ASIZE=ELSIZE
#line 4356 "test-new/nrimp10s-77.imp"
*LB = 0;
#line 4356 "test-new/nrimp10s-77.imp"
*ASIZE = ELSIZE;
// 4357 %IF MODE=0 %THEN FAULT(41,0) %ELSE P=PIN
#line 4357 "test-new/nrimp10s-77.imp"
if (MODE != 0) goto L_03D8;
#line 4357 "test-new/nrimp10s-77.imp"
FAULT(41, 0);
#line 4357 "test-new/nrimp10s-77.imp"
goto L_03D9;
#line 4357 "test-new/nrimp10s-77.imp"
L_03D8:;
#line 4357 "test-new/nrimp10s-77.imp"
P = PIN;
#line 4357 "test-new/nrimp10s-77.imp"
L_03D9:;
// 4358 ->WAYOUT
#line 4358 "test-new/nrimp10s-77.imp"
goto U_1027;
// 4359 %END
#line 4359 "test-new/nrimp10s-77.imp"
} /* end of DOPEVECTOR */
// 4360
// 4361 %ROUTINE DECLARE ARRAYS(%INTEGER FORMAT, FINF)
#line 4361 "test-new/nrimp10s-77.imp"
void DECLAREARRAYS(int FORMAT, int FINF) {
#line 4361 "test-new/nrimp10s-77.imp"
auto void CLAIMAS(void);
// 4362 !***********************************************************************
// 4363 !* FORMAT=1 FOR 'ARRAYFORMAT' =0 OTHERWISE *
// 4364 !* FINF>0 FOR RECORD FORMAT INFORMATION =0 OTHERWISE *
// 4365 !* P IS AT P<ADECLN> IN *
// 4366 !* *
// 4367 !* P<ADECLN>=<NAMELIST> <BPAIR> <RESTOFDECLN> *
// 4368 !* P<BPAIR> = '('<EXPR>':'<EXRR><RESTOFBP>*')' *
// 4369 !* *
// 4370 !* ARRAYS WITH CONSTANT BOUNDS HAVE THEIR D-V IN THE SST *
// 4371 !* ALL OTHER ARRAYS HAVE A DOPE VECTOR AMONG THE LOCALS AND GET *
// 4372 !* THEIR SPACE OFF THE STACK AT RUN TIME *
// 4373 !* BOTH SORTS OF ARRAYS HAVE A FOUR WORD HEAD AND D-V TO EMAS *
// 4374 !* SYSTEM STANDARDS *
// 4375 !***********************************************************************
// 4376 %ROUTINESPEC CLAIM AS
// 4377 %INTEGER DVDISP, PP, DVF, ELSIZE, TOTSIZE, D0, D1, PTYPEP, {%C
#line 4377 "test-new/nrimp10s-77.imp"
int DVDISP;
#line 4377 "test-new/nrimp10s-77.imp"
int PP;
#line 4377 "test-new/nrimp10s-77.imp"
int DVF;
#line 4377 "test-new/nrimp10s-77.imp"
int ELSIZE;
#line 4377 "test-new/nrimp10s-77.imp"
int TOTSIZE;
#line 4377 "test-new/nrimp10s-77.imp"
int D0;
#line 4377 "test-new/nrimp10s-77.imp"
int D1;
#line 4377 "test-new/nrimp10s-77.imp"
int PTYPEP;
#line 4377 "test-new/nrimp10s-77.imp"
int ARRP;
#line 4377 "test-new/nrimp10s-77.imp"
int NN;
#line 4377 "test-new/nrimp10s-77.imp"
int ND;
#line 4377 "test-new/nrimp10s-77.imp"
int II;
#line 4377 "test-new/nrimp10s-77.imp"
int JJ;
#line 4377 "test-new/nrimp10s-77.imp"
int QQ;
#line 4377 "test-new/nrimp10s-77.imp"
int R;
#line 4377 "test-new/nrimp10s-77.imp"
int CDV;
#line 4377 "test-new/nrimp10s-77.imp"
int UNSCAL;
#line 4377 "test-new/nrimp10s-77.imp"
int DESC;
#line 4377 "test-new/nrimp10s-77.imp"
int SC;
#line 4377 "test-new/nrimp10s-77.imp"
int LWB;
#line 4377 "test-new/nrimp10s-77.imp"
int PTYPEPP;
#line 4377 "test-new/nrimp10s-77.imp"
int JJJ;
#line 4377 "test-new/nrimp10s-77.imp"
int JJJJ;
#line 4377 "test-new/nrimp10s-77.imp"
int ADJ;
// 4378+ ARRP, NN, ND, II, JJ, QQ, R, CDV, UNSCAL, DESC, SC, {%C
// 4379+ LWB, PTYPEPP, JJJ, JJJJ, ADJ
// 4380 %IF STACK#0 %AND FLAG(LEVEL)=0=NMDECS(LEVEL)>>14 %START
#line 4380 "test-new/nrimp10s-77.imp"
if (STACK == 0) goto L_03DA;
#line 4380 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 4380 "test-new/nrimp10s-77.imp"
int tmp;
#line 4380 "test-new/nrimp10s-77.imp"
if (FLAG[LEVEL] != (tmp = 0)) goto L_03DA;
// Double-sided test on 0 (Part II)
#line 4380 "test-new/nrimp10s-77.imp"
if (tmp != (unsigned int)NMDECS[LEVEL] >> 14) goto L_03DA;
#line 4380 "test-new/nrimp10s-77.imp"
}
// 4381 PSF1(STSF,1,N)
#line 4381 "test-new/nrimp10s-77.imp"
PSF1(94, 1, N);
// 4382 NMDECS(LEVEL)=NMDECS(LEVEL)!(N<<14)
#line 4382 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | N << 14;
// 4383 N=N+4
#line 4383 "test-new/nrimp10s-77.imp"
N = N + 4;
// 4384 %FINISH
#line 4384 "test-new/nrimp10s-77.imp"
L_03DA:;
// 4385 %IF STACK=0 %THEN SAVE AUX STACK
#line 4385 "test-new/nrimp10s-77.imp"
if (STACK != 0) goto L_03DB;
#line 4385 "test-new/nrimp10s-77.imp"
SAVEAUXSTACK();
#line 4385 "test-new/nrimp10s-77.imp"
L_03DB:;
// 4386 ARRP=2*FORMAT+1; ARR=ARRP; PACK(PTYPEP)
#line 4386 "test-new/nrimp10s-77.imp"
ARRP = 2 * FORMAT + 1;
#line 4386 "test-new/nrimp10s-77.imp"
ARR = ARRP;
#line 4386 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPEP);
// 4387 ELSIZE=ACC
#line 4387 "test-new/nrimp10s-77.imp"
ELSIZE = ACC;
// 4388 %IF TYPE>2 %OR (TYPE=1 %AND PREC=4) %THEN UNSCAL=1 %AND SC=3 %ELSE UNSCAL=0 %AND SC=PREC
#line 4388 "test-new/nrimp10s-77.imp"
if (TYPE > 2) goto L_03C3;
#line 4388 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_03DC;
#line 4388 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_03DC;
#line 4388 "test-new/nrimp10s-77.imp"
L_03C3:;
#line 4388 "test-new/nrimp10s-77.imp"
UNSCAL = 1;
#line 4388 "test-new/nrimp10s-77.imp"
SC = 3;
#line 4388 "test-new/nrimp10s-77.imp"
goto L_03DD;
#line 4388 "test-new/nrimp10s-77.imp"
L_03DC:;
#line 4388 "test-new/nrimp10s-77.imp"
UNSCAL = 0;
#line 4388 "test-new/nrimp10s-77.imp"
SC = PREC;
#line 4388 "test-new/nrimp10s-77.imp"
L_03DD:;
// 4389 DESC=SC<<27!UNSCAL<<25!(1-PARMARR)<<24;! ARRAY DESCRIPTOR SKELETON
#line 4389 "test-new/nrimp10s-77.imp"
DESC = SC << 27 | UNSCAL << 25 | 1 - PARMARR << 24;
// 4390 %IF PREC=4 %THEN DESC=16_58000002
#line 4390 "test-new/nrimp10s-77.imp"
if (PREC != 4) goto L_03DE;
#line 4390 "test-new/nrimp10s-77.imp"
DESC = 1476395010;
#line 4390 "test-new/nrimp10s-77.imp"
L_03DE:;
// 4391 START:NN=1; P=P+1; ! NO OF NAMES IN NAMELIST
#line 4391 "test-new/nrimp10s-77.imp"
U_1028:;
#line 4391 "test-new/nrimp10s-77.imp"
NN = 1;
#line 4391 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4392 PP=P; CDV=0; PTYPEPP=PTYPEP
#line 4392 "test-new/nrimp10s-77.imp"
PP = P;
#line 4392 "test-new/nrimp10s-77.imp"
CDV = 0;
#line 4392 "test-new/nrimp10s-77.imp"
PTYPEPP = PTYPEP;
// 4393 P=P+3 %AND NN=NN+1 %WHILE A(P+2)=1
#line 4393 "test-new/nrimp10s-77.imp"
L_03DF:;
#line 4393 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 1) goto L_03E0;
#line 4393 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 4393 "test-new/nrimp10s-77.imp"
NN = NN + 1;
#line 4393 "test-new/nrimp10s-77.imp"
goto L_03DF;
#line 4393 "test-new/nrimp10s-77.imp"
L_03E0:;
// 4394 P=P+3
#line 4394 "test-new/nrimp10s-77.imp"
P = P + 3;
// 4395 DVDISP=DOPE VECTOR(TYPE,ELSIZE,1,FROMAR2(PP),TOTSIZE,LWB)
#line 4395 "test-new/nrimp10s-77.imp"
DVDISP = DOPEVECTOR(TYPE, ELSIZE, 1, FROMAR2(PP), /*?*/ &TOTSIZE, /*?*/ &LWB);
// 4396 ND=J
#line 4396 "test-new/nrimp10s-77.imp"
ND = J;
// 4397 ->CONSTDV %UNLESS DVDISP=-1
#line 4397 "test-new/nrimp10s-77.imp"
if (DVDISP == -1) goto L_03E1;
#line 4397 "test-new/nrimp10s-77.imp"
goto U_102E;
#line 4397 "test-new/nrimp10s-77.imp"
L_03E1:;
// 4398 ! NORMAL CASE - PLANT CODE TO SET UP DOPE-VECTOR AT RUN TIME
// 4399
// 4400 DVF=0; TOTSIZE=16_FFFF
#line 4400 "test-new/nrimp10s-77.imp"
DVF = 0;
#line 4400 "test-new/nrimp10s-77.imp"
TOTSIZE = 65535;
// 4401 DVDISP=N; ! DVDISP IS D-V POSITION
#line 4401 "test-new/nrimp10s-77.imp"
DVDISP = N;
// 4402 N=N+12*ND+12; ! CLAIM SPACE FOR THE D-V
#line 4402 "test-new/nrimp10s-77.imp"
N = N + 12 * ND + 12;
// 4403 FAULT(37,0) %IF ND>12; ! TOO MANY DIMENSIONS
#line 4403 "test-new/nrimp10s-77.imp"
if (ND <= 12) goto L_03E2;
#line 4403 "test-new/nrimp10s-77.imp"
FAULT(37, 0);
#line 4403 "test-new/nrimp10s-77.imp"
L_03E2:;
// 4404 D0=5<<27!3*ND; D1=12; ! DESCPTR FOR DV
#line 4404 "test-new/nrimp10s-77.imp"
D0 = 5 << 27 | 3 * ND;
#line 4404 "test-new/nrimp10s-77.imp"
D1 = 12;
// 4405 STORE CONST(JJ,8,ADDR(D0))
#line 4405 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &JJ, 8, _imp_ADDR(/*?*/ &D0));
// 4406 PF1(LD,0,PC,JJ)
#line 4406 "test-new/nrimp10s-77.imp"
PF1(120, 0, 4, JJ);
// 4407 PSF1(STD,1,DVDISP)
#line 4407 "test-new/nrimp10s-77.imp"
PSF1(88, 1, DVDISP);
// 4408 GRUSE(DR)=0
#line 4408 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 4409
// 4410 %IF UNSCAL=0 %THEN JJ=1 %ELSE JJ=ELSIZE
#line 4410 "test-new/nrimp10s-77.imp"
if (UNSCAL != 0) goto L_03E3;
#line 4410 "test-new/nrimp10s-77.imp"
JJ = 1;
#line 4410 "test-new/nrimp10s-77.imp"
goto L_03E4;
#line 4410 "test-new/nrimp10s-77.imp"
L_03E3:;
#line 4410 "test-new/nrimp10s-77.imp"
JJ = ELSIZE;
#line 4410 "test-new/nrimp10s-77.imp"
L_03E4:;
// 4411 PSF1(LSS,0,JJ); ! M1 THE FIRST MULTIPLIER
#line 4411 "test-new/nrimp10s-77.imp"
PSF1(98, 0, JJ);
// 4412 GRUSE(ACCR)=0
#line 4412 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 4413 %CYCLE II=ND,-1,1
#line 4413 "test-new/nrimp10s-77.imp"
// %for II = ND, -1, 1 %cycle
#line 4413 "test-new/nrimp10s-77.imp"
{
int _control, _initial = ND, _increment = -1, _final = 1;
#line 4413 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle II = ND, -1, 1");
_control = II = _initial - _increment;
#line 4413 "test-new/nrimp10s-77.imp"
L_03E5:
#line 4413 "test-new/nrimp10s-77.imp"
if (II != _control) _imp_signal(4, 2, 0, "Corrupt control variable II");
#line 4413 "test-new/nrimp10s-77.imp"
if (II == _final) goto L_03E6;
#line 4413 "test-new/nrimp10s-77.imp"
_control += _increment;
II -= 1;
// 4414 P=P+1
#line 4414 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4415 QQ=DVDISP+12*II; ! TRIPLE FOR IITH DIMENSION
#line 4415 "test-new/nrimp10s-77.imp"
QQ = DVDISP + 12 * II;
// 4416 PSF1(ST,1,QQ+4); ! STORE MULTIPLIER
#line 4416 "test-new/nrimp10s-77.imp"
PSF1(72, 1, QQ + 4);
// 4417 CSEXP(ACCR,16_51); ! LOWER BOUND
#line 4417 "test-new/nrimp10s-77.imp"
CSEXP(0, 81);
// 4418 %IF ND=1 %AND PTYPEP&7<=3 %AND FORMAT=0 %AND GRUSE(ACCR)=5 %AND GRINF1(ACCR)=0 %THEN PTYPEPP=PTYPEPP+256
#line 4418 "test-new/nrimp10s-77.imp"
if (ND != 1) goto L_03E8;
#line 4418 "test-new/nrimp10s-77.imp"
if (PTYPEP & 7 > 3) goto L_03E8;
#line 4418 "test-new/nrimp10s-77.imp"
if (FORMAT != 0) goto L_03E8;
#line 4418 "test-new/nrimp10s-77.imp"
if (GRUSE[0] != 5) goto L_03E8;
#line 4418 "test-new/nrimp10s-77.imp"
if (GRINF1[0] != 0) goto L_03E8;
#line 4418 "test-new/nrimp10s-77.imp"
PTYPEPP = PTYPEPP + 256;
#line 4418 "test-new/nrimp10s-77.imp"
L_03E8:;
// 4419 PSF1(ST,1,QQ); ! STORED IN DV
#line 4419 "test-new/nrimp10s-77.imp"
PSF1(72, 1, QQ);
// 4420 CSEXP(ACCR,16_51); ! UPPER BOUND
#line 4420 "test-new/nrimp10s-77.imp"
CSEXP(0, 81);
// 4421 PSF1(ISB,1,QQ)
#line 4421 "test-new/nrimp10s-77.imp"
PSF1(226, 1, QQ);
// 4422 GRUSE(ACCR)=0
#line 4422 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 4423 %IF COMPILER=0 %OR PARMARR#0 %START
#line 4423 "test-new/nrimp10s-77.imp"
if (COMPILER == 0) goto L_03E9;
#line 4423 "test-new/nrimp10s-77.imp"
if (PARMARR == 0) goto L_03EA;
#line 4423 "test-new/nrimp10s-77.imp"
L_03E9:;
// 4424 PF3(JAF,6,0,3); ! JUMP UNLESS NEGATIVE
#line 4424 "test-new/nrimp10s-77.imp"
PF3(6, 6, 0, 3);
// 4425 PSF1(LSS,0,-1); ! SET UP -1 (ENSURES 0 ELEMENTS
#line 4425 "test-new/nrimp10s-77.imp"
PSF1(98, 0, -1);
// 4426 %FINISH
#line 4426 "test-new/nrimp10s-77.imp"
L_03EA:;
// 4427 PSF1(IAD,0,1); ! CONVERTED TO RANGE
#line 4427 "test-new/nrimp10s-77.imp"
PSF1(224, 0, 1);
// 4428 PSF1(IMY,1,QQ+4); ! RANGE*MULTIPLIER
#line 4428 "test-new/nrimp10s-77.imp"
PSF1(234, 1, QQ + 4);
// 4429 PSF1(ST,1,QQ+8); ! AND STORED IN DV
#line 4429 "test-new/nrimp10s-77.imp"
PSF1(72, 1, QQ + 8);
// 4430 %REPEAT
#line 4430 "test-new/nrimp10s-77.imp"
goto L_03E5;
#line 4430 "test-new/nrimp10s-77.imp"
}
#line 4430 "test-new/nrimp10s-77.imp"
L_03E6:;
// 4431 P=P+1
#line 4431 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4432 %IF UNSCAL=0 %AND ELSIZE#1 %THEN PSF1(IMY,0,ELSIZE)
#line 4432 "test-new/nrimp10s-77.imp"
if (UNSCAL != 0) goto L_03EB;
#line 4432 "test-new/nrimp10s-77.imp"
if (ELSIZE == 1) goto L_03EB;
#line 4432 "test-new/nrimp10s-77.imp"
PSF1(234, 0, ELSIZE);
#line 4432 "test-new/nrimp10s-77.imp"
L_03EB:;
// 4433 PSF1(ST,1,DVDISP+8)
#line 4433 "test-new/nrimp10s-77.imp"
PSF1(72, 1, DVDISP + 8);
// 4434 SNDISP=0; ! DV NOT AVAILABLE AT COMPILETIME
#line 4434 "test-new/nrimp10s-77.imp"
SNDISP = 0;
// 4435 ->DECL
#line 4435 "test-new/nrimp10s-77.imp"
goto U_102F;
// 4436 CONSTDV: ! ONE DIMENSION - CONSTANT BOUNDS
#line 4436 "test-new/nrimp10s-77.imp"
U_102E:;
// 4437 DVF=1; CDV=1
#line 4437 "test-new/nrimp10s-77.imp"
DVF = 1;
#line 4437 "test-new/nrimp10s-77.imp"
CDV = 1;
// 4438 %IF ND=1 %AND LWB=0 %AND PTYPEP&15<=3 %AND FORMAT=0 %THEN PTYPEPP=PTYPEP+256
#line 4438 "test-new/nrimp10s-77.imp"
if (ND != 1) goto L_03EC;
#line 4438 "test-new/nrimp10s-77.imp"
if (LWB != 0) goto L_03EC;
#line 4438 "test-new/nrimp10s-77.imp"
if (PTYPEP & 15 > 3) goto L_03EC;
#line 4438 "test-new/nrimp10s-77.imp"
if (FORMAT != 0) goto L_03EC;
#line 4438 "test-new/nrimp10s-77.imp"
PTYPEPP = PTYPEP + 256;
#line 4438 "test-new/nrimp10s-77.imp"
L_03EC:;
// 4439 ! SET ARR=2 IF LWB=ZERO
// 4440 SNDISP=(DVDISP&16_FFFFFF)>>2
#line 4440 "test-new/nrimp10s-77.imp"
SNDISP = (unsigned int)(DVDISP & 16777215) >> 2;
// 4441 DECL: ! MAKE DECLN - BOTH WAYS
#line 4441 "test-new/nrimp10s-77.imp"
U_102F:;
// 4442 J=ND
#line 4442 "test-new/nrimp10s-77.imp"
J = ND;
// 4443 ODD ALIGN
#line 4443 "test-new/nrimp10s-77.imp"
ODDALIGN();
// 4444 PTYPE=PTYPEPP; UNPACK
#line 4444 "test-new/nrimp10s-77.imp"
PTYPE = PTYPEPP;
#line 4444 "test-new/nrimp10s-77.imp"
UNPACK();
// 4445 %IF DVF#0 %THEN %START; ! ARRAY IS STRING OF LOCALS
#line 4445 "test-new/nrimp10s-77.imp"
if (DVF == 0) goto L_03ED;
// 4446 R=TOTSIZE
#line 4446 "test-new/nrimp10s-77.imp"
R = TOTSIZE;
// 4447 %IF UNSCAL=0 %THEN R=R//ELSIZE
#line 4447 "test-new/nrimp10s-77.imp"
if (UNSCAL != 0) goto L_03EE;
#line 4447 "test-new/nrimp10s-77.imp"
R = ((long)R / (long)ELSIZE);
#line 4447 "test-new/nrimp10s-77.imp"
L_03EE:;
// 4448 D0=DESC
#line 4448 "test-new/nrimp10s-77.imp"
D0 = DESC;
// 4449 D0=D0!R %UNLESS PREC=4
#line 4449 "test-new/nrimp10s-77.imp"
if (PREC == 4) goto L_03EF;
#line 4449 "test-new/nrimp10s-77.imp"
D0 = D0 | R;
#line 4449 "test-new/nrimp10s-77.imp"
L_03EF:;
// 4450 STORE CONST(D1,4,ADDR(D0))
#line 4450 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &D1, 4, _imp_ADDR(/*?*/ &D0));
// 4451 PF1(LB,0,PC,D1)
#line 4451 "test-new/nrimp10s-77.imp"
PF1(122, 0, 4, D1);
// 4452 %FINISH %ELSE %START
#line 4452 "test-new/nrimp10s-77.imp"
goto L_03F0;
#line 4452 "test-new/nrimp10s-77.imp"
L_03ED:;
// 4453 STORE CONST(D1,4,ADDR(DESC))
#line 4453 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &D1, 4, _imp_ADDR(/*?*/ &DESC));
// 4454 PF1(LB,0,PC,D1)
#line 4454 "test-new/nrimp10s-77.imp"
PF1(122, 0, 4, D1);
// 4455 PSF1(ADB,1,DVDISP+20) %UNLESS PREC=4
#line 4455 "test-new/nrimp10s-77.imp"
if (PREC == 4) goto L_03F1;
#line 4455 "test-new/nrimp10s-77.imp"
PSF1(32, 1, DVDISP + 20);
#line 4455 "test-new/nrimp10s-77.imp"
L_03F1:;
// 4456 %FINISH
#line 4456 "test-new/nrimp10s-77.imp"
L_03F0:;
// 4457 %IF DVF#0 %THEN QQ=PC %ELSE QQ=LNB
#line 4457 "test-new/nrimp10s-77.imp"
if (DVF == 0) goto L_03F2;
#line 4457 "test-new/nrimp10s-77.imp"
QQ = 4;
#line 4457 "test-new/nrimp10s-77.imp"
goto L_03F3;
#line 4457 "test-new/nrimp10s-77.imp"
L_03F2:;
#line 4457 "test-new/nrimp10s-77.imp"
QQ = 2;
#line 4457 "test-new/nrimp10s-77.imp"
L_03F3:;
// 4458 PSORLF1(LDRL,0,QQ,DVDISP)
#line 4458 "test-new/nrimp10s-77.imp"
PSORLF1(112, 0, QQ, DVDISP);
// 4459 GRUSE(BREG)=0; GRUSE(DR)=0
#line 4459 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
#line 4459 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 4460 %CYCLE JJJ=0,1,NN-1; ! DOWN NAMELIST
#line 4460 "test-new/nrimp10s-77.imp"
// %for JJJ = 0, 1, NN - 1 %cycle
#line 4460 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = NN - 1;
#line 4460 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle JJJ = 0, 1, NN - 1");
_control = JJJ = _initial - _increment;
#line 4460 "test-new/nrimp10s-77.imp"
L_03F4:
#line 4460 "test-new/nrimp10s-77.imp"
if (JJJ != _control) _imp_signal(4, 2, 0, "Corrupt control variable JJJ");
#line 4460 "test-new/nrimp10s-77.imp"
if (JJJ == _final) goto L_03F5;
#line 4460 "test-new/nrimp10s-77.imp"
_control += _increment;
JJJ += _increment;
// 4461 PSF1(STB,1,N+16*JJJ); ! ARRAY BOUND
#line 4461 "test-new/nrimp10s-77.imp"
PSF1(90, 1, N + 16 * JJJ);
// 4462 PSF1(STD,1,N+8+16*JJJ); ! DV POINTER
#line 4462 "test-new/nrimp10s-77.imp"
PSF1(88, 1, N + 8 + 16 * JJJ);
// 4463 %REPEAT
#line 4463 "test-new/nrimp10s-77.imp"
goto L_03F4;
#line 4463 "test-new/nrimp10s-77.imp"
}
#line 4463 "test-new/nrimp10s-77.imp"
L_03F5:;
// 4464 %IF PARMARR=0 %AND PARMCHK=0 %AND ND=1 %AND TYPE<=3 %AND PTYPEPP&16_F00#16_200 %THEN ADJ=1 %ELSE ADJ=0
#line 4464 "test-new/nrimp10s-77.imp"
if (PARMARR != 0) goto L_03F6;
#line 4464 "test-new/nrimp10s-77.imp"
if (PARMCHK != 0) goto L_03F6;
#line 4464 "test-new/nrimp10s-77.imp"
if (ND != 1) goto L_03F6;
#line 4464 "test-new/nrimp10s-77.imp"
if (TYPE > 3) goto L_03F6;
#line 4464 "test-new/nrimp10s-77.imp"
if (PTYPEPP & 3840 == 512) goto L_03F6;
#line 4464 "test-new/nrimp10s-77.imp"
ADJ = 1;
#line 4464 "test-new/nrimp10s-77.imp"
goto L_03F7;
#line 4464 "test-new/nrimp10s-77.imp"
L_03F6:;
#line 4464 "test-new/nrimp10s-77.imp"
ADJ = 0;
#line 4464 "test-new/nrimp10s-77.imp"
L_03F7:;
// 4465 %CYCLE JJJ=0,1,NN-1; ! DOWN NAMELIST
#line 4465 "test-new/nrimp10s-77.imp"
// %for JJJ = 0, 1, NN - 1 %cycle
#line 4465 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = NN - 1;
#line 4465 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle JJJ = 0, 1, NN - 1");
_control = JJJ = _initial - _increment;
#line 4465 "test-new/nrimp10s-77.imp"
L_03F8:
#line 4465 "test-new/nrimp10s-77.imp"
if (JJJ != _control) _imp_signal(4, 2, 0, "Corrupt control variable JJJ");
#line 4465 "test-new/nrimp10s-77.imp"
if (JJJ == _final) goto L_03F9;
#line 4465 "test-new/nrimp10s-77.imp"
_control += _increment;
JJJ += _increment;
// 4466 %IF ADJ#0 %START; ! ADJUST DESC
#line 4466 "test-new/nrimp10s-77.imp"
if (ADJ == 0) goto L_03FA;
// 4467 %IF STACK#0 %START; ! ARRAY ON AUTOMATIC STACK
#line 4467 "test-new/nrimp10s-77.imp"
if (STACK == 0) goto L_03FB;
// 4468 PF1(STSF,0,BREG,0); ! CURRENT SF TO B
#line 4468 "test-new/nrimp10s-77.imp"
PF1(94, 0, 7, 0);
// 4469 %IF DVF#0 %THEN PSF1(SBB,0,LWB*ELSIZE) %ELSE %START
#line 4469 "test-new/nrimp10s-77.imp"
if (DVF == 0) goto L_03FC;
#line 4469 "test-new/nrimp10s-77.imp"
PSF1(34, 0, LWB * ELSIZE);
#line 4469 "test-new/nrimp10s-77.imp"
goto L_03FD;
#line 4469 "test-new/nrimp10s-77.imp"
L_03FC:;
// 4470 %IF ELSIZE=1 %THEN PSF1(SBB,1,DVDISP+12) %ELSESTART
#line 4470 "test-new/nrimp10s-77.imp"
if (ELSIZE != 1) goto L_03FE;
#line 4470 "test-new/nrimp10s-77.imp"
PSF1(34, 1, DVDISP + 12);
#line 4470 "test-new/nrimp10s-77.imp"
goto L_03FF;
#line 4470 "test-new/nrimp10s-77.imp"
L_03FE:;
// 4471 PSF1(SLB,1,DVDISP+12)
#line 4471 "test-new/nrimp10s-77.imp"
PSF1(82, 1, DVDISP + 12);
// 4472 PSF1(MYB,0,ELSIZE)
#line 4472 "test-new/nrimp10s-77.imp"
PSF1(42, 0, ELSIZE);
// 4473 PF1(SLB,0,TOS,0)
#line 4473 "test-new/nrimp10s-77.imp"
PF1(82, 0, 6, 0);
// 4474 PF1(SBB,0,TOS,0)
#line 4474 "test-new/nrimp10s-77.imp"
PF1(34, 0, 6, 0);
// 4475 %FINISH
#line 4475 "test-new/nrimp10s-77.imp"
L_03FF:;
// 4476 %FINISH
#line 4476 "test-new/nrimp10s-77.imp"
L_03FD:;
// 4477 PSF1(STB,1,N+4)
#line 4477 "test-new/nrimp10s-77.imp"
PSF1(90, 1, N + 4);
// 4478 GRUSE(BREG)=0
#line 4478 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 4479 %FINISH %ELSE %START; ! ARRAY ON AUX STACK
#line 4479 "test-new/nrimp10s-77.imp"
goto L_0400;
#line 4479 "test-new/nrimp10s-77.imp"
L_03FB:;
// 4480 %IF DVF#0 %START; ! CONST DOPE VECTOR
#line 4480 "test-new/nrimp10s-77.imp"
if (DVF == 0) goto L_0401;
// 4481 %UNLESS GRUSE(ACCR)=11 %%START
#line 4481 "test-new/nrimp10s-77.imp"
if (GRUSE[0] == 11) goto L_0402;
// 4482 PSF1(LSS,2,AUXSBASE(LEVEL))
#line 4482 "test-new/nrimp10s-77.imp"
PSF1(98, 2, AUXSBASE[LEVEL]);
// 4483 GRUSE(ACCR)=11; GRINF1(ACCR)=0
#line 4483 "test-new/nrimp10s-77.imp"
GRUSE[0] = 11;
#line 4483 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 4484 %FINISH
#line 4484 "test-new/nrimp10s-77.imp"
L_0402:;
// 4485 JJJJ=LWB*ELSIZE-GRINF1(ACCR)
#line 4485 "test-new/nrimp10s-77.imp"
JJJJ = LWB * ELSIZE - GRINF1[0];
// 4486 PSF1(ISB,0,JJJJ) %UNLESS JJJJ=0
#line 4486 "test-new/nrimp10s-77.imp"
if (JJJJ == 0) goto L_0403;
#line 4486 "test-new/nrimp10s-77.imp"
PSF1(226, 0, JJJJ);
#line 4486 "test-new/nrimp10s-77.imp"
L_0403:;
// 4487 GRINF1(ACCR)=LWB*ELSIZE
#line 4487 "test-new/nrimp10s-77.imp"
GRINF1[0] = LWB * ELSIZE;
// 4488 %FINISH %ELSE %START; ! DYNAMIC ARRAYS
#line 4488 "test-new/nrimp10s-77.imp"
goto L_0404;
#line 4488 "test-new/nrimp10s-77.imp"
L_0401:;
// 4489 %IF GRUSE(ACCR)=11 %AND GRINF1(ACCR)=0 %AND ELSIZE=1 %THEN PSF1(ISB,1,DVDISP+12) %ELSESTART
#line 4489 "test-new/nrimp10s-77.imp"
if (GRUSE[0] != 11) goto L_0405;
#line 4489 "test-new/nrimp10s-77.imp"
if (GRINF1[0] != 0) goto L_0405;
#line 4489 "test-new/nrimp10s-77.imp"
if (ELSIZE != 1) goto L_0405;
#line 4489 "test-new/nrimp10s-77.imp"
PSF1(226, 1, DVDISP + 12);
#line 4489 "test-new/nrimp10s-77.imp"
goto L_0406;
#line 4489 "test-new/nrimp10s-77.imp"
L_0405:;
// 4490 PSF1(LSS,1,DVDISP+12)
#line 4490 "test-new/nrimp10s-77.imp"
PSF1(98, 1, DVDISP + 12);
// 4491 PSF1(IMY,0,ELSIZE) %UNLESS ELSIZE=1
#line 4491 "test-new/nrimp10s-77.imp"
if (ELSIZE == 1) goto L_0407;
#line 4491 "test-new/nrimp10s-77.imp"
PSF1(234, 0, ELSIZE);
#line 4491 "test-new/nrimp10s-77.imp"
L_0407:;
// 4492 PSF1(IRSB,2,AUXSBASE(LEVEL))
#line 4492 "test-new/nrimp10s-77.imp"
PSF1(228, 2, AUXSBASE[LEVEL]);
// 4493 %FINISH
#line 4493 "test-new/nrimp10s-77.imp"
L_0406:;
// 4494 GRUSE(ACCR)=0
#line 4494 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 4495 %FINISH
#line 4495 "test-new/nrimp10s-77.imp"
L_0404:;
// 4496 PSF1(ST,1,N+4)
#line 4496 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N + 4);
// 4497 %FINISH
#line 4497 "test-new/nrimp10s-77.imp"
L_0400:;
// 4498 %FINISH %ELSE %START; ! NO ADJUSTMENT OF DESCRPT
#line 4498 "test-new/nrimp10s-77.imp"
goto L_0408;
#line 4498 "test-new/nrimp10s-77.imp"
L_03FA:;
// 4499 %IF STACK#0 %THEN PSF1(STSF,1,N+4) %ELSE %START
#line 4499 "test-new/nrimp10s-77.imp"
if (STACK == 0) goto L_0409;
#line 4499 "test-new/nrimp10s-77.imp"
PSF1(94, 1, N + 4);
#line 4499 "test-new/nrimp10s-77.imp"
goto L_040A;
#line 4499 "test-new/nrimp10s-77.imp"
L_0409:;
// 4500 PSF1(LSS,2,AUXSBASE(LEVEL)) %UNLESS GRUSE(ACCR)=11 %AND GRINF1(ACCR)=0
#line 4500 "test-new/nrimp10s-77.imp"
if (GRUSE[0] != 11) goto L_040B;
#line 4500 "test-new/nrimp10s-77.imp"
if (GRINF1[0] == 0) goto L_040C;
#line 4500 "test-new/nrimp10s-77.imp"
L_040B:;
#line 4500 "test-new/nrimp10s-77.imp"
PSF1(98, 2, AUXSBASE[LEVEL]);
#line 4500 "test-new/nrimp10s-77.imp"
L_040C:;
// 4501 PSF1(ST,1,N+4)
#line 4501 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N + 4);
// 4502 GRUSE(ACCR)=11; GRINF1(ACCR)=0
#line 4502 "test-new/nrimp10s-77.imp"
GRUSE[0] = 11;
#line 4502 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 4503 %FINISH
#line 4503 "test-new/nrimp10s-77.imp"
L_040A:;
// 4504 %FINISH
#line 4504 "test-new/nrimp10s-77.imp"
L_0408:;
// 4505
// 4506 ACC=ELSIZE; ! RESET ACC AFTER DV CMPLD
#line 4506 "test-new/nrimp10s-77.imp"
ACC = ELSIZE;
// 4507 KFORM=FINF; ! FORMAT INFORMATION
#line 4507 "test-new/nrimp10s-77.imp"
KFORM = FINF;
// 4508 K=FROM AR2(PP+3*JJJ)
#line 4508 "test-new/nrimp10s-77.imp"
K = FROMAR2(PP + 3 * JJJ);
// 4509 STORE TAG(K,N)
#line 4509 "test-new/nrimp10s-77.imp"
STORETAG(K, N);
// 4510 CLAIM AS %IF FORMAT = 0
#line 4510 "test-new/nrimp10s-77.imp"
if (FORMAT != 0) goto L_040D;
#line 4510 "test-new/nrimp10s-77.imp"
CLAIMAS();
#line 4510 "test-new/nrimp10s-77.imp"
L_040D:;
// 4511 N=N+16
#line 4511 "test-new/nrimp10s-77.imp"
N = N + 16;
// 4512 %REPEAT
#line 4512 "test-new/nrimp10s-77.imp"
goto L_03F8;
#line 4512 "test-new/nrimp10s-77.imp"
}
#line 4512 "test-new/nrimp10s-77.imp"
L_03F9:;
// 4513 P=P+1; ! PAST REST OF ARRAYLIST
#line 4513 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4514 %IF A(P-1)=1 %THEN ->START
#line 4514 "test-new/nrimp10s-77.imp"
if (A[P - 1] != 1) goto L_040E;
#line 4514 "test-new/nrimp10s-77.imp"
goto U_1028;
#line 4514 "test-new/nrimp10s-77.imp"
L_040E:;
// 4515 %RETURN
#line 4515 "test-new/nrimp10s-77.imp"
return;
// 4516 %ROUTINE CLAIM AS
#line 4516 "test-new/nrimp10s-77.imp"
void CLAIMAS(void) {
// 4517 !***********************************************************************
// 4518 !* CLAIM THE SPACE FOR AN ARRAY FROM STACK OR AUX STACK *
// 4519 !***********************************************************************
// 4520 %INTEGER T, B, D,ADJMENT
#line 4520 "test-new/nrimp10s-77.imp"
int T;
#line 4520 "test-new/nrimp10s-77.imp"
int B;
#line 4520 "test-new/nrimp10s-77.imp"
int D;
#line 4520 "test-new/nrimp10s-77.imp"
int ADJMENT;
// 4521 %IF STACK=1 %THEN %START; ! FROM AUTOMATIC STACK
#line 4521 "test-new/nrimp10s-77.imp"
if (STACK != 1) goto L_040F;
// 4522 %IF CDV=1 %THEN %START; ! CONSTANT BOUNDS
#line 4522 "test-new/nrimp10s-77.imp"
if (CDV != 1) goto L_0410;
// 4523 T=(TOTSIZE+3)//4
#line 4523 "test-new/nrimp10s-77.imp"
T = ((long)(TOTSIZE + 3) / (long)4);
// 4524 PSF1(ASF+12*PARMCHK,0,T); ! ASF OR LB
#line 4524 "test-new/nrimp10s-77.imp"
PSF1(110 + 12 * PARMCHK, 0, T);
// 4525 PPJ(0,4) %IF PARMCHK#0
#line 4525 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_0411;
#line 4525 "test-new/nrimp10s-77.imp"
PPJ(0, 4);
#line 4525 "test-new/nrimp10s-77.imp"
L_0411:;
// 4526 %FINISH %ELSE %START; ! DYNAMIC BOUNDS
#line 4526 "test-new/nrimp10s-77.imp"
goto L_0412;
#line 4526 "test-new/nrimp10s-77.imp"
L_0410:;
// 4527 %IF PARMCHK=0 %AND PTYPEP&7<=2 %AND (ELSIZE=4 %OR ELSIZE=8) %START
#line 4527 "test-new/nrimp10s-77.imp"
if (PARMCHK != 0) goto L_0413;
#line 4527 "test-new/nrimp10s-77.imp"
if (PTYPEP & 7 > 2) goto L_0413;
#line 4527 "test-new/nrimp10s-77.imp"
if (ELSIZE == 4) goto L_03D0;
#line 4527 "test-new/nrimp10s-77.imp"
if (ELSIZE != 8) goto L_0413;
#line 4527 "test-new/nrimp10s-77.imp"
L_03D0:;
// 4528 PSF1(ASF,1,DVDISP+20); ! SIZE IN ELEMENTS WORD
#line 4528 "test-new/nrimp10s-77.imp"
PSF1(110, 1, DVDISP + 20);
// 4529 PSF1(ASF,1,DVDISP+20) %IF ELSIZE=8
#line 4529 "test-new/nrimp10s-77.imp"
if (ELSIZE != 8) goto L_0414;
#line 4529 "test-new/nrimp10s-77.imp"
PSF1(110, 1, DVDISP + 20);
#line 4529 "test-new/nrimp10s-77.imp"
L_0414:;
// 4530 %FINISH %ELSE %START
#line 4530 "test-new/nrimp10s-77.imp"
goto L_0415;
#line 4530 "test-new/nrimp10s-77.imp"
L_0413:;
// 4531 PSF1(LSS,1,DVDISP+8); ! ARRAY SIZE BYTES
#line 4531 "test-new/nrimp10s-77.imp"
PSF1(98, 1, DVDISP + 8);
// 4532 PSF1(IAD,0,3) %IF ELSIZE&3#0
#line 4532 "test-new/nrimp10s-77.imp"
if (ELSIZE & 3 == 0) goto L_0416;
#line 4532 "test-new/nrimp10s-77.imp"
PSF1(224, 0, 3);
#line 4532 "test-new/nrimp10s-77.imp"
L_0416:;
// 4533 PSF1(USH,0,-2); ! ARRAY SIZE WORDS
#line 4533 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -2);
// 4534 PF1(ST,0,BREG,0)
#line 4534 "test-new/nrimp10s-77.imp"
PF1(72, 0, 7, 0);
// 4535 FORGET(BREG)
#line 4535 "test-new/nrimp10s-77.imp"
FORGET(7);
// 4536 %IF PARMCHK#0 %THEN PPJ(0,4) %ELSE PF1(ASF,0,BREG,0)
#line 4536 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_0417;
#line 4536 "test-new/nrimp10s-77.imp"
PPJ(0, 4);
#line 4536 "test-new/nrimp10s-77.imp"
goto L_0418;
#line 4536 "test-new/nrimp10s-77.imp"
L_0417:;
#line 4536 "test-new/nrimp10s-77.imp"
PF1(110, 0, 7, 0);
#line 4536 "test-new/nrimp10s-77.imp"
L_0418:;
// 4537 %FINISH
#line 4537 "test-new/nrimp10s-77.imp"
L_0415:;
// 4538 %FINISH
#line 4538 "test-new/nrimp10s-77.imp"
L_0412:;
// 4539 CHECK STOF
#line 4539 "test-new/nrimp10s-77.imp"
CHECKSTOF();
// 4540 %FINISH %ELSE %START
#line 4540 "test-new/nrimp10s-77.imp"
goto L_0419;
#line 4540 "test-new/nrimp10s-77.imp"
L_040F:;
// 4541 %UNLESS GRUSE(ACCR)=11 %AND (GRINF1(ACCR)=0 %OR CDV=1) %START
#line 4541 "test-new/nrimp10s-77.imp"
if (GRUSE[0] != 11) goto L_041A;
#line 4541 "test-new/nrimp10s-77.imp"
if (GRINF1[0] == 0) goto L_041B;
#line 4541 "test-new/nrimp10s-77.imp"
if (CDV == 1) goto L_041B;
#line 4541 "test-new/nrimp10s-77.imp"
L_041A:;
// 4542 PSF1(LSS,2,AUXSBASE(LEVEL))
#line 4542 "test-new/nrimp10s-77.imp"
PSF1(98, 2, AUXSBASE[LEVEL]);
// 4543 GRUSE(ACCR)=11; GRINF1(ACCR)=0
#line 4543 "test-new/nrimp10s-77.imp"
GRUSE[0] = 11;
#line 4543 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 4544 %FINISH
#line 4544 "test-new/nrimp10s-77.imp"
L_041B:;
// 4545 %IF CDV=1 %THEN %START
#line 4545 "test-new/nrimp10s-77.imp"
if (CDV != 1) goto L_041C;
// 4546 ADJMENT=(TOTSIZE+7)&(-8)+GRINF1(ACCR)
#line 4546 "test-new/nrimp10s-77.imp"
ADJMENT = (TOTSIZE + 7 & -8) + GRINF1[0];
// 4547 %IF ADJMENT<16_1FFFF %THEN B=0 %AND D=ADJMENT %ELSE %START
#line 4547 "test-new/nrimp10s-77.imp"
if (ADJMENT >= 131071) goto L_041D;
#line 4547 "test-new/nrimp10s-77.imp"
B = 0;
#line 4547 "test-new/nrimp10s-77.imp"
D = ADJMENT;
#line 4547 "test-new/nrimp10s-77.imp"
goto L_041E;
#line 4547 "test-new/nrimp10s-77.imp"
L_041D:;
// 4548 STORE CONST(D,4,ADDR(ADJMENT))
#line 4548 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &D, 4, _imp_ADDR(/*?*/ &ADJMENT));
// 4549 B=PC
#line 4549 "test-new/nrimp10s-77.imp"
B = 4;
// 4550 %FINISH
#line 4550 "test-new/nrimp10s-77.imp"
L_041E:;
// 4551 %IF ADJ=1 %AND JJJ#NN-1 %AND PARMOPT=0 %THEN GRINF1(ACCR)=ADJMENT %ELSE %START
#line 4551 "test-new/nrimp10s-77.imp"
if (ADJ != 1) goto L_041F;
#line 4551 "test-new/nrimp10s-77.imp"
if (JJJ == NN - 1) goto L_041F;
#line 4551 "test-new/nrimp10s-77.imp"
if (PARMOPT != 0) goto L_041F;
#line 4551 "test-new/nrimp10s-77.imp"
GRINF1[0] = ADJMENT;
#line 4551 "test-new/nrimp10s-77.imp"
goto L_0420;
#line 4551 "test-new/nrimp10s-77.imp"
L_041F:;
// 4552 GRINF1(ACCR)=0
#line 4552 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 4553 PSORLF1(IAD,0,B,D) %UNLESS B=D=0
#line 4553 "test-new/nrimp10s-77.imp"
{
// Double-sided test on D (Part I)
#line 4553 "test-new/nrimp10s-77.imp"
int tmp;
#line 4553 "test-new/nrimp10s-77.imp"
if (B != (tmp = D)) goto L_0421;
// Double-sided test on D (Part II)
#line 4553 "test-new/nrimp10s-77.imp"
if (tmp == 0) goto L_0422;
#line 4553 "test-new/nrimp10s-77.imp"
}
#line 4553 "test-new/nrimp10s-77.imp"
L_0421:;
#line 4553 "test-new/nrimp10s-77.imp"
PSORLF1(224, 0, B, D);
#line 4553 "test-new/nrimp10s-77.imp"
L_0422:;
// 4554 %FINISH
#line 4554 "test-new/nrimp10s-77.imp"
L_0420:;
// 4555 %FINISH %ELSE %START
#line 4555 "test-new/nrimp10s-77.imp"
goto L_0423;
#line 4555 "test-new/nrimp10s-77.imp"
L_041C:;
// 4556 B=LNB; D=DVDISP+8
#line 4556 "test-new/nrimp10s-77.imp"
B = 2;
#line 4556 "test-new/nrimp10s-77.imp"
D = DVDISP + 8;
// 4557 PSF1(IAD,1,D)
#line 4557 "test-new/nrimp10s-77.imp"
PSF1(224, 1, D);
// 4558 %UNLESS ELSIZE&7=0 %START
#line 4558 "test-new/nrimp10s-77.imp"
if (ELSIZE & 7 == 0) goto L_0424;
// 4559 PSF1(IAD,0,7)
#line 4559 "test-new/nrimp10s-77.imp"
PSF1(224, 0, 7);
// 4560 PSF1(AND,0,-8)
#line 4560 "test-new/nrimp10s-77.imp"
PSF1(138, 0, -8);
// 4561 %FINISH
#line 4561 "test-new/nrimp10s-77.imp"
L_0424:;
// 4562 GRINF1(ACCR)=0
#line 4562 "test-new/nrimp10s-77.imp"
GRINF1[0] = 0;
// 4563 %FINISH
#line 4563 "test-new/nrimp10s-77.imp"
L_0423:;
// 4564 PSF1(ST,2,AUXSBASE(LEVEL)) %IF JJJ=NN-1 %OR (ADJ=1 %AND CDV=0)
#line 4564 "test-new/nrimp10s-77.imp"
if (JJJ == NN - 1) goto L_0425;
#line 4564 "test-new/nrimp10s-77.imp"
if (ADJ != 1) goto L_0426;
#line 4564 "test-new/nrimp10s-77.imp"
if (CDV != 0) goto L_0426;
#line 4564 "test-new/nrimp10s-77.imp"
L_0425:;
#line 4564 "test-new/nrimp10s-77.imp"
PSF1(72, 2, AUXSBASE[LEVEL]);
#line 4564 "test-new/nrimp10s-77.imp"
L_0426:;
// 4565 %IF PARMOPT#0 %THEN %START
#line 4565 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_0427;
// 4566 PSF1(ICP,1,AUXSBASE(LEVEL)+16)
#line 4566 "test-new/nrimp10s-77.imp"
PSF1(230, 1, AUXSBASE[LEVEL] + 16);
// 4567 PPJ(2,8)
#line 4567 "test-new/nrimp10s-77.imp"
PPJ(2, 8);
// 4568 %FINISH
#line 4568 "test-new/nrimp10s-77.imp"
L_0427:;
// 4569 %IF PARMCHK#0 %START
#line 4569 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_0428;
// 4570 PF1(LDTB,0,PC,PARAM DES(3))
#line 4570 "test-new/nrimp10s-77.imp"
PF1(116, 0, 4, PARAMDES(3));
// 4571 PSORLF1(LDB,0,B,D)
#line 4571 "test-new/nrimp10s-77.imp"
PSORLF1(118, 0, B, D);
// 4572 PSF1(LDA,1,N+4)
#line 4572 "test-new/nrimp10s-77.imp"
PSF1(114, 1, N + 4);
// 4573 PF2(MVL,1,1,0,0,UNASSPAT&255)
#line 4573 "test-new/nrimp10s-77.imp"
PF2(176, 1, 1, 0, 0, -2122219135 & 255);
// 4574 GRUSE(DR)=0
#line 4574 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 4575 %FINISH
#line 4575 "test-new/nrimp10s-77.imp"
L_0428:;
// 4576 %FINISH
#line 4576 "test-new/nrimp10s-77.imp"
L_0419:;
// 4577 %END
#line 4577 "test-new/nrimp10s-77.imp"
return;
#line 4577 "test-new/nrimp10s-77.imp"
} /* end of CLAIMAS */
// 4578 %END
#line 4578 "test-new/nrimp10s-77.imp"
return;
#line 4578 "test-new/nrimp10s-77.imp"
} /* end of DECLAREARRAYS */
// 4579 ! %ROUTINE TEST NST
// 4580 !!***********************************************************************
// 4581 !!* SEE IF NAME 'K' HAS BEEN DECLARED BEFORE AT THIS LEVEL *
// 4582 !!***********************************************************************
// 4583 ! FNAME=K
// 4584 ! FAULT(7,FNAME) %IF FROM1(TAGS(FNAME))>>8&15=LEVEL
// 4585 ! %END
// 4586 %ROUTINE CLT
#line 4586 "test-new/nrimp10s-77.imp"
void CLT(void) {
// 4587 !***********************************************************************
// 4588 !* DEAL WITH PHRASE TYPE AND SET PREC,TYPE & ACC *
// 4589 !* ONLY PROBLEM IS STRING WHICH HAS OPTIONAL MAX LENGTH ALSO *
// 4590 !* P ON PHRASE TYPE AT ENTRY - TO NEXT PHRASE AT EXIT. *
// 4591 !***********************************************************************
// 4592 %CONSTBYTEINTEGERARRAY TYPEFLAG(1:10)= {%C
#line 4592 "test-new/nrimp10s-77.imp"
const unsigned char TYPEFLAG[10] = {81, 82, 0, 49, 53, 65, 0, 98, 97, 114};
// 4593+ 16_51,16_52,0,16_31,16_35,
// 4594+ 16_41,0,16_62,16_61,16_72;
// 4595 %INTEGER ALT
#line 4595 "test-new/nrimp10s-77.imp"
int ALT;
// 4596 ALT=A(P)
#line 4596 "test-new/nrimp10s-77.imp"
ALT = A[P];
// 4597 TYPE=TYPEFLAG(ALT)
#line 4597 "test-new/nrimp10s-77.imp"
TYPE = TYPEFLAG[ALT - 1];
// 4598 %IF TYPE=0 %THEN P=P+1 %AND TYPE=TYPEFLAG(A(P)+7)
#line 4598 "test-new/nrimp10s-77.imp"
if (TYPE != 0) goto L_0429;
#line 4598 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4598 "test-new/nrimp10s-77.imp"
TYPE = TYPEFLAG[A[P] + 7 - 1];
#line 4598 "test-new/nrimp10s-77.imp"
L_0429:;
// 4599 PREC=TYPE>>4
#line 4599 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)TYPE >> 4;
// 4600 TYPE=TYPE&7
#line 4600 "test-new/nrimp10s-77.imp"
TYPE = TYPE & 7;
// 4601 PREC=6 %IF TYPE=2 %AND ALL LONG#0 %AND PREC<=5;! DEAL WITH '%REALSLONG'
#line 4601 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_042A;
#line 4601 "test-new/nrimp10s-77.imp"
if (ALLLONG == 0) goto L_042A;
#line 4601 "test-new/nrimp10s-77.imp"
if (PREC > 5) goto L_042A;
#line 4601 "test-new/nrimp10s-77.imp"
PREC = 6;
#line 4601 "test-new/nrimp10s-77.imp"
L_042A:;
// 4602 ACC=BYTES(PREC)
#line 4602 "test-new/nrimp10s-77.imp"
ACC = BYTES[PREC];
// 4603 %IF TYPE=5 %THEN %START; ! P<TYPE>='%STRING'
#line 4603 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_042B;
// 4604 %IF A(P+1)=1 %THEN %START;! MAX LENGTH GIVEN
#line 4604 "test-new/nrimp10s-77.imp"
if (A[P + 1] != 1) goto L_042C;
// 4605 P=P+2
#line 4605 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4606 ACC=A(P)+1
#line 4606 "test-new/nrimp10s-77.imp"
ACC = A[P] + 1;
// 4607 %FINISH %ELSE ACC=0 %AND P=P+1
#line 4607 "test-new/nrimp10s-77.imp"
goto L_042D;
#line 4607 "test-new/nrimp10s-77.imp"
L_042C:;
#line 4607 "test-new/nrimp10s-77.imp"
ACC = 0;
#line 4607 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4607 "test-new/nrimp10s-77.imp"
L_042D:;
// 4608 %FINISH
#line 4608 "test-new/nrimp10s-77.imp"
L_042B:;
// 4609 P=P+1
#line 4609 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4610 %END
#line 4610 "test-new/nrimp10s-77.imp"
return;
#line 4610 "test-new/nrimp10s-77.imp"
} /* end of CLT */
// 4611 %ROUTINE CQN(%INTEGER P)
#line 4611 "test-new/nrimp10s-77.imp"
void CQN(int P) {
// 4612 !***********************************************************************
// 4613 !* SET NAM,ARR & ACC FROM ALTERNATIVE OF PHRASE <QNAME'> *
// 4614 !* P<QNAME'>='%ARRAYNAME','%NAME',<%NULL> *
// 4615 !* P POINTS TO THE ANALYSIS RECORD ENTRY AS IS NOT UPDATED *
// 4616 !***********************************************************************
// 4617 %INTEGER I
#line 4617 "test-new/nrimp10s-77.imp"
int I;
// 4618 I=A(P);NAM=0;ARR=0
#line 4618 "test-new/nrimp10s-77.imp"
I = A[P];
#line 4618 "test-new/nrimp10s-77.imp"
NAM = 0;
#line 4618 "test-new/nrimp10s-77.imp"
ARR = 0;
// 4619 %IF I=1 %THEN ARR=1 %AND ACC=16;! ARRAYNAMES
#line 4619 "test-new/nrimp10s-77.imp"
if (I != 1) goto L_042E;
#line 4619 "test-new/nrimp10s-77.imp"
ARR = 1;
#line 4619 "test-new/nrimp10s-77.imp"
ACC = 16;
#line 4619 "test-new/nrimp10s-77.imp"
L_042E:;
// 4620 %IF I<=2 %THEN NAM=1; ! ARRAYNAMES & NAMES
#line 4620 "test-new/nrimp10s-77.imp"
if (I > 2) goto L_042F;
#line 4620 "test-new/nrimp10s-77.imp"
NAM = 1;
#line 4620 "test-new/nrimp10s-77.imp"
L_042F:;
// 4621 %IF I=2 %THEN ACC=8; ! NAMES USE 8-BYTE DESCRIPTOR
#line 4621 "test-new/nrimp10s-77.imp"
if (I != 2) goto L_0430;
#line 4621 "test-new/nrimp10s-77.imp"
ACC = 8;
#line 4621 "test-new/nrimp10s-77.imp"
L_0430:;
// 4622 %END
#line 4622 "test-new/nrimp10s-77.imp"
return;
#line 4622 "test-new/nrimp10s-77.imp"
} /* end of CQN */
// 4623 %ROUTINE CRSPEC (%INTEGER M)
#line 4623 "test-new/nrimp10s-77.imp"
void CRSPEC(int M) {
// 4624 !***********************************************************************
// 4625 !* MODE=0 FOR NORMAL ROUTINE SPEC *
// 4626 !* MODE=1 FOR EXTERNAL(ETC) ROUTINE SPECS XREF NEEDED *
// 4627 !* P ON ENTRY TO P(RT) IN (RT)(MARK)(%SPEC')(NAME)(FPP) *
// 4628 !***********************************************************************
// 4629 %INTEGER KK,JJ,TYPEP,OPHEAD,NPARMS
#line 4629 "test-new/nrimp10s-77.imp"
int KK;
#line 4629 "test-new/nrimp10s-77.imp"
int JJ;
#line 4629 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 4629 "test-new/nrimp10s-77.imp"
int OPHEAD;
#line 4629 "test-new/nrimp10s-77.imp"
int NPARMS;
// 4630 %STRING(34) XNAME
#line 4630 "test-new/nrimp10s-77.imp"
_imp_string34 XNAME;
// 4631 LITL=EXTRN&3
#line 4631 "test-new/nrimp10s-77.imp"
LITL = EXTRN & 3;
// 4632 %IF A(P)=1 %THEN %START; ! P<RT>=%ROUTINE
#line 4632 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0431;
// 4633 TYPEP=LITL<<14!16_1000
#line 4633 "test-new/nrimp10s-77.imp"
TYPEP = LITL << 14 | 4096;
// 4634 P=P+2; ! IGNORING ALT OF P(SPEC')
#line 4634 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4635 %FINISH %ELSE %START; ! P<RT>=<TYPE><FNORMAP>
#line 4635 "test-new/nrimp10s-77.imp"
goto L_0432;
#line 4635 "test-new/nrimp10s-77.imp"
L_0431:;
// 4636 ROUT=1; ARR=0; P=P+1
#line 4636 "test-new/nrimp10s-77.imp"
ROUT = 1;
#line 4636 "test-new/nrimp10s-77.imp"
ARR = 0;
#line 4636 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4637 CLT; NAM=0
#line 4637 "test-new/nrimp10s-77.imp"
CLT();
#line 4637 "test-new/nrimp10s-77.imp"
NAM = 0;
// 4638 %IF A(P)=2 %THEN NAM=2; ! 2 FOR MAP 0 FOR FN
#line 4638 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0433;
#line 4638 "test-new/nrimp10s-77.imp"
NAM = 2;
#line 4638 "test-new/nrimp10s-77.imp"
L_0433:;
// 4639 PACK(TYPEP)
#line 4639 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &TYPEP);
// 4640 P=P+2; ! AGAIN IGNORING ALT OF P(SPEC')
#line 4640 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4641 %FINISH
#line 4641 "test-new/nrimp10s-77.imp"
L_0432:;
// 4642 P=P+4; ! PAST HOLE FOR DECLINKS
#line 4642 "test-new/nrimp10s-77.imp"
P = P + 4;
// 4643 KK=FROM AR2(P)
#line 4643 "test-new/nrimp10s-77.imp"
KK = FROMAR2(P);
// 4644 JJ=0
#line 4644 "test-new/nrimp10s-77.imp"
JJ = 0;
// 4645 P=P+2
#line 4645 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4646 CFPLIST(OPHEAD,NPARMS)
#line 4646 "test-new/nrimp10s-77.imp"
CFPLIST(/*?*/ &OPHEAD, /*?*/ &NPARMS);
// 4647 %IF M=1 %THEN %START
#line 4647 "test-new/nrimp10s-77.imp"
if (M != 1) goto L_0434;
// 4648 XNAME<-STRING(DICTBASE+WORD(KK))
#line 4648 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &XNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *_imp_STRING(DICTBASE + WORD[KK]);
(void *)&tmp;
}),
/*max:*/ 34);
#line 4648 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 34 chars */
#line 4648 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &XNAME) > 34) *_imp_LENGTH((_imp_string *)/*?*/ &XNAME) = 34;
// 4649 %IF EXTRN=1 %THEN XNAME<-"S#".XNAME
#line 4649 "test-new/nrimp10s-77.imp"
if (EXTRN != 1) goto L_0435;
#line 4649 "test-new/nrimp10s-77.imp"
_imp_strncpy(/*?*/ &XNAME, ({
__typeof__(_imp_string255) tmp; /*C*/
tmp = *({
_imp_string255 tmp =
_imp_join((_imp_string *)/*?*/ _imp_str_literal_ptr("S#"), (_imp_string *)/*?*/ &XNAME);
(_imp_string255 *)&tmp;
});
(void *)&tmp;
}),
/*max:*/ 34);
#line 4649 "test-new/nrimp10s-77.imp"
/* truncated copy of no more than 34 chars */
#line 4649 "test-new/nrimp10s-77.imp"
if (*_imp_LENGTH((_imp_string *)/*?*/ &XNAME) > 34) *_imp_LENGTH((_imp_string *)/*?*/ &XNAME) = 34;
#line 4649 "test-new/nrimp10s-77.imp"
L_0435:;
// 4650 CXREF(XNAME,PARMDYNAMIC!(EXTRN//3),2,JJ); ! %STSTEM & %EXTERNAL =STATIC
#line 4650 "test-new/nrimp10s-77.imp"
CXREF(
#line 4650 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string34) tmp = XNAME /*q*/;
(_imp_string255 *)&tmp;
})
#line 4650 "test-new/nrimp10s-77.imp"
,
PARMDYNAMIC | ((long)EXTRN / (long)3), 2, /*?*/ &JJ);
// 4651 ! %DYNAMIC = DYNAMIC
// 4652 %FINISH
#line 4652 "test-new/nrimp10s-77.imp"
L_0434:;
// 4653 %IF M=0 %AND RLEVEL=0 %THEN CODE DES(JJ)
#line 4653 "test-new/nrimp10s-77.imp"
if (M != 0) goto L_0436;
#line 4653 "test-new/nrimp10s-77.imp"
if (RLEVEL != 0) goto L_0436;
#line 4653 "test-new/nrimp10s-77.imp"
CODEDES(/*?*/ &JJ);
#line 4653 "test-new/nrimp10s-77.imp"
L_0436:;
// 4654 J=15-M; PTYPE=TYPEP
#line 4654 "test-new/nrimp10s-77.imp"
J = 15 - M;
#line 4654 "test-new/nrimp10s-77.imp"
PTYPE = TYPEP;
// 4655 KFORM=NPARMS
#line 4655 "test-new/nrimp10s-77.imp"
KFORM = NPARMS;
// 4656 SNDISP=JJ>>16
#line 4656 "test-new/nrimp10s-77.imp"
SNDISP = (unsigned int)JJ >> 16;
// 4657 ACC=JJ&16_FFFF
#line 4657 "test-new/nrimp10s-77.imp"
ACC = JJ & 65535;
// 4658 STORE TAG(KK,OPHEAD)
#line 4658 "test-new/nrimp10s-77.imp"
STORETAG(KK, OPHEAD);
// 4659 %END
#line 4659 "test-new/nrimp10s-77.imp"
return;
#line 4659 "test-new/nrimp10s-77.imp"
} /* end of CRSPEC */
// 4660 %ROUTINE CFPLIST(%INTEGERNAME OPHEAD,NPARMS)
#line 4660 "test-new/nrimp10s-77.imp"
void CFPLIST(int *OPHEAD, int *NPARMS) {
// 4661 !***********************************************************************
// 4662 !* COMPILE A FORMAL PARAMETER PART INTO A LIST OF PARAMETER TYPES *
// 4663 !* P(FPP)='('{(HOLE)(FPDEL)(NAMELIST)(MARK)}*')',0. *
// 4664 !* *
// 4665 !* THE LIST OF PARAMETER LOOKS LIKE:- *
// 4666 !* S1 = PTYPE FOR PARAM<<16! DIMENSION (DIMEN DEDUCED LATER) *
// 4667 !* S2 = ACC <<16 ! SPARE *
// 4668 !* S3 = 0 (RESERVED FOR FPP OF RTS) *
// 4669 !* *
// 4670 !* ON ENTRY P IS AT ALT OF FPP (WHICH MAY BE NULL) *
// 4671 !***********************************************************************
// 4672 %INTEGER OPBOT, PP
#line 4672 "test-new/nrimp10s-77.imp"
int OPBOT;
#line 4672 "test-new/nrimp10s-77.imp"
int PP;
// 4673 OPHEAD=0; OPBOT=0
#line 4673 "test-new/nrimp10s-77.imp"
*OPHEAD = 0;
#line 4673 "test-new/nrimp10s-77.imp"
OPBOT = 0;
// 4674 NPARMS=0; ! ZERO PARAMETERS AS YET
#line 4674 "test-new/nrimp10s-77.imp"
*NPARMS = 0;
// 4675 %WHILE A(P)=1 %CYCLE; ! WHILE SOME(MORE) FPS
#line 4675 "test-new/nrimp10s-77.imp"
L_0437:;
#line 4675 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0438;
// 4676 PP=P+1+FROMAR2(P+1); ! TO NEXT FPDEL
#line 4676 "test-new/nrimp10s-77.imp"
PP = P + 1 + FROMAR2(P + 1);
// 4677 P=P+3; ! TO ALT OF FPDEL
#line 4677 "test-new/nrimp10s-77.imp"
P = P + 3;
// 4678 CFPDEL; ! GET TYPE & ACC FOR NEXT GROUP
#line 4678 "test-new/nrimp10s-77.imp"
CFPDEL();
// 4679 {%UNTIL A(P-1)=2} %CYCLE; ! DOWN <NAMELIST> FOR EACH DEL
#line 4679 "test-new/nrimp10s-77.imp"
L_0439:;
// 4680 BINSERT(OPHEAD,OPBOT,PTYPE<<16,ACC<<16,0)
#line 4680 "test-new/nrimp10s-77.imp"
BINSERT(OPHEAD, /*?*/ &OPBOT, PTYPE << 16, ACC << 16, 0);
// 4681 NPARMS=NPARMS+1
#line 4681 "test-new/nrimp10s-77.imp"
*NPARMS = *NPARMS + 1;
// 4682 P=P+3
#line 4682 "test-new/nrimp10s-77.imp"
P = P + 3;
// 4683 %REPEAT %UNTIL A(P-1)=2; ! DOWN <NAMELIST> FOR EACH DEL
#line 4683 "test-new/nrimp10s-77.imp"
if (A[P - 1] == 2) goto L_043A;
#line 4683 "test-new/nrimp10s-77.imp"
goto L_0439;
#line 4683 "test-new/nrimp10s-77.imp"
L_043A:;
// 4684 P=PP
#line 4684 "test-new/nrimp10s-77.imp"
P = PP;
// 4685 %REPEAT
#line 4685 "test-new/nrimp10s-77.imp"
goto L_0437;
#line 4685 "test-new/nrimp10s-77.imp"
L_0438:;
// 4686 P=P+1
#line 4686 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4687 %END
#line 4687 "test-new/nrimp10s-77.imp"
return;
#line 4687 "test-new/nrimp10s-77.imp"
} /* end of CFPLIST */
// 4688 %ROUTINE CFPDEL
#line 4688 "test-new/nrimp10s-77.imp"
void CFPDEL(void) {
// 4689 !***********************************************************************
// 4690 !* SET UP PTYPE & ACC FOR A FORMAL PARAMETER DEFINITION *
// 4691 !* P<FPDEL>=<TYPE><%QNAME'>, *
// 4692 !* '%RECORD'<%ARRAY'>'%NAME'. *
// 4693 !* (RT)(%NAME')(NAMELIST)(FPP), *
// 4694 !* '%NAME'. *
// 4695 !***********************************************************************
// 4696 %SWITCH FP(1:4)
#line 4696 "test-new/nrimp10s-77.imp"
int FP_index;
#line 4696 "test-new/nrimp10s-77.imp"
int FP_line;
#line 4696 "test-new/nrimp10s-77.imp"
char *FP_file;
#line 4696 "test-new/nrimp10s-77.imp"
static const void *FP[4] = {&&case_FP_missing, &&case_FP_missing, &&case_FP_missing, &&case_FP_missing};
// 4697 %INTEGER FPALT
#line 4697 "test-new/nrimp10s-77.imp"
int FPALT;
// 4698 FPALT=A(P); P=P+1
#line 4698 "test-new/nrimp10s-77.imp"
FPALT = A[P];
#line 4698 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4699 KFORM=0; LITL=0
#line 4699 "test-new/nrimp10s-77.imp"
KFORM = 0;
#line 4699 "test-new/nrimp10s-77.imp"
LITL = 0;
// 4700 ->FP(FPALT)
#line 4700 "test-new/nrimp10s-77.imp"
FP_line = __LINE__;
FP_file = __FILE__;
FP_index = FPALT;
goto case_FP_dispatch;
// 4701 FP(1): ! (TYPE)(%QNAME')
#line 4701 "test-new/nrimp10s-77.imp"
case_FP_1:;
// 4702 ROUT=0; CLT
#line 4702 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 4702 "test-new/nrimp10s-77.imp"
CLT();
// 4703 CQN(P)
#line 4703 "test-new/nrimp10s-77.imp"
CQN(P);
// 4704 FAULT(70,0) %IF TYPE=5 %AND ACC=0
#line 4704 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_043C;
#line 4704 "test-new/nrimp10s-77.imp"
if (ACC != 0) goto L_043C;
#line 4704 "test-new/nrimp10s-77.imp"
FAULT(70, 0);
#line 4704 "test-new/nrimp10s-77.imp"
L_043C:;
// 4705 P=P+1
#line 4705 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4706 ->PK
#line 4706 "test-new/nrimp10s-77.imp"
goto U_1018;
// 4707 FP(2): ! RECORD(%ARRAY')%NAME
#line 4707 "test-new/nrimp10s-77.imp"
case_FP_2:;
// 4708 ARR=2-A(P); ROUT=0
#line 4708 "test-new/nrimp10s-77.imp"
ARR = 2 - A[P];
#line 4708 "test-new/nrimp10s-77.imp"
ROUT = 0;
// 4709 ACC=8+8*ARR; TYPE=3; PREC=3
#line 4709 "test-new/nrimp10s-77.imp"
ACC = 8 + 8 * ARR;
#line 4709 "test-new/nrimp10s-77.imp"
TYPE = 3;
#line 4709 "test-new/nrimp10s-77.imp"
PREC = 3;
// 4710 NAM=1; P=P+1; ->PK
#line 4710 "test-new/nrimp10s-77.imp"
NAM = 1;
#line 4710 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4710 "test-new/nrimp10s-77.imp"
goto U_1018;
// 4711 FP(3): ! (RT)(%NAME')(NAMELIST)(FPP)
#line 4711 "test-new/nrimp10s-77.imp"
case_FP_3:;
// 4712 ROUT=1; NAM=1
#line 4712 "test-new/nrimp10s-77.imp"
ROUT = 1;
#line 4712 "test-new/nrimp10s-77.imp"
NAM = 1;
// 4713 ARR=0
#line 4713 "test-new/nrimp10s-77.imp"
ARR = 0;
// 4714 %IF A(P)=1 %THEN %START; ! RT=%ROUITNE
#line 4714 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_043D;
// 4715 TYPE=0; PREC=0
#line 4715 "test-new/nrimp10s-77.imp"
TYPE = 0;
#line 4715 "test-new/nrimp10s-77.imp"
PREC = 0;
// 4716 P=P+2
#line 4716 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4717 %FINISH %ELSE %START
#line 4717 "test-new/nrimp10s-77.imp"
goto L_043E;
#line 4717 "test-new/nrimp10s-77.imp"
L_043D:;
// 4718 P=P+1; CLT; ! RT=(TYPE)(FM)
#line 4718 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4718 "test-new/nrimp10s-77.imp"
CLT();
// 4719 NAM=1
#line 4719 "test-new/nrimp10s-77.imp"
NAM = 1;
// 4720 %IF A(P)=2 %THEN NAM=3; ! 1 FOR FN 3 FOR MAP
#line 4720 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_043F;
#line 4720 "test-new/nrimp10s-77.imp"
NAM = 3;
#line 4720 "test-new/nrimp10s-77.imp"
L_043F:;
// 4721 P=P+2; ! PAST (%NAME') WHICH IS IGNORED
#line 4721 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4722 %FINISH
#line 4722 "test-new/nrimp10s-77.imp"
L_043E:;
// 4723 ACC=16
#line 4723 "test-new/nrimp10s-77.imp"
ACC = 16;
// 4724 ->PK
#line 4724 "test-new/nrimp10s-77.imp"
goto U_1018;
// 4725 FP(4): ! %NAME
#line 4725 "test-new/nrimp10s-77.imp"
case_FP_4:;
// 4726 ACC=8; NAM=1
#line 4726 "test-new/nrimp10s-77.imp"
ACC = 8;
#line 4726 "test-new/nrimp10s-77.imp"
NAM = 1;
// 4727 ROUT=0; TYPE=0
#line 4727 "test-new/nrimp10s-77.imp"
ROUT = 0;
#line 4727 "test-new/nrimp10s-77.imp"
TYPE = 0;
// 4728 ARR=0; PREC=0
#line 4728 "test-new/nrimp10s-77.imp"
ARR = 0;
#line 4728 "test-new/nrimp10s-77.imp"
PREC = 0;
// 4729 PK: PACK(PTYPE)
#line 4729 "test-new/nrimp10s-77.imp"
U_1018:;
#line 4729 "test-new/nrimp10s-77.imp"
PACK(/*?*/ &PTYPE);
// 4730 %END
#line 4730 "test-new/nrimp10s-77.imp"
return;
#line 4730 "test-new/nrimp10s-77.imp"
case_FP_dispatch:
#line 4730 "test-new/nrimp10s-77.imp"
if (FP_index < 1 || FP_index > 4)
_imp_signalf(6, 3, FP_index, "->FP(%d) out of bounds at %s line %d", FP_index, FP_file, FP_line);
#line 4730 "test-new/nrimp10s-77.imp"
goto *FP[FP_index - 1];
#line 4730 "test-new/nrimp10s-77.imp"
case_FP_missing:
_imp_signalf(8, 2, FP_index, "switch jump to undefined label FP(%d): at %s line %d", FP_index, FP_file,
FP_line);
#line 4730 "test-new/nrimp10s-77.imp"
} /* end of CFPDEL */
// 4731 %ROUTINE DIAG POINTER(%INTEGER LEVEL)
#line 4731 "test-new/nrimp10s-77.imp"
void DIAGPOINTER(int LEVEL) {
// 4732 %IF PARMTRACE#0 %THEN %START
#line 4732 "test-new/nrimp10s-77.imp"
if (PARMTRACE == 0) goto L_0440;
// 4733 PUSH(RAL(LEVEL),1,CA,LDB<<24!3<<23)
#line 4733 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &RAL[LEVEL], 1, CA, 118 << 24 | 3 << 23);
// 4734 PF1(LDB,0,0,0)
#line 4734 "test-new/nrimp10s-77.imp"
PF1(118, 0, 0, 0);
// 4735 GRUSE(DR)=0
#line 4735 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 4736 %FINISH
#line 4736 "test-new/nrimp10s-77.imp"
L_0440:;
// 4737 %END
#line 4737 "test-new/nrimp10s-77.imp"
return;
#line 4737 "test-new/nrimp10s-77.imp"
} /* end of DIAGPOINTER */
// 4738 %ROUTINE RHEAD(%INTEGER KK)
#line 4738 "test-new/nrimp10s-77.imp"
void RHEAD(int KK) {
// 4739 !***********************************************************************
// 4740 !* COMPILES CODE FOR BLOCK AND ROUTINE ENTRY *
// 4741 !* KK IS THE RT/FN/MAP NAME (=-1 FOR %BEGIN BLOCKS) *
// 4742 !***********************************************************************
// 4743 %INTEGER W1, W3, INSRN, AT
#line 4743 "test-new/nrimp10s-77.imp"
int W1;
#line 4743 "test-new/nrimp10s-77.imp"
int W3;
#line 4743 "test-new/nrimp10s-77.imp"
int INSRN;
#line 4743 "test-new/nrimp10s-77.imp"
int AT;
// 4744 PUSH(LEVELINF, 0, NMAX<<16!N, 0)
#line 4744 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &LEVELINF, 0, NMAX << 16 | N, 0);
// 4745 LEVEL=LEVEL+1
#line 4745 "test-new/nrimp10s-77.imp"
LEVEL = LEVEL + 1;
// 4746 NMDECS(LEVEL)=0; AUXSBASE(LEVEL)=0
#line 4746 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = 0;
#line 4746 "test-new/nrimp10s-77.imp"
AUXSBASE[LEVEL] = 0;
// 4747 NAMES(LEVEL)=-1
#line 4747 "test-new/nrimp10s-77.imp"
NAMES[LEVEL] = -1;
// 4748 ONINF(LEVEL)=0; ONWORD(LEVEL)=0
#line 4748 "test-new/nrimp10s-77.imp"
ONINF[LEVEL] = 0;
#line 4748 "test-new/nrimp10s-77.imp"
ONWORD[LEVEL] = 0;
// 4749 %IF KK>=0 %THEN %START
#line 4749 "test-new/nrimp10s-77.imp"
if (KK < 0) goto L_0441;
// 4750 RLEVEL=RLEVEL+1; RBASE=RLEVEL
#line 4750 "test-new/nrimp10s-77.imp"
RLEVEL = RLEVEL + 1;
#line 4750 "test-new/nrimp10s-77.imp"
RBASE = RLEVEL;
// 4751 %FINISH
#line 4751 "test-new/nrimp10s-77.imp"
L_0441:;
// 4752 FAULT(34, 0) %IF LEVEL=MAX LEVELS
#line 4752 "test-new/nrimp10s-77.imp"
if (LEVEL != 31) goto L_0442;
#line 4752 "test-new/nrimp10s-77.imp"
FAULT(34, 0);
#line 4752 "test-new/nrimp10s-77.imp"
L_0442:;
// 4753 FAULT(105, 0) %IF LEVEL>MAX LEVELS
#line 4753 "test-new/nrimp10s-77.imp"
if (LEVEL <= 31) goto L_0443;
#line 4753 "test-new/nrimp10s-77.imp"
FAULT(105, 0);
#line 4753 "test-new/nrimp10s-77.imp"
L_0443:;
// 4754 %IF KK>=0 %AND RLEVEL>1 %START;! ROUTINE ENTRY
#line 4754 "test-new/nrimp10s-77.imp"
if (KK < 0) goto L_0444;
#line 4754 "test-new/nrimp10s-77.imp"
if (RLEVEL <= 1) goto L_0444;
// 4755 COPY TAG(KK); JJ=K; ! LIST OF JUMPS
#line 4755 "test-new/nrimp10s-77.imp"
COPYTAG(KK);
#line 4755 "test-new/nrimp10s-77.imp"
JJ = K;
// 4756 J=MIDCELL
#line 4756 "test-new/nrimp10s-77.imp"
J = MIDCELL;
// 4757 %IF J=0 %AND LEVEL>2 %START;! REPLACE 'NOT USED' BIT
#line 4757 "test-new/nrimp10s-77.imp"
if (J != 0) goto L_0445;
#line 4757 "test-new/nrimp10s-77.imp"
if (LEVEL <= 2) goto L_0445;
// 4758 REPLACE1(TAGS(KK), FROM1(TAGS(KK))&16_FFFF3FFF)
#line 4758 "test-new/nrimp10s-77.imp"
REPLACE1(TAGS[KK], FROM1(TAGS[KK]) & -49153);
// 4759 %FINISH
#line 4759 "test-new/nrimp10s-77.imp"
L_0445:;
// 4760 !
// 4761 ! NOW FILL ANY JUMPS TO THIS ROUTINE PLANTED SINCE
// 4762 ! THE ROUTINESPEC WAS COMPILED. SEE ALSO 'RT JUMP'
// 4763 !
// 4764 %WHILE J#0 %CYCLE
#line 4764 "test-new/nrimp10s-77.imp"
L_0446:;
#line 4764 "test-new/nrimp10s-77.imp"
if (J == 0) goto L_0447;
// 4765 POP(J, INSRN, AT, W1)
#line 4765 "test-new/nrimp10s-77.imp"
POP(/*?*/ &J, /*?*/ &INSRN, /*?*/ &AT, /*?*/ &W1);
// 4766 W3=CA-AT
#line 4766 "test-new/nrimp10s-77.imp"
W3 = CA - AT;
// 4767 W3=W3//2 %IF INSRN>>25=CALL>>1
#line 4767 "test-new/nrimp10s-77.imp"
if ((unsigned int)INSRN >> 25 != (unsigned int)30 >> 1) goto L_0448;
#line 4767 "test-new/nrimp10s-77.imp"
W3 = ((long)W3 / (long)2);
#line 4767 "test-new/nrimp10s-77.imp"
L_0448:;
// 4768 INSRN=INSRN+W3
#line 4768 "test-new/nrimp10s-77.imp"
INSRN = INSRN + W3;
// 4769 PLUG(1, AT, INSRN,4)
#line 4769 "test-new/nrimp10s-77.imp"
PLUG(1, AT, INSRN, 4);
// 4770 %REPEAT
#line 4770 "test-new/nrimp10s-77.imp"
goto L_0446;
#line 4770 "test-new/nrimp10s-77.imp"
L_0447:;
// 4771 REPLACE2(TAGS(KK), CA); ! NOTE ADDR FOR FUTURE CALLS
#line 4771 "test-new/nrimp10s-77.imp"
REPLACE2(TAGS[KK], CA);
// 4772 %FINISH
#line 4772 "test-new/nrimp10s-77.imp"
L_0444:;
// 4773 %IF KK>=0 %AND RLEVEL=1 %THEN DIAG POINTER(LEVEL) %AND PSF1(STD,1,12)
#line 4773 "test-new/nrimp10s-77.imp"
if (KK < 0) goto L_0449;
#line 4773 "test-new/nrimp10s-77.imp"
if (RLEVEL != 1) goto L_0449;
#line 4773 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL);
#line 4773 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
#line 4773 "test-new/nrimp10s-77.imp"
L_0449:;
// 4774 %IF KK<0 %THEN W3=0 %ELSE W3=WORD(KK)
#line 4774 "test-new/nrimp10s-77.imp"
if (KK >= 0) goto L_044A;
#line 4774 "test-new/nrimp10s-77.imp"
W3 = 0;
#line 4774 "test-new/nrimp10s-77.imp"
goto L_044B;
#line 4774 "test-new/nrimp10s-77.imp"
L_044A:;
#line 4774 "test-new/nrimp10s-77.imp"
W3 = WORD[KK];
#line 4774 "test-new/nrimp10s-77.imp"
L_044B:;
// 4775 L(LEVEL)=LINE; M(LEVEL)=W3
#line 4775 "test-new/nrimp10s-77.imp"
L[LEVEL] = LINE;
#line 4775 "test-new/nrimp10s-77.imp"
M[LEVEL] = W3;
// 4776 FLAG(LEVEL)=PTYPE; ! CURRENT BLOCK TYPE MARKER
#line 4776 "test-new/nrimp10s-77.imp"
FLAG[LEVEL] = PTYPE;
// 4777 %END
#line 4777 "test-new/nrimp10s-77.imp"
return;
#line 4777 "test-new/nrimp10s-77.imp"
} /* end of RHEAD */
// 4778 %ROUTINE RDISPLAY(%INTEGER KK)
#line 4778 "test-new/nrimp10s-77.imp"
void RDISPLAY(int KK) {
// 4779 !***********************************************************************
// 4780 !* SET UP OR COPY THE DISPLAY (A WORD ARRAY CONTAINING COPIES OF *
// 4781 !* LNB FOR THE GLOBAL LEVELS. THE HIGHEST LEVEL ENTRY IS TO THE *
// 4782 !* GLA(PLT) FOR OWNS AND IS ALSO KEPT IN(LNB+4) IN CASE WE WISH *
// 4783 !* TO MOVE TO READ-ONLY PLTS. ON INTERNAL CALLS THE LNB FOR THE *
// 4784 !* NEXT MOST GLOBAL LEVEL IS STACKED AS AN EXTRA PARAMETER *
// 4785 !***********************************************************************
// 4786 %INTEGER W1,W2,STACK,OP,INC
#line 4786 "test-new/nrimp10s-77.imp"
int W1;
#line 4786 "test-new/nrimp10s-77.imp"
int W2;
#line 4786 "test-new/nrimp10s-77.imp"
int STACK;
#line 4786 "test-new/nrimp10s-77.imp"
int OP;
#line 4786 "test-new/nrimp10s-77.imp"
int INC;
// 4787 %IF KK>=0 %OR LEVEL=2 %START; ! DISPLAY NEEDED
#line 4787 "test-new/nrimp10s-77.imp"
if (KK >= 0) goto L_03E7;
#line 4787 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_044C;
#line 4787 "test-new/nrimp10s-77.imp"
L_03E7:;
// 4788 STACK=0; DISPLAY(RLEVEL)=N
#line 4788 "test-new/nrimp10s-77.imp"
STACK = 0;
#line 4788 "test-new/nrimp10s-77.imp"
DISPLAY[RLEVEL] = N;
// 4789 GRUSE(XNB)=0
#line 4789 "test-new/nrimp10s-77.imp"
GRUSE[3] = 0;
// 4790 GRUSE(CTB)=0; GRUSE(BREG)=0
#line 4790 "test-new/nrimp10s-77.imp"
GRUSE[5] = 0;
#line 4790 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 4791 %IF LEVEL#2 %THEN %START
#line 4791 "test-new/nrimp10s-77.imp"
if (LEVEL == 2) goto L_044D;
// 4792 ! PF1(LXN,0,TOS,0)
// 4793 GRUSE(XNB)=4; GRINF1(XNB)=RLEVEL-1; GRAT(XNB)=CA
#line 4793 "test-new/nrimp10s-77.imp"
GRUSE[3] = 4;
#line 4793 "test-new/nrimp10s-77.imp"
GRINF1[3] = RLEVEL - 1;
#line 4793 "test-new/nrimp10s-77.imp"
GRAT[3] = CA;
// 4794 PF1(LD,0,XNB,12); ! COPY PLT DESCRIPTOR
#line 4794 "test-new/nrimp10s-77.imp"
PF1(120, 0, 3, 12);
// 4795 DIAG POINTER(LEVEL)
#line 4795 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL);
// 4796 PSF1(STD,1,12)
#line 4796 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
// 4797 W1=RLEVEL-1; W2=DISPLAY(W1)
#line 4797 "test-new/nrimp10s-77.imp"
W1 = RLEVEL - 1;
#line 4797 "test-new/nrimp10s-77.imp"
W2 = DISPLAY[W1];
// 4798 %IF W1=1 %THEN PF1(STXN,0,TOS,0) %AND N=N+4 %ELSE %START
#line 4798 "test-new/nrimp10s-77.imp"
if (W1 != 1) goto L_044E;
#line 4798 "test-new/nrimp10s-77.imp"
PF1(76, 0, 6, 0);
#line 4798 "test-new/nrimp10s-77.imp"
N = N + 4;
#line 4798 "test-new/nrimp10s-77.imp"
goto L_044F;
#line 4798 "test-new/nrimp10s-77.imp"
L_044E:;
// 4799 %WHILE W1>0 %CYCLE
#line 4799 "test-new/nrimp10s-77.imp"
L_0450:;
#line 4799 "test-new/nrimp10s-77.imp"
if (W1 <= 0) goto L_0451;
// 4800 OP=LSS; INC=1
#line 4800 "test-new/nrimp10s-77.imp"
OP = 98;
#line 4800 "test-new/nrimp10s-77.imp"
INC = 1;
// 4801 %IF W1>=2 %THEN OP=LSD %AND INC=2
#line 4801 "test-new/nrimp10s-77.imp"
if (W1 < 2) goto L_0452;
#line 4801 "test-new/nrimp10s-77.imp"
OP = 100;
#line 4801 "test-new/nrimp10s-77.imp"
INC = 2;
#line 4801 "test-new/nrimp10s-77.imp"
L_0452:;
// 4802 %IF W1>=4 %THEN OP=LSQ %AND INC=4
#line 4802 "test-new/nrimp10s-77.imp"
if (W1 < 4) goto L_0453;
#line 4802 "test-new/nrimp10s-77.imp"
OP = 102;
#line 4802 "test-new/nrimp10s-77.imp"
INC = 4;
#line 4802 "test-new/nrimp10s-77.imp"
L_0453:;
// 4803 PF1(OP+STACK,0,XNB,W2)
#line 4803 "test-new/nrimp10s-77.imp"
PF1(OP + STACK, 0, 3, W2);
// 4804 STACK=-32; N=N+4*INC
#line 4804 "test-new/nrimp10s-77.imp"
STACK = -32;
#line 4804 "test-new/nrimp10s-77.imp"
N = N + 4 * INC;
// 4805 W2=W2+4*INC; W1=W1-INC
#line 4805 "test-new/nrimp10s-77.imp"
W2 = W2 + 4 * INC;
#line 4805 "test-new/nrimp10s-77.imp"
W1 = W1 - INC;
// 4806 %REPEAT
#line 4806 "test-new/nrimp10s-77.imp"
goto L_0450;
#line 4806 "test-new/nrimp10s-77.imp"
L_0451:;
// 4807 %FINISH
#line 4807 "test-new/nrimp10s-77.imp"
L_044F:;
// 4808 %FINISH
#line 4808 "test-new/nrimp10s-77.imp"
L_044D:;
// 4809 %IF STACK#0 %THEN PF1(ST,0,TOS,0); ! ST TOS
#line 4809 "test-new/nrimp10s-77.imp"
if (STACK == 0) goto L_0454;
#line 4809 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
#line 4809 "test-new/nrimp10s-77.imp"
L_0454:;
// 4810 PF1(STLN,0,TOS,0)
#line 4810 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
// 4811 N=N+4
#line 4811 "test-new/nrimp10s-77.imp"
N = N + 4;
// 4812 %FINISH
#line 4812 "test-new/nrimp10s-77.imp"
L_044C:;
// 4813 !
// 4814 ! IF IN DIAGNOSTIC MODE PLANT CODE TO SAVE THE LINE & ROUTINE NO OF
// 4815 ! THE CALLING ROUTINE AND SET UP THE NEW BLOCK/ROUTINE IDENT NO.
// 4816 !
// 4817 %IF PARMTRACE#0 %START
#line 4817 "test-new/nrimp10s-77.imp"
if (PARMTRACE == 0) goto L_0455;
// 4818 PF1(LSS,0,PC,4*CONST BTM!16_80000000) %IF PARMOPT#0;! M'IDIA'
#line 4818 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_0456;
#line 4818 "test-new/nrimp10s-77.imp"
PF1(98, 0, 4, 4 * CONSTBTM | -2147483648);
#line 4818 "test-new/nrimp10s-77.imp"
L_0456:;
// 4819 %IF KK>=0 %OR LEVEL=2 %START
#line 4819 "test-new/nrimp10s-77.imp"
if (KK >= 0) goto L_0457;
#line 4819 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_0458;
#line 4819 "test-new/nrimp10s-77.imp"
L_0457:;
// 4820 %IF PARMOPT#0 %THEN %START
#line 4820 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_0459;
// 4821 PSF1(SLSS,0,LINE)
#line 4821 "test-new/nrimp10s-77.imp"
PSF1(66, 0, LINE);
// 4822 N=N+4
#line 4822 "test-new/nrimp10s-77.imp"
N = N + 4;
// 4823 %FINISH %ELSE PSF1(LSS,0,LINE)
#line 4823 "test-new/nrimp10s-77.imp"
goto L_045A;
#line 4823 "test-new/nrimp10s-77.imp"
L_0459:;
#line 4823 "test-new/nrimp10s-77.imp"
PSF1(98, 0, LINE);
#line 4823 "test-new/nrimp10s-77.imp"
L_045A:;
// 4824 PF1(ST,0,TOS,0)
#line 4824 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 4825 %FINISH %ELSE %START
#line 4825 "test-new/nrimp10s-77.imp"
goto L_045B;
#line 4825 "test-new/nrimp10s-77.imp"
L_0458:;
// 4826 %IF PARMOPT#0 %THEN %START
#line 4826 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_045C;
// 4827 PSF1(ST,1,N)
#line 4827 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N);
// 4828 N=N+4
#line 4828 "test-new/nrimp10s-77.imp"
N = N + 4;
// 4829 %FINISH
#line 4829 "test-new/nrimp10s-77.imp"
L_045C:;
// 4830 PSF1(LSS,0,LINE)
#line 4830 "test-new/nrimp10s-77.imp"
PSF1(98, 0, LINE);
// 4831 PSF1(ST,1,N)
#line 4831 "test-new/nrimp10s-77.imp"
PSF1(72, 1, N);
// 4832 PSF1(LD,1,12); ! UPDATE BND FIELD
#line 4832 "test-new/nrimp10s-77.imp"
PSF1(120, 1, 12);
// 4833 DIAG POINTER(LEVEL)
#line 4833 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL);
// 4834 PSF1(STD,1,12)
#line 4834 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
// 4835 %FINISH
#line 4835 "test-new/nrimp10s-77.imp"
L_045B:;
// 4836 DIAGINF(LEVEL)=N
#line 4836 "test-new/nrimp10s-77.imp"
DIAGINF[LEVEL] = N;
// 4837 N=N+4
#line 4837 "test-new/nrimp10s-77.imp"
N = N + 4;
// 4838 GRUSE(ACCR)=0; ! NEEDED FOR %BEGIN BLOCKS
#line 4838 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 4839 %FINISH
#line 4839 "test-new/nrimp10s-77.imp"
L_0455:;
// 4840 %IF PARMOPT#0 %AND KK>=0 %AND LEVEL=2 %START
#line 4840 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_045D;
#line 4840 "test-new/nrimp10s-77.imp"
if (KK < 0) goto L_045D;
#line 4840 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_045D;
// 4841 PF1(STSF,0,BREG,0)
#line 4841 "test-new/nrimp10s-77.imp"
PF1(94, 0, 7, 0);
// 4842 PF1(STLN,0,TOS,0)
#line 4842 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
// 4843 PF1(SBB,0,TOS,0)
#line 4843 "test-new/nrimp10s-77.imp"
PF1(34, 0, 6, 0);
// 4844 PSF1(CPB,0,N)
#line 4844 "test-new/nrimp10s-77.imp"
PSF1(38, 0, N);
// 4845 PPJ(7,13)
#line 4845 "test-new/nrimp10s-77.imp"
PPJ(7, 13);
// 4846 %FINISH
#line 4846 "test-new/nrimp10s-77.imp"
L_045D:;
// 4847 !
// 4848 ! CLAIM (THE REST OF) THE STACK FRAME
// 4849 !
// 4850 %IF KK>=0 %OR LEVEL=2 %START
#line 4850 "test-new/nrimp10s-77.imp"
if (KK >= 0) goto L_045E;
#line 4850 "test-new/nrimp10s-77.imp"
if (LEVEL != 2) goto L_045F;
#line 4850 "test-new/nrimp10s-77.imp"
L_045E:;
// 4851 SET(RLEVEL)=N<<18!CA
#line 4851 "test-new/nrimp10s-77.imp"
SET[RLEVEL] = N << 18 | CA;
// 4852 NMAX=N
#line 4852 "test-new/nrimp10s-77.imp"
NMAX = N;
// 4853 PF1(ASF+12*PARMCHK,0,0,0); ! ASF OR LB
#line 4853 "test-new/nrimp10s-77.imp"
PF1(110 + 12 * PARMCHK, 0, 0, 0);
// 4854 PPJ(0,4) %IF PARMCHK#0
#line 4854 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_0460;
#line 4854 "test-new/nrimp10s-77.imp"
PPJ(0, 4);
#line 4854 "test-new/nrimp10s-77.imp"
L_0460:;
// 4855 %FINISH
#line 4855 "test-new/nrimp10s-77.imp"
L_045F:;
// 4856 !
// 4857 %IF KK>=0 %AND PARMCHK#0 %START
#line 4857 "test-new/nrimp10s-77.imp"
if (KK < 0) goto L_0461;
#line 4857 "test-new/nrimp10s-77.imp"
if (PARMCHK == 0) goto L_0461;
// 4858 CHECK STOF; ! CHECK FOR STACK O'FLOW
#line 4858 "test-new/nrimp10s-77.imp"
CHECKSTOF();
// 4859 %FINISH
#line 4859 "test-new/nrimp10s-77.imp"
L_0461:;
// 4860 %IF PARMDBUG#0 %THEN SET LINE; ! TO CALL DBUG PACKAGE
#line 4860 "test-new/nrimp10s-77.imp"
if (PARMDBUG == 0) goto L_0462;
#line 4860 "test-new/nrimp10s-77.imp"
SETLINE();
#line 4860 "test-new/nrimp10s-77.imp"
L_0462:;
// 4861 %END
#line 4861 "test-new/nrimp10s-77.imp"
return;
#line 4861 "test-new/nrimp10s-77.imp"
} /* end of RDISPLAY */
// 4862 %ROUTINE CHECK STOF
#line 4862 "test-new/nrimp10s-77.imp"
void CHECKSTOF(void) {
// 4863 !***********************************************************************
// 4864 !* CHECK THE STACK FOR OVERFLOW (LEAVING 4K MARGIN FOR MDIAG *
// 4865 !***********************************************************************
// 4866 %IF PARMOPT#0 %THEN %START
#line 4866 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_0463;
// 4867 !
// 4868 ! STSF TOS GET STACK POINTER
// 4869 ! LSS TOS
// 4870 ! USH +14
// 4871 ! USH -15 LOSE SEGMENT NO
// 4872 ! ICP 16_1F800 CHECK WITHIN SEG ADDRESS
// 4873 ! SHIFTED DOWN 1 PLACE
// 4874 ! JCC 2,EXCESS BLKS
// 4875 !
// 4876 PF1(STSF,0,TOS,0)
#line 4876 "test-new/nrimp10s-77.imp"
PF1(94, 0, 6, 0);
// 4877 PF1(LSS,0,TOS,0)
#line 4877 "test-new/nrimp10s-77.imp"
PF1(98, 0, 6, 0);
// 4878 PSF1(USH,0,14)
#line 4878 "test-new/nrimp10s-77.imp"
PSF1(200, 0, 14);
// 4879 PSF1(USH,0,-15)
#line 4879 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -15);
// 4880 PF1(ICP,0,0,ST LIMIT>>1)
#line 4880 "test-new/nrimp10s-77.imp"
PF1(230, 0, 0, (unsigned int)STLIMIT >> 1);
// 4881 PPJ(2,8)
#line 4881 "test-new/nrimp10s-77.imp"
PPJ(2, 8);
// 4882 %FINISH
#line 4882 "test-new/nrimp10s-77.imp"
L_0463:;
// 4883 %END; ! OF ROUTINE RHEAD
#line 4883 "test-new/nrimp10s-77.imp"
return;
#line 4883 "test-new/nrimp10s-77.imp"
} /* end of CHECKSTOF */
// 4884 %ROUTINE CIOCP(%INTEGER N,REG)
#line 4884 "test-new/nrimp10s-77.imp"
void CIOCP(int N, int REG) {
// 4885 !***********************************************************************
// 4886 !* COMPILES A CALL ON IOCP ENTRY POINT NO 'N' *
// 4887 !* 2ND PARAMETER IS ALREAD IN THE ACC WHICH IS 32 BITS *
// 4888 !***********************************************************************
// 4889 %INTEGER XYNB,OP1,OP2
#line 4889 "test-new/nrimp10s-77.imp"
int XYNB;
#line 4889 "test-new/nrimp10s-77.imp"
int OP1;
#line 4889 "test-new/nrimp10s-77.imp"
int OP2;
// 4890 %IF IOCPDISP=0 %THEN CXREF(IOCPEP,PARMDYNAMIC,2,IOCPDISP)
#line 4890 "test-new/nrimp10s-77.imp"
if (IOCPDISP != 0) goto L_0464;
#line 4890 "test-new/nrimp10s-77.imp"
CXREF(
#line 4890 "test-new/nrimp10s-77.imp"
*({
__typeof__(_imp_string8) tmp = IOCPEP /*q*/;
(_imp_string255 *)&tmp;
})
#line 4890 "test-new/nrimp10s-77.imp"
,
PARMDYNAMIC, 2, /*?*/ &IOCPDISP);
#line 4890 "test-new/nrimp10s-77.imp"
L_0464:;
// 4891 %IF REGISTER(BREG)#0 %THEN BOOT OUT(BREG)
#line 4891 "test-new/nrimp10s-77.imp"
if (REGISTER[7] == 0) goto L_0465;
#line 4891 "test-new/nrimp10s-77.imp"
BOOTOUT(7);
#line 4891 "test-new/nrimp10s-77.imp"
L_0465:;
// 4892 %IF REG=ACCR %THEN OP1=LUH %AND OP2=ST %ELSE OP1=LDTB %AND OP2=STD
#line 4892 "test-new/nrimp10s-77.imp"
if (REG != 0) goto L_0466;
#line 4892 "test-new/nrimp10s-77.imp"
OP1 = 106;
#line 4892 "test-new/nrimp10s-77.imp"
OP2 = 72;
#line 4892 "test-new/nrimp10s-77.imp"
goto L_0467;
#line 4892 "test-new/nrimp10s-77.imp"
L_0466:;
#line 4892 "test-new/nrimp10s-77.imp"
OP1 = 116;
#line 4892 "test-new/nrimp10s-77.imp"
OP2 = 88;
#line 4892 "test-new/nrimp10s-77.imp"
L_0467:;
// 4893 PSF1(OP1,0,N)
#line 4893 "test-new/nrimp10s-77.imp"
PSF1(OP1, 0, N);
// 4894 PSF1(PRCL,0,4)
#line 4894 "test-new/nrimp10s-77.imp"
PSF1(24, 0, 4);
// 4895 PF1(OP2,0,TOS,0)
#line 4895 "test-new/nrimp10s-77.imp"
PF1(OP2, 0, 6, 0);
// 4896 XYNB=SET XORYNB(-1,-1); ! TO PLT
#line 4896 "test-new/nrimp10s-77.imp"
XYNB = SETXORYNB(-1, -1);
// 4897 PSF1(RALN,0,7)
#line 4897 "test-new/nrimp10s-77.imp"
PSF1(108, 0, 7);
// 4898 PF1(CALL,2,XYNB,IOCPDISP)
#line 4898 "test-new/nrimp10s-77.imp"
PF1(30, 2, XYNB, IOCPDISP);
// 4899 FORGET(-1)
#line 4899 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 4900 %END
#line 4900 "test-new/nrimp10s-77.imp"
return;
#line 4900 "test-new/nrimp10s-77.imp"
} /* end of CIOCP */
// 4901 %ROUTINE CUI(%INTEGER CODE)
#line 4901 "test-new/nrimp10s-77.imp"
void CUI(int CODE) {
// 4902 !***********************************************************************
// 4903 !* COMPILE AN UNCONDITIONAL INSTRN WHEREEVER IT OCCURS *
// 4904 !* CODE=0 UNCONDITIOALLY,=1 AFTER %THEN, =2 AFTER %ELSE *
// 4905 !***********************************************************************
// 4906 %INTEGER MARKER,J,LNAME,TYPEP,PRECP,GWRDD,LWB,XYNB,ARRP,ALT
#line 4906 "test-new/nrimp10s-77.imp"
int MARKER;
#line 4906 "test-new/nrimp10s-77.imp"
int J;
#line 4906 "test-new/nrimp10s-77.imp"
int LNAME;
#line 4906 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 4906 "test-new/nrimp10s-77.imp"
int PRECP;
#line 4906 "test-new/nrimp10s-77.imp"
int GWRDD;
#line 4906 "test-new/nrimp10s-77.imp"
int LWB;
#line 4906 "test-new/nrimp10s-77.imp"
int XYNB;
#line 4906 "test-new/nrimp10s-77.imp"
int ARRP;
#line 4906 "test-new/nrimp10s-77.imp"
int ALT;
// 4907 %SWITCH SW(1:9)
#line 4907 "test-new/nrimp10s-77.imp"
int SW_index;
#line 4907 "test-new/nrimp10s-77.imp"
int SW_line;
#line 4907 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 4907 "test-new/nrimp10s-77.imp"
static const void *SW[9] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 4908 REPORTUI=0
#line 4908 "test-new/nrimp10s-77.imp"
REPORTUI = 0;
// 4909 ALT=A(P)
#line 4909 "test-new/nrimp10s-77.imp"
ALT = A[P];
// 4910 ->SW(ALT)
#line 4910 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = ALT;
goto case_SW_dispatch;
// 4911 SW(1): ! (NAME)(APP)(ASSMNT?)
#line 4911 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 4912 P=P+1; MARKER=P+FROMAR2(P)
#line 4912 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4912 "test-new/nrimp10s-77.imp"
MARKER = P + FROMAR2(P);
// 4913 %IF A(MARKER)=1 %THEN %START
#line 4913 "test-new/nrimp10s-77.imp"
if (A[MARKER] != 1) goto L_0469;
// 4914 J=P+2; P=MARKER+2
#line 4914 "test-new/nrimp10s-77.imp"
J = P + 2;
#line 4914 "test-new/nrimp10s-77.imp"
P = MARKER + 2;
// 4915 ASSIGN(A(MARKER+1),J)
#line 4915 "test-new/nrimp10s-77.imp"
ASSIGN(A[MARKER + 1], J);
// 4916 %FINISH %ELSE %START
#line 4916 "test-new/nrimp10s-77.imp"
goto L_046A;
#line 4916 "test-new/nrimp10s-77.imp"
L_0469:;
// 4917 P=P+2
#line 4917 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4918 CNAME(0,0)
#line 4918 "test-new/nrimp10s-77.imp"
CNAME(0, 0);
// 4919 P=P+1
#line 4919 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4920 %FINISH
#line 4920 "test-new/nrimp10s-77.imp"
L_046A:;
// 4921 AUI: J=A(P); P=P+1
#line 4921 "test-new/nrimp10s-77.imp"
U_102B:;
#line 4921 "test-new/nrimp10s-77.imp"
J = A[P];
#line 4921 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4922 %IF J=1 %THEN CUI(CODE)
#line 4922 "test-new/nrimp10s-77.imp"
if (J != 1) goto L_046B;
#line 4922 "test-new/nrimp10s-77.imp"
CUI(CODE);
#line 4922 "test-new/nrimp10s-77.imp"
L_046B:;
// 4923 %RETURN
#line 4923 "test-new/nrimp10s-77.imp"
return;
// 4924 SW(2): ! -> (NAME)(APP)
#line 4924 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 4925 NMDECS(LEVEL)=NMDECS(LEVEL)!1
#line 4925 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | 1;
// 4926 CURR INST=1 %IF CODE=0
#line 4926 "test-new/nrimp10s-77.imp"
if (CODE != 0) goto L_046C;
#line 4926 "test-new/nrimp10s-77.imp"
CURRINST = 1;
#line 4926 "test-new/nrimp10s-77.imp"
L_046C:;
// 4927 LNAME=FROM AR2(P+1)
#line 4927 "test-new/nrimp10s-77.imp"
LNAME = FROMAR2(P + 1);
// 4928 J=A(P+3); P=P+4
#line 4928 "test-new/nrimp10s-77.imp"
J = A[P + 3];
#line 4928 "test-new/nrimp10s-77.imp"
P = P + 4;
// 4929 %IF J=2 %THEN %START; ! SIMPLE LABEL
#line 4929 "test-new/nrimp10s-77.imp"
if (J != 2) goto L_046D;
// 4930 ENTER JUMP(15,LNAME,0)
#line 4930 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, LNAME, 0);
// 4931 REPORTUI=1
#line 4931 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
// 4932 %FINISH %ELSE %START; ! SWITCH LABELS
#line 4932 "test-new/nrimp10s-77.imp"
goto L_046E;
#line 4932 "test-new/nrimp10s-77.imp"
L_046D:;
// 4933 COPY TAG(LNAME)
#line 4933 "test-new/nrimp10s-77.imp"
COPYTAG(LNAME);
// 4934 ARRP=ARR
#line 4934 "test-new/nrimp10s-77.imp"
ARRP = ARR;
// 4935 GWRDD=SNDISP<<2; ! BYTE DISP OF DESCRIPTOR IN PLT
#line 4935 "test-new/nrimp10s-77.imp"
GWRDD = SNDISP << 2;
// 4936 %UNLESS OLDI=LEVEL %AND TYPE=6 %START
#line 4936 "test-new/nrimp10s-77.imp"
if (OLDI != LEVEL) goto L_046F;
#line 4936 "test-new/nrimp10s-77.imp"
if (TYPE == 6) goto L_0470;
#line 4936 "test-new/nrimp10s-77.imp"
L_046F:;
// 4937 FAULT(4,LNAME); P=P-1; SKIP APP
#line 4937 "test-new/nrimp10s-77.imp"
FAULT(4, LNAME);
#line 4937 "test-new/nrimp10s-77.imp"
P = P - 1;
#line 4937 "test-new/nrimp10s-77.imp"
SKIPAPP();
// 4938 %RETURN
#line 4938 "test-new/nrimp10s-77.imp"
return;
// 4939 %FINISH
#line 4939 "test-new/nrimp10s-77.imp"
L_0470:;
// 4940 LWB=FROM2(K); ! GET LOWER BOUND
#line 4940 "test-new/nrimp10s-77.imp"
LWB = FROM2(K);
// 4941 CSEXP(BREG,16_51)
#line 4941 "test-new/nrimp10s-77.imp"
CSEXP(7, 81);
// 4942 %IF ARRP=1 %THEN PSF1(SBB,0,LWB)
#line 4942 "test-new/nrimp10s-77.imp"
if (ARRP != 1) goto L_0471;
#line 4942 "test-new/nrimp10s-77.imp"
PSF1(34, 0, LWB);
#line 4942 "test-new/nrimp10s-77.imp"
L_0471:;
// 4943 XYNB=SET XORYNB(-1,-1); ! TO PLT
#line 4943 "test-new/nrimp10s-77.imp"
XYNB = SETXORYNB(-1, -1);
// 4944 PF1(JUNC,3,XYNB,GWRDD); ! JUMP INDIRECT VIA WORD ARRAY
#line 4944 "test-new/nrimp10s-77.imp"
PF1(26, 3, XYNB, GWRDD);
// 4945 ! OF 32 BIT RELOCATED ADDRESSES
// 4946 REPORTUI=1; FORGET(-1)
#line 4946 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
#line 4946 "test-new/nrimp10s-77.imp"
FORGET(-1);
// 4947 %FINISH
#line 4947 "test-new/nrimp10s-77.imp"
L_046E:;
// 4948 %RETURN
#line 4948 "test-new/nrimp10s-77.imp"
return;
// 4949 SW(3): ! RETURN
#line 4949 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 4950 FAULT(30,0) %UNLESS FLAG(LEVEL)&16_3FFF=16_1000
#line 4950 "test-new/nrimp10s-77.imp"
if (FLAG[LEVEL] & 16383 == 4096) goto L_0472;
#line 4950 "test-new/nrimp10s-77.imp"
FAULT(30, 0);
#line 4950 "test-new/nrimp10s-77.imp"
L_0472:;
// 4951 P=P+1
#line 4951 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4952 RET: RT EXIT
#line 4952 "test-new/nrimp10s-77.imp"
U_1030:;
#line 4952 "test-new/nrimp10s-77.imp"
RTEXIT();
// 4953 REPORT UI=1
#line 4953 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
// 4954 CURR INST=1 %IF CODE=0
#line 4954 "test-new/nrimp10s-77.imp"
if (CODE != 0) goto L_0473;
#line 4954 "test-new/nrimp10s-77.imp"
CURRINST = 1;
#line 4954 "test-new/nrimp10s-77.imp"
L_0473:;
// 4955 %RETURN
#line 4955 "test-new/nrimp10s-77.imp"
return;
// 4956 SW(4): ! %RESULT(ASSOP)(EXPR)
#line 4956 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 4957 PTYPE=FLAG(LEVEL)&16_3FFF; UNPACK
#line 4957 "test-new/nrimp10s-77.imp"
PTYPE = FLAG[LEVEL] & 16383;
#line 4957 "test-new/nrimp10s-77.imp"
UNPACK();
// 4958 %IF PTYPE>16_1000 %AND A(P+1)#3 %THEN %START;! ASSOP #'->'
#line 4958 "test-new/nrimp10s-77.imp"
if (PTYPE <= 4096) goto L_0474;
#line 4958 "test-new/nrimp10s-77.imp"
if (A[P + 1] == 3) goto L_0474;
// 4959 %IF A(P+1)=1 %AND NAM#0 %AND A(P+5)=4 %AND A(P+6)=1 %START
#line 4959 "test-new/nrimp10s-77.imp"
if (A[P + 1] != 1) goto L_0475;
#line 4959 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_0475;
#line 4959 "test-new/nrimp10s-77.imp"
if (A[P + 5] != 4) goto L_0475;
#line 4959 "test-new/nrimp10s-77.imp"
if (A[P + 6] != 1) goto L_0475;
// 4960 P=P+7; TYPEP=TYPE; PRECP=PREC
#line 4960 "test-new/nrimp10s-77.imp"
P = P + 7;
#line 4960 "test-new/nrimp10s-77.imp"
TYPEP = TYPE;
#line 4960 "test-new/nrimp10s-77.imp"
PRECP = PREC;
// 4961 CNAME(4,ACCR)
#line 4961 "test-new/nrimp10s-77.imp"
CNAME(4, 0);
// 4962 FAULT(81,0) %UNLESS A(P)=2; P=P+1
#line 4962 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0476;
#line 4962 "test-new/nrimp10s-77.imp"
FAULT(81, 0);
#line 4962 "test-new/nrimp10s-77.imp"
L_0476:;
#line 4962 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4963 FAULT(83,0) %UNLESS TYPEP=TYPE %AND PRECP=PREC
#line 4963 "test-new/nrimp10s-77.imp"
if (TYPEP != TYPE) goto L_0477;
#line 4963 "test-new/nrimp10s-77.imp"
if (PRECP == PREC) goto L_0478;
#line 4963 "test-new/nrimp10s-77.imp"
L_0477:;
#line 4963 "test-new/nrimp10s-77.imp"
FAULT(83, 0);
#line 4963 "test-new/nrimp10s-77.imp"
L_0478:;
// 4964 ->RET
#line 4964 "test-new/nrimp10s-77.imp"
goto U_1030;
// 4965 %FINISH
#line 4965 "test-new/nrimp10s-77.imp"
L_0475:;
// 4966 %IF A(P+1)=2 %THEN %START; ! ASSOP='='
#line 4966 "test-new/nrimp10s-77.imp"
if (A[P + 1] != 2) goto L_0479;
// 4967 P=P+2
#line 4967 "test-new/nrimp10s-77.imp"
P = P + 2;
// 4968 %IF NAM#0 %THEN TYPE=1; ! MAPS HAVE INTEGER RESULTS
#line 4968 "test-new/nrimp10s-77.imp"
if (NAM == 0) goto L_047A;
#line 4968 "test-new/nrimp10s-77.imp"
TYPE = 1;
#line 4968 "test-new/nrimp10s-77.imp"
L_047A:;
// 4969 %IF TYPE=5 %THEN %START
#line 4969 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_047B;
// 4970 CSTREXP(0,ACCR)
#line 4970 "test-new/nrimp10s-77.imp"
CSTREXP(0, 0);
// 4971 PSF1(LD,1,DISPLAY(RBASE)-8); ! RESULT DESCRPT
#line 4971 "test-new/nrimp10s-77.imp"
PSF1(120, 1, DISPLAY[RBASE] - 8);
// 4972 PF1(IAD,0,PC,SPECIAL CONSTS(2))
#line 4972 "test-new/nrimp10s-77.imp"
PF1(224, 0, 4, SPECIALCONSTS(2));
// 4973 PF2(MV,1,1,0,0,UNASSPAT&255)
#line 4973 "test-new/nrimp10s-77.imp"
PF2(178, 1, 1, 0, 0, -2122219135 & 255);
// 4974 PSF1(LDB,2,DISPLAY(RBASE)-8)
#line 4974 "test-new/nrimp10s-77.imp"
PSF1(118, 2, DISPLAY[RBASE] - 8);
// 4975 COPY DR
#line 4975 "test-new/nrimp10s-77.imp"
COPYDR();
// 4976 %FINISH %ELSE %START
#line 4976 "test-new/nrimp10s-77.imp"
goto L_047C;
#line 4976 "test-new/nrimp10s-77.imp"
L_047B:;
// 4977 %IF PREC<5 %THEN PREC=5
#line 4977 "test-new/nrimp10s-77.imp"
if (PREC >= 5) goto L_047D;
#line 4977 "test-new/nrimp10s-77.imp"
PREC = 5;
#line 4977 "test-new/nrimp10s-77.imp"
L_047D:;
// 4978 %IF NAM=0 %THEN KK=PREC<<4!TYPE %ELSE KK=16_51
#line 4978 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_047E;
#line 4978 "test-new/nrimp10s-77.imp"
KK = PREC << 4 | TYPE;
#line 4978 "test-new/nrimp10s-77.imp"
goto L_047F;
#line 4978 "test-new/nrimp10s-77.imp"
L_047E:;
#line 4978 "test-new/nrimp10s-77.imp"
KK = 81;
#line 4978 "test-new/nrimp10s-77.imp"
L_047F:;
// 4979 CSEXP(ACCR,KK)
#line 4979 "test-new/nrimp10s-77.imp"
CSEXP(0, KK);
// 4980 %FINISH; ->RET
#line 4980 "test-new/nrimp10s-77.imp"
L_047C:;
#line 4980 "test-new/nrimp10s-77.imp"
goto U_1030;
// 4981 %FINISH
#line 4981 "test-new/nrimp10s-77.imp"
L_0479:;
// 4982 %FINISH
#line 4982 "test-new/nrimp10s-77.imp"
L_0474:;
// 4983 FAULT(31,0)
#line 4983 "test-new/nrimp10s-77.imp"
FAULT(31, 0);
// 4984 P=P+2; SKIP EXP; ! IGNORE SPURIOUS RESULT
#line 4984 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 4984 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 4985 %RETURN
#line 4985 "test-new/nrimp10s-77.imp"
return;
// 4986 SW(5): ! %MONITOR (AUI)
#line 4986 "test-new/nrimp10s-77.imp"
case_SW_5:;
// 4987 PSF1(LSD,0,0); ! ERR=0 & EXTRA =0
#line 4987 "test-new/nrimp10s-77.imp"
PSF1(100, 0, 0);
// 4988 PPJ(0,2); ! TO ERROR ROUTINE
#line 4988 "test-new/nrimp10s-77.imp"
PPJ(0, 2);
// 4989 P=P+1; ->AUI
#line 4989 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 4989 "test-new/nrimp10s-77.imp"
goto U_102B;
// 4990 SW(6): ! %STOP
#line 4990 "test-new/nrimp10s-77.imp"
case_SW_6:;
// 4991 PPJ(0,21)
#line 4991 "test-new/nrimp10s-77.imp"
PPJ(0, 21);
// 4992 P=P+1
#line 4992 "test-new/nrimp10s-77.imp"
P = P + 1;
// 4993 CURR INST=1 %IF CODE=0
#line 4993 "test-new/nrimp10s-77.imp"
if (CODE != 0) goto L_0480;
#line 4993 "test-new/nrimp10s-77.imp"
CURRINST = 1;
#line 4993 "test-new/nrimp10s-77.imp"
L_0480:;
// 4994 REPORTUI=1
#line 4994 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
// 4995 %RETURN
#line 4995 "test-new/nrimp10s-77.imp"
return;
// 4996 SW(7): !'%SIGNAL'(EVENT')(N)(OPEXPR)
#line 4996 "test-new/nrimp10s-77.imp"
case_SW_7:;
// 4997 PSF1(PRCL,0,4)
#line 4997 "test-new/nrimp10s-77.imp"
PSF1(24, 0, 4);
// 4998 PSF1(JLK,0,1); ! STACK DUMMY PC
#line 4998 "test-new/nrimp10s-77.imp"
PSF1(28, 0, 1);
// 4999 %IF NMDECS(LEVEL)&16 #0 %START;! IN AN 'ON' GROUP
#line 4999 "test-new/nrimp10s-77.imp"
if (NMDECS[LEVEL] & 16 == 0) goto L_0481;
// 5000 %IF FLAG(LEVEL)<=2 %START; ! IN A BEGIN BLOCK
#line 5000 "test-new/nrimp10s-77.imp"
if (FLAG[LEVEL] > 2) goto L_0482;
// 5001 PSF1(LD,1,12); ! SO RESET DIAG POINTER
#line 5001 "test-new/nrimp10s-77.imp"
PSF1(120, 1, 12);
// 5002 DIAGPOINTER(LEVEL-1); ! TO NEXT OUTER BLOCK
#line 5002 "test-new/nrimp10s-77.imp"
DIAGPOINTER(LEVEL - 1);
// 5003 PSF1(STD,1,12)
#line 5003 "test-new/nrimp10s-77.imp"
PSF1(88, 1, 12);
// 5004 PF1(STLN,0,TOS,0)
#line 5004 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
// 5005 %FINISH %ELSE %START; ! 'ON IN A RT/FN/MAP
#line 5005 "test-new/nrimp10s-77.imp"
goto L_0483;
#line 5005 "test-new/nrimp10s-77.imp"
L_0482:;
// 5006 PSF1(LSS,1,0); ! GET PREVIOUS LNB
#line 5006 "test-new/nrimp10s-77.imp"
PSF1(98, 1, 0);
// 5007 PF1(ST,0,TOS,0); ! AND STACK THAT
#line 5007 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 5008 %FINISH
#line 5008 "test-new/nrimp10s-77.imp"
L_0483:;
// 5009 %FINISH %ELSE PF1(STLN,0,TOS,0)
#line 5009 "test-new/nrimp10s-77.imp"
goto L_0484;
#line 5009 "test-new/nrimp10s-77.imp"
L_0481:;
#line 5009 "test-new/nrimp10s-77.imp"
PF1(92, 0, 6, 0);
#line 5009 "test-new/nrimp10s-77.imp"
L_0484:;
// 5010 GRUSE(ACCR)=0
#line 5010 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5011 J=A(P+2); ! EVENT NO
#line 5011 "test-new/nrimp10s-77.imp"
J = A[P + 2];
// 5012 FAULT2(26,J,0) %UNLESS 1<=J<=15
#line 5012 "test-new/nrimp10s-77.imp"
{
// Double-sided test on J (Part I)
#line 5012 "test-new/nrimp10s-77.imp"
int tmp;
#line 5012 "test-new/nrimp10s-77.imp"
if (1 > (tmp = J)) goto L_0485;
// Double-sided test on J (Part II)
#line 5012 "test-new/nrimp10s-77.imp"
if (tmp <= 15) goto L_0486;
#line 5012 "test-new/nrimp10s-77.imp"
}
#line 5012 "test-new/nrimp10s-77.imp"
L_0485:;
#line 5012 "test-new/nrimp10s-77.imp"
FAULT2(26, J, 0);
#line 5012 "test-new/nrimp10s-77.imp"
L_0486:;
// 5013 %IF A(P+3)=1 %START; ! SUBEVENT SPECIFIED
#line 5013 "test-new/nrimp10s-77.imp"
if (A[P + 3] != 1) goto L_0487;
// 5014 P=P+4; CSEXP(ACCR,16_51)
#line 5014 "test-new/nrimp10s-77.imp"
P = P + 4;
#line 5014 "test-new/nrimp10s-77.imp"
CSEXP(0, 81);
// 5015 PF1(AND,0,0,255)
#line 5015 "test-new/nrimp10s-77.imp"
PF1(138, 0, 0, 255);
// 5016 PF1(OR,0,0,256*J)
#line 5016 "test-new/nrimp10s-77.imp"
PF1(140, 0, 0, 256 * J);
// 5017 %FINISH %ELSE PF1(LSS,0,0,256*J)
#line 5017 "test-new/nrimp10s-77.imp"
goto L_0488;
#line 5017 "test-new/nrimp10s-77.imp"
L_0487:;
#line 5017 "test-new/nrimp10s-77.imp"
PF1(98, 0, 0, 256 * J);
#line 5017 "test-new/nrimp10s-77.imp"
L_0488:;
// 5018 PSF1(SLSS,0,0)
#line 5018 "test-new/nrimp10s-77.imp"
PSF1(66, 0, 0);
// 5019 PF1(ST,0,TOS,0)
#line 5019 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 5020 XYNB=SET XORYNB(-1,-1); ! TO PLT
#line 5020 "test-new/nrimp10s-77.imp"
XYNB = SETXORYNB(-1, -1);
// 5021 PSF1(RALN,0,9)
#line 5021 "test-new/nrimp10s-77.imp"
PSF1(108, 0, 9);
// 5022 PF1(CALL,2,XYNB,40)
#line 5022 "test-new/nrimp10s-77.imp"
PF1(30, 2, XYNB, 40);
// 5023 CURR INST=1 %IF CODE=0
#line 5023 "test-new/nrimp10s-77.imp"
if (CODE != 0) goto L_0489;
#line 5023 "test-new/nrimp10s-77.imp"
CURRINST = 1;
#line 5023 "test-new/nrimp10s-77.imp"
L_0489:;
// 5024 REPORTUI=1; %RETURN
#line 5024 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
#line 5024 "test-new/nrimp10s-77.imp"
return;
// 5025 SW(8): ! %EXIT
#line 5025 "test-new/nrimp10s-77.imp"
case_SW_8:;
// 5026 SW(9): ! %CONTINUE
#line 5026 "test-new/nrimp10s-77.imp"
case_SW_9:;
// 5027 ALT=ALT&7; ! 0 FOR EXIT 1 FOR CONTINUE
#line 5027 "test-new/nrimp10s-77.imp"
ALT = ALT & 7;
// 5028 %IF EXITLAB=0 %THEN FAULT2(54+ALT,0,0) %AND %RETURN
#line 5028 "test-new/nrimp10s-77.imp"
if (EXITLAB != 0) goto L_048A;
#line 5028 "test-new/nrimp10s-77.imp"
FAULT2(54 + ALT, 0, 0);
#line 5028 "test-new/nrimp10s-77.imp"
return;
#line 5028 "test-new/nrimp10s-77.imp"
L_048A:;
// 5029 KK=INTEGER(ADDR(EXITLAB)+4*ALT)
#line 5029 "test-new/nrimp10s-77.imp"
KK = *_imp_INTEGER(_imp_ADDR(/*?*/ &EXITLAB) + 4 * ALT);
// 5030 ENTER JUMP(15,KK,B'10')
#line 5030 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, KK, 2);
// 5031 REPORTUI=1
#line 5031 "test-new/nrimp10s-77.imp"
REPORTUI = 1;
// 5032 CURR INST=1 %IF CODE=0
#line 5032 "test-new/nrimp10s-77.imp"
if (CODE != 0) goto L_048B;
#line 5032 "test-new/nrimp10s-77.imp"
CURRINST = 1;
#line 5032 "test-new/nrimp10s-77.imp"
L_048B:;
// 5033 %END
#line 5033 "test-new/nrimp10s-77.imp"
return;
#line 5033 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 5033 "test-new/nrimp10s-77.imp"
if (SW_index < 1 || SW_index > 9)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 5033 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 1];
#line 5033 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 5033 "test-new/nrimp10s-77.imp"
} /* end of CUI */
// 5034 %ROUTINE CIFTHEN(%INTEGER MARKIU,MARKC,MARKUI,MARKE,MARKR,SKIP)
#line 5034 "test-new/nrimp10s-77.imp"
void CIFTHEN(int MARKIU, int MARKC, int MARKUI, int MARKE, int MARKR, int SKIP) {
// 5035 !***********************************************************************
// 5036 !* THIS ROUTINE COMPILES CONDITIONAL EXPRESSIONS.IT REQUIRES THE *
// 5037 !* FOLLOWING PARAMETERS TO BE SET TO THEIR A .R. ENTRY. *
// 5038 !* MARKIU TO THE ENTRY FOR P(%IU) *
// 5039 !* MARKC TO THE ENTRY FOR P(COND) *
// 5040 !* MARKUI TO THE ENTRY FOR (FIRST OCCURRENCE OF) P(UI) *
// 5041 !* MARKE TO THE ENTRY FOR P(ELSE') - =0 FOR BACKWARDS CONDITION *
// 5042 !* MARKR TO ENTRY FOR P(RESTOFIU) - =0 FOR BACKWARDS CONDITION *
// 5043 !***********************************************************************
// 5044 %INTEGER ALTUI,CCRES,ELRES,THENLAB,ELSELAB,USERLAB,REPORT,START,ELSEALT,K
#line 5044 "test-new/nrimp10s-77.imp"
int ALTUI;
#line 5044 "test-new/nrimp10s-77.imp"
int CCRES;
#line 5044 "test-new/nrimp10s-77.imp"
int ELRES;
#line 5044 "test-new/nrimp10s-77.imp"
int THENLAB;
#line 5044 "test-new/nrimp10s-77.imp"
int ELSELAB;
#line 5044 "test-new/nrimp10s-77.imp"
int USERLAB;
#line 5044 "test-new/nrimp10s-77.imp"
int REPORT;
#line 5044 "test-new/nrimp10s-77.imp"
int START;
#line 5044 "test-new/nrimp10s-77.imp"
int ELSEALT;
#line 5044 "test-new/nrimp10s-77.imp"
int K;
// 5045 %CONSTINTEGER NULL ELSE=4
// 5046 %SWITCH ESW(1:NULL ELSE)
#line 5046 "test-new/nrimp10s-77.imp"
int ESW_index;
#line 5046 "test-new/nrimp10s-77.imp"
int ESW_line;
#line 5046 "test-new/nrimp10s-77.imp"
char *ESW_file;
#line 5046 "test-new/nrimp10s-77.imp"
static const void *ESW[4] = {&&case_ESW_missing, &&case_ESW_missing, &&case_ESW_missing, &&case_ESW_missing};
// 5047 SET LINE %UNLESS SKIP=YES
#line 5047 "test-new/nrimp10s-77.imp"
if (SKIP == 1) goto L_048C;
#line 5047 "test-new/nrimp10s-77.imp"
SETLINE();
#line 5047 "test-new/nrimp10s-77.imp"
L_048C:;
// 5048 MARKIU=A(MARKIU); ! ALT OF IU 1=%IF,2=%UNLESS
#line 5048 "test-new/nrimp10s-77.imp"
MARKIU = A[MARKIU];
// 5049 PLABEL=PLABEL-1
#line 5049 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
// 5050 THENLAB=PLABEL
#line 5050 "test-new/nrimp10s-77.imp"
THENLAB = PLABEL;
// 5051 START=0; ! NO START IN CONDITION YET
#line 5051 "test-new/nrimp10s-77.imp"
START = 0;
// 5052 ELSELAB=0; ! MEANS NO ELSE CLAUSE
#line 5052 "test-new/nrimp10s-77.imp"
ELSELAB = 0;
// 5053 P=MARKC
#line 5053 "test-new/nrimp10s-77.imp"
P = MARKC;
// 5054 %IF MARKR>0 %AND A(MARKR)<=2 %THEN START=1;! '%START' OR '%THENSTART'
#line 5054 "test-new/nrimp10s-77.imp"
if (MARKR <= 0) goto L_048D;
#line 5054 "test-new/nrimp10s-77.imp"
if (A[MARKR] > 2) goto L_048D;
#line 5054 "test-new/nrimp10s-77.imp"
START = 1;
#line 5054 "test-new/nrimp10s-77.imp"
L_048D:;
// 5055 %IF MARKE#0 %AND LEVEL<2 %AND START=0 %THEN FAULT(57,0)
#line 5055 "test-new/nrimp10s-77.imp"
if (MARKE == 0) goto L_048E;
#line 5055 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_048E;
#line 5055 "test-new/nrimp10s-77.imp"
if (START != 0) goto L_048E;
#line 5055 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 5055 "test-new/nrimp10s-77.imp"
L_048E:;
// 5056 USERLAB=-1
#line 5056 "test-new/nrimp10s-77.imp"
USERLAB = -1;
// 5057 %IF START#0 %THEN ALTUI=0 %ELSE ALTUI=A(MARKUI)
#line 5057 "test-new/nrimp10s-77.imp"
if (START == 0) goto L_048F;
#line 5057 "test-new/nrimp10s-77.imp"
ALTUI = 0;
#line 5057 "test-new/nrimp10s-77.imp"
goto L_0490;
#line 5057 "test-new/nrimp10s-77.imp"
L_048F:;
#line 5057 "test-new/nrimp10s-77.imp"
ALTUI = A[MARKUI];
#line 5057 "test-new/nrimp10s-77.imp"
L_0490:;
// 5058 %IF ALTUI=2 %AND A(MARKUI+3)=2 %THEN USERLAB=FROM AR2(MARKUI+1); ! UI = SIMPLE LABEL
#line 5058 "test-new/nrimp10s-77.imp"
if (ALTUI != 2) goto L_0491;
#line 5058 "test-new/nrimp10s-77.imp"
if (A[MARKUI + 3] != 2) goto L_0491;
#line 5058 "test-new/nrimp10s-77.imp"
USERLAB = FROMAR2(MARKUI + 1);
#line 5058 "test-new/nrimp10s-77.imp"
L_0491:;
// 5059 %IF 8<=ALTUI<=9 %AND EXITLAB#0 %START; ! VALID EXIT
#line 5059 "test-new/nrimp10s-77.imp"
{
// Double-sided test on ALTUI (Part I)
#line 5059 "test-new/nrimp10s-77.imp"
int tmp;
#line 5059 "test-new/nrimp10s-77.imp"
if (8 > (tmp = ALTUI)) goto L_0492;
// Double-sided test on ALTUI (Part II)
#line 5059 "test-new/nrimp10s-77.imp"
if (tmp > 9) goto L_0492;
#line 5059 "test-new/nrimp10s-77.imp"
}
#line 5059 "test-new/nrimp10s-77.imp"
if (EXITLAB == 0) goto L_0492;
// 5060 %IF ALTUI=8 %THEN USERLAB=EXITLAB %ELSE USERLAB=CONTLAB
#line 5060 "test-new/nrimp10s-77.imp"
if (ALTUI != 8) goto L_0493;
#line 5060 "test-new/nrimp10s-77.imp"
USERLAB = EXITLAB;
#line 5060 "test-new/nrimp10s-77.imp"
goto L_0494;
#line 5060 "test-new/nrimp10s-77.imp"
L_0493:;
#line 5060 "test-new/nrimp10s-77.imp"
USERLAB = CONTLAB;
#line 5060 "test-new/nrimp10s-77.imp"
L_0494:;
// 5061 %FINISH
#line 5061 "test-new/nrimp10s-77.imp"
L_0492:;
// 5062 !
// 5063 %IF SKIP=YES %THEN %START; ! NO CODE NEEDED
#line 5063 "test-new/nrimp10s-77.imp"
if (SKIP != 1) goto L_0495;
// 5064 %IF START#0 %START
#line 5064 "test-new/nrimp10s-77.imp"
if (START == 0) goto L_0496;
// 5065 P=MARKR+1
#line 5065 "test-new/nrimp10s-77.imp"
P = MARKR + 1;
// 5066 CSTART(2,1); ! NO CODE
#line 5066 "test-new/nrimp10s-77.imp"
CSTART(2, 1);
// 5067 MARKE=P
#line 5067 "test-new/nrimp10s-77.imp"
MARKE = P;
// 5068 %FINISH
#line 5068 "test-new/nrimp10s-77.imp"
L_0496:;
// 5069 CCRES=1; ! NO CODE FOR ELSE
#line 5069 "test-new/nrimp10s-77.imp"
CCRES = 1;
// 5070 ->ELSE
#line 5070 "test-new/nrimp10s-77.imp"
goto U_1031;
// 5071 %FINISH
#line 5071 "test-new/nrimp10s-77.imp"
L_0495:;
// 5072 !
// 5073 %IF USERLAB>=0 %THEN %START; ! FIRST UI IS'->'<LABEL>
#line 5073 "test-new/nrimp10s-77.imp"
if (USERLAB < 0) goto L_0497;
// 5074 NMDECS(LEVEL)=NMDECS(LEVEL)!1
#line 5074 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | 1;
// 5075 CCRES=CCOND(0,3-MARKIU,USERLAB)
#line 5075 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 3 - MARKIU, USERLAB);
// 5076 %IF CCRES#0 %THEN CCRES=CCRES!!3;! CONDITION BACKWARDS!
#line 5076 "test-new/nrimp10s-77.imp"
if (CCRES == 0) goto L_0498;
#line 5076 "test-new/nrimp10s-77.imp"
CCRES = CCRES ^ 3;
#line 5076 "test-new/nrimp10s-77.imp"
L_0498:;
// 5077 THENLAB=0; ! NO THENLAB IN THIS CASE
#line 5077 "test-new/nrimp10s-77.imp"
THENLAB = 0;
// 5078 REPORT=1; ! UI TRANSFERED CONTROL
#line 5078 "test-new/nrimp10s-77.imp"
REPORT = 1;
// 5079 %FINISH %ELSE %START
#line 5079 "test-new/nrimp10s-77.imp"
goto L_0499;
#line 5079 "test-new/nrimp10s-77.imp"
L_0497:;
// 5080 CCRES=CCOND(1,MARKIU,THENLAB)
#line 5080 "test-new/nrimp10s-77.imp"
CCRES = CCOND(1, MARKIU, THENLAB);
// 5081 %IF START#0 %THEN %START; ! %THEN %START
#line 5081 "test-new/nrimp10s-77.imp"
if (START == 0) goto L_049A;
// 5082 %IF CCRES=0 %START; ! CONDITIONAL
#line 5082 "test-new/nrimp10s-77.imp"
if (CCRES != 0) goto L_049B;
// 5083 FAULT(57,0) %IF LEVEL<2
#line 5083 "test-new/nrimp10s-77.imp"
if (LEVEL >= 2) goto L_049C;
#line 5083 "test-new/nrimp10s-77.imp"
FAULT(57, 0);
#line 5083 "test-new/nrimp10s-77.imp"
L_049C:;
// 5084 NMDECS(LEVEL)=NMDECS(LEVEL)!1
#line 5084 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | 1;
// 5085 %FINISH
#line 5085 "test-new/nrimp10s-77.imp"
L_049B:;
// 5086 P=MARKR+1
#line 5086 "test-new/nrimp10s-77.imp"
P = MARKR + 1;
// 5087 CSTART(CCRES,1)
#line 5087 "test-new/nrimp10s-77.imp"
CSTART(CCRES, 1);
// 5088 %IF A(P)<=2 %THEN PLABEL=PLABEL-1 %AND ELSELAB=PLABEL
#line 5088 "test-new/nrimp10s-77.imp"
if (A[P] > 2) goto L_049D;
#line 5088 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
#line 5088 "test-new/nrimp10s-77.imp"
ELSELAB = PLABEL;
#line 5088 "test-new/nrimp10s-77.imp"
L_049D:;
// 5089 MARKE=P
#line 5089 "test-new/nrimp10s-77.imp"
MARKE = P;
// 5090 REPORT=LAST INST
#line 5090 "test-new/nrimp10s-77.imp"
REPORT = LASTINST;
// 5091 %FINISH %ELSE %START
#line 5091 "test-new/nrimp10s-77.imp"
goto L_049E;
#line 5091 "test-new/nrimp10s-77.imp"
L_049A:;
// 5092 %IF CCRES#2 %START
#line 5092 "test-new/nrimp10s-77.imp"
if (CCRES == 2) goto L_049F;
// 5093 P=MARKUI; CUI(1)
#line 5093 "test-new/nrimp10s-77.imp"
P = MARKUI;
#line 5093 "test-new/nrimp10s-77.imp"
CUI(1);
// 5094 REPORT=REPORTUI
#line 5094 "test-new/nrimp10s-77.imp"
REPORT = REPORTUI;
// 5095 %FINISH %ELSE %START; ! FIRST UI NEVER EXECUTED
#line 5095 "test-new/nrimp10s-77.imp"
goto L_04A0;
#line 5095 "test-new/nrimp10s-77.imp"
L_049F:;
// 5096 REPORT=1
#line 5096 "test-new/nrimp10s-77.imp"
REPORT = 1;
// 5097 %FINISH
#line 5097 "test-new/nrimp10s-77.imp"
L_04A0:;
// 5098 %FINISH
#line 5098 "test-new/nrimp10s-77.imp"
L_049E:;
// 5099 %FINISH
#line 5099 "test-new/nrimp10s-77.imp"
L_0499:;
// 5100 ELSE: ! ELSE PART
#line 5100 "test-new/nrimp10s-77.imp"
U_1031:;
// 5101 %IF MARKE=0 %THEN ELSEALT=NULL ELSE %ELSE ELSEALT=A(MARKE)
#line 5101 "test-new/nrimp10s-77.imp"
if (MARKE != 0) goto L_04A1;
#line 5101 "test-new/nrimp10s-77.imp"
ELSEALT = 4;
#line 5101 "test-new/nrimp10s-77.imp"
goto L_04A2;
#line 5101 "test-new/nrimp10s-77.imp"
L_04A1:;
#line 5101 "test-new/nrimp10s-77.imp"
ELSEALT = A[MARKE];
#line 5101 "test-new/nrimp10s-77.imp"
L_04A2:;
// 5102 %IF ELSEALT<NULL ELSE %THEN PLABEL=PLABEL-1 %AND ELSELAB=PLABEL
#line 5102 "test-new/nrimp10s-77.imp"
if (ELSEALT >= 4) goto L_04A3;
#line 5102 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
#line 5102 "test-new/nrimp10s-77.imp"
ELSELAB = PLABEL;
#line 5102 "test-new/nrimp10s-77.imp"
L_04A3:;
// 5103 P=MARKE+1
#line 5103 "test-new/nrimp10s-77.imp"
P = MARKE + 1;
// 5104 %IF REPORT=0=CCRES %AND ELSEALT<NULL ELSE %THEN REPORT=1 %AND ENTER JUMP(15,ELSELAB,B'10');! LONG JUMP BUT SAVE ENV
#line 5104 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 5104 "test-new/nrimp10s-77.imp"
int tmp;
#line 5104 "test-new/nrimp10s-77.imp"
if (REPORT != (tmp = 0)) goto L_04A4;
// Double-sided test on 0 (Part II)
#line 5104 "test-new/nrimp10s-77.imp"
if (tmp != CCRES) goto L_04A4;
#line 5104 "test-new/nrimp10s-77.imp"
}
#line 5104 "test-new/nrimp10s-77.imp"
if (ELSEALT >= 4) goto L_04A4;
#line 5104 "test-new/nrimp10s-77.imp"
REPORT = 1;
#line 5104 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, ELSELAB, 2);
#line 5104 "test-new/nrimp10s-77.imp"
L_04A4:;
// 5105 %IF THENLAB>0 %THEN ELRES=ENTER LAB(THENLAB,B'11'!REPORT<<2)
#line 5105 "test-new/nrimp10s-77.imp"
if (THENLAB <= 0) goto L_04A5;
#line 5105 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(THENLAB, 3 | REPORT << 2);
#line 5105 "test-new/nrimp10s-77.imp"
L_04A5:;
// 5106 ! CONDITIONAL&MERGE OR REPLACE
// 5107 ->ESW(ELSEALT)
#line 5107 "test-new/nrimp10s-77.imp"
ESW_line = __LINE__;
ESW_file = __FILE__;
ESW_index = ELSEALT;
goto case_ESW_dispatch;
// 5108 ESW(1): ! '%ELSESTART'
#line 5108 "test-new/nrimp10s-77.imp"
case_ESW_1:;
// 5109 %IF CCRES=0 %THEN NMDECS(LEVEL)=NMDECS(LEVEL)!1
#line 5109 "test-new/nrimp10s-77.imp"
if (CCRES != 0) goto L_04A7;
#line 5109 "test-new/nrimp10s-77.imp"
NMDECS[LEVEL] = NMDECS[LEVEL] | 1;
#line 5109 "test-new/nrimp10s-77.imp"
L_04A7:;
// 5110 CSTART(CCRES,2)
#line 5110 "test-new/nrimp10s-77.imp"
CSTART(CCRES, 2);
// 5111 REPORT=LAST INST
#line 5111 "test-new/nrimp10s-77.imp"
REPORT = LASTINST;
// 5112 ->ENTER ELSELAB
#line 5112 "test-new/nrimp10s-77.imp"
goto U_1032;
// 5113 ESW(2): ! '%ELSE' (%IU) ETC
#line 5113 "test-new/nrimp10s-77.imp"
case_ESW_2:;
// 5114 MARKE=0; MARKUI=0
#line 5114 "test-new/nrimp10s-77.imp"
MARKE = 0;
#line 5114 "test-new/nrimp10s-77.imp"
MARKUI = 0;
// 5115 MARKR=P+1+FROMAR2(P+1)
#line 5115 "test-new/nrimp10s-77.imp"
MARKR = P + 1 + FROMAR2(P + 1);
// 5116 %IF A(MARKR)=3 %THEN %START
#line 5116 "test-new/nrimp10s-77.imp"
if (A[MARKR] != 3) goto L_04A8;
// 5117 MARKE=MARKR+1+FROM AR2(MARKR+1)
#line 5117 "test-new/nrimp10s-77.imp"
MARKE = MARKR + 1 + FROMAR2(MARKR + 1);
// 5118 MARKUI=MARKR+3
#line 5118 "test-new/nrimp10s-77.imp"
MARKUI = MARKR + 3;
// 5119 %FINISH
#line 5119 "test-new/nrimp10s-77.imp"
L_04A8:;
// 5120 %IF CCRES=1 %OR SKIP=YES %THEN K=YES %ELSE K=NO
#line 5120 "test-new/nrimp10s-77.imp"
if (CCRES == 1) goto L_04A9;
#line 5120 "test-new/nrimp10s-77.imp"
if (SKIP != 1) goto L_04AA;
#line 5120 "test-new/nrimp10s-77.imp"
L_04A9:;
#line 5120 "test-new/nrimp10s-77.imp"
K = 1;
#line 5120 "test-new/nrimp10s-77.imp"
goto L_04AB;
#line 5120 "test-new/nrimp10s-77.imp"
L_04AA:;
#line 5120 "test-new/nrimp10s-77.imp"
K = 0;
#line 5120 "test-new/nrimp10s-77.imp"
L_04AB:;
// 5121 CIFTHEN(P,P+3,MARKUI,MARKE,MARKR,K)
#line 5121 "test-new/nrimp10s-77.imp"
CIFTHEN(P, P + 3, MARKUI, MARKE, MARKR, K);
// 5122 ->ENTER ELSELAB
#line 5122 "test-new/nrimp10s-77.imp"
goto U_1032;
// 5123 ESW(3): ! '%ELSE'<UI>
#line 5123 "test-new/nrimp10s-77.imp"
case_ESW_3:;
// 5124 %IF CCRES#1 %THEN %START
#line 5124 "test-new/nrimp10s-77.imp"
if (CCRES == 1) goto L_04AC;
// 5125 %IF START#0 %THEN SET LINE; ! FOR CORRECT LINE IF FAILS IN UI
#line 5125 "test-new/nrimp10s-77.imp"
if (START == 0) goto L_04AD;
#line 5125 "test-new/nrimp10s-77.imp"
SETLINE();
#line 5125 "test-new/nrimp10s-77.imp"
L_04AD:;
// 5126 %IF THENLAB=0 %THEN K=0 %ELSE K=2
#line 5126 "test-new/nrimp10s-77.imp"
if (THENLAB != 0) goto L_04AE;
#line 5126 "test-new/nrimp10s-77.imp"
K = 0;
#line 5126 "test-new/nrimp10s-77.imp"
goto L_04AF;
#line 5126 "test-new/nrimp10s-77.imp"
L_04AE:;
#line 5126 "test-new/nrimp10s-77.imp"
K = 2;
#line 5126 "test-new/nrimp10s-77.imp"
L_04AF:;
// 5127 CUI(K)
#line 5127 "test-new/nrimp10s-77.imp"
CUI(K);
// 5128 REPORT=REPORTUI
#line 5128 "test-new/nrimp10s-77.imp"
REPORT = REPORTUI;
// 5129 %FINISH
#line 5129 "test-new/nrimp10s-77.imp"
L_04AC:;
// 5130 ENTER ELSELAB:
#line 5130 "test-new/nrimp10s-77.imp"
U_1032:;
// 5131 %IF ELSELAB>0 %THEN ELRES=ENTER LAB(ELSELAB,B'11'!REPORT<<2)
#line 5131 "test-new/nrimp10s-77.imp"
if (ELSELAB <= 0) goto L_04B0;
#line 5131 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(ELSELAB, 3 | REPORT << 2);
#line 5131 "test-new/nrimp10s-77.imp"
L_04B0:;
// 5132 ! CONDITIONAL MERGE
// 5133 ESW(NULL ELSE): ! NULL ELSE CLAUSE
#line 5133 "test-new/nrimp10s-77.imp"
case_ESW_4:;
// 5134 %END
#line 5134 "test-new/nrimp10s-77.imp"
return;
#line 5134 "test-new/nrimp10s-77.imp"
case_ESW_dispatch:
#line 5134 "test-new/nrimp10s-77.imp"
if (ESW_index < 1 || ESW_index > 4)
_imp_signalf(6, 3, ESW_index, "->ESW(%d) out of bounds at %s line %d", ESW_index, ESW_file, ESW_line);
#line 5134 "test-new/nrimp10s-77.imp"
goto *ESW[ESW_index - 1];
#line 5134 "test-new/nrimp10s-77.imp"
case_ESW_missing:
_imp_signalf(8, 2, ESW_index, "switch jump to undefined label ESW(%d): at %s line %d", ESW_index, ESW_file,
ESW_line);
#line 5134 "test-new/nrimp10s-77.imp"
} /* end of CIFTHEN */
// 5135 %ROUTINE CSTART(%INTEGER CCRES,CODE)
#line 5135 "test-new/nrimp10s-77.imp"
void CSTART(int CCRES, int CODE) {
// 5136 !***********************************************************************
// 5137 !* COMPILE A COMPLETE START-FINISH BLOCK BY RECURSION *
// 5138 !* IF START NEVER EXECUTED SKIP TO CORRESPONDING FINISH *
// 5139 !* CODE=0 WAS UNCONDITIONAL NOW SHOULD BE UNUSED *
// 5140 !* CODE=1 AFTER THEN *
// 5141 !* CODE=2 AFTER ELSE *
// 5142 !* CODE=3 AFTER ONEVENT *
// 5143 !* P ON ENTRY TO FORWARD POINTER TO THE RIGHT FINISH *
// 5144 !* P ON EXIT TO THE ELSE CLAUSE AFTER THE RIGHT FINISH *
// 5145 !***********************************************************************
// 5146 %INTEGER SKIPCODE,FINISHAR,OLDNEXTP,OLDLINE
#line 5146 "test-new/nrimp10s-77.imp"
int SKIPCODE;
#line 5146 "test-new/nrimp10s-77.imp"
int FINISHAR;
#line 5146 "test-new/nrimp10s-77.imp"
int OLDNEXTP;
#line 5146 "test-new/nrimp10s-77.imp"
int OLDLINE;
// 5147 SKIPCODE=NO
#line 5147 "test-new/nrimp10s-77.imp"
SKIPCODE = 0;
// 5148 %IF 1<=CODE<=2 %AND CCRES!CODE=3 %THEN SKIPCODE=YES;! NEVER EXECUTED
#line 5148 "test-new/nrimp10s-77.imp"
{
// Double-sided test on CODE (Part I)
#line 5148 "test-new/nrimp10s-77.imp"
int tmp;
#line 5148 "test-new/nrimp10s-77.imp"
if (1 > (tmp = CODE)) goto L_04B1;
// Double-sided test on CODE (Part II)
#line 5148 "test-new/nrimp10s-77.imp"
if (tmp > 2) goto L_04B1;
#line 5148 "test-new/nrimp10s-77.imp"
}
#line 5148 "test-new/nrimp10s-77.imp"
if (CCRES | CODE != 3) goto L_04B1;
#line 5148 "test-new/nrimp10s-77.imp"
SKIPCODE = 1;
#line 5148 "test-new/nrimp10s-77.imp"
L_04B1:;
// 5149 FINISHAR=FROMAR4(P); ! TO START OF AR FOR FINISH
#line 5149 "test-new/nrimp10s-77.imp"
FINISHAR = FROMAR4(P);
// 5150 %IF FINISHAR<=P %THEN ABORT; ! FOR TESTING
#line 5150 "test-new/nrimp10s-77.imp"
if (FINISHAR > P) goto L_04B2;
#line 5150 "test-new/nrimp10s-77.imp"
ABORT();
#line 5150 "test-new/nrimp10s-77.imp"
L_04B2:;
// 5151 OLDLINE=LINE; ! FOR ERROR MESSAGES
#line 5151 "test-new/nrimp10s-77.imp"
OLDLINE = LINE;
// 5152 %CYCLE; ! THROUGH INTERVENING STATMNTS {I didn't change this one. Looks like both forms of until were accepted.}
#line 5152 "test-new/nrimp10s-77.imp"
L_04B3:;
// 5153 OLDNEXTP=NEXTP
#line 5153 "test-new/nrimp10s-77.imp"
OLDNEXTP = NEXTP;
// 5154 %IF SKIP CODE=NO %THEN COMPILE A STMNT %ELSE %START
#line 5154 "test-new/nrimp10s-77.imp"
if (SKIPCODE != 0) goto L_04B4;
#line 5154 "test-new/nrimp10s-77.imp"
COMPILEASTMNT();
#line 5154 "test-new/nrimp10s-77.imp"
goto L_04B5;
#line 5154 "test-new/nrimp10s-77.imp"
L_04B4:;
// 5155 LINE=A(NEXTP+3)<<8!A(NEXTP+4)
#line 5155 "test-new/nrimp10s-77.imp"
LINE = A[NEXTP + 3] << 8 | A[NEXTP + 4];
// 5156 NEXTP=NEXTP+A(NEXTP)<<16+A(NEXTP+1)<<8+A(NEXTP+2)
#line 5156 "test-new/nrimp10s-77.imp"
NEXTP = NEXTP + (A[NEXTP] << 16) + (A[NEXTP + 1] << 8) + A[NEXTP + 2];
// 5157 %FINISH
#line 5157 "test-new/nrimp10s-77.imp"
L_04B5:;
// 5158 %REPEAT %UNTIL OLDNEXTP>=FINISHAR;! HAVING COMPILED FINISH
#line 5158 "test-new/nrimp10s-77.imp"
if (OLDNEXTP >= FINISHAR) goto L_04B6;
#line 5158 "test-new/nrimp10s-77.imp"
goto L_04B3;
#line 5158 "test-new/nrimp10s-77.imp"
L_04B6:;
// 5159 P=FINISHAR+6; ! TO ELSE CLAUSE
#line 5159 "test-new/nrimp10s-77.imp"
P = FINISHAR + 6;
// 5160 !
// 5161 %IF A(P)<=2 %AND CODE#1 %THEN FAULT2(45+CODE,OLDLINE,0)
#line 5161 "test-new/nrimp10s-77.imp"
if (A[P] > 2) goto L_04B7;
#line 5161 "test-new/nrimp10s-77.imp"
if (CODE == 1) goto L_04B7;
#line 5161 "test-new/nrimp10s-77.imp"
FAULT2(45 + CODE, OLDLINE, 0);
#line 5161 "test-new/nrimp10s-77.imp"
L_04B7:;
// 5162 %IF SKIPCODE=YES %THEN LAST INST=1
#line 5162 "test-new/nrimp10s-77.imp"
if (SKIPCODE != 1) goto L_04B8;
#line 5162 "test-new/nrimp10s-77.imp"
LASTINST = 1;
#line 5162 "test-new/nrimp10s-77.imp"
L_04B8:;
// 5163 %END
#line 5163 "test-new/nrimp10s-77.imp"
return;
#line 5163 "test-new/nrimp10s-77.imp"
} /* end of CSTART */
// 5164 %ROUTINE CCYCBODY(%INTEGER UA,ELAB,CLAB)
#line 5164 "test-new/nrimp10s-77.imp"
void CCYCBODY(int UA, int ELAB, int CLAB) {
// 5165 !***********************************************************************
// 5166 !* COMPILES A CYCLE REPEAT BODY BY RECURSION *
// 5167 !* ON ENTRY P IS TO FORWARD POINTER. ON EXIT TO ALT OF UNTIL *
// 5168 !* UA = O IF UNTIL NOT ALLOWED *
// 5169 !* ELAB&CLAB ARE LABELS FOR ELSE & CONTINUE *
// 5170 !***********************************************************************
// 5171 %INTEGER FINISHAR,OLDLINE,SAVEE,SAVEC
#line 5171 "test-new/nrimp10s-77.imp"
int FINISHAR;
#line 5171 "test-new/nrimp10s-77.imp"
int OLDLINE;
#line 5171 "test-new/nrimp10s-77.imp"
int SAVEE;
#line 5171 "test-new/nrimp10s-77.imp"
int SAVEC;
// 5172 FINISHAR=FROMAR4(P)
#line 5172 "test-new/nrimp10s-77.imp"
FINISHAR = FROMAR4(P);
// 5173 %IF FINISHAR<=P %THEN ABORT
#line 5173 "test-new/nrimp10s-77.imp"
if (FINISHAR > P) goto L_04B9;
#line 5173 "test-new/nrimp10s-77.imp"
ABORT();
#line 5173 "test-new/nrimp10s-77.imp"
L_04B9:;
// 5174 OLDLINE=LINE; SAVEE=EXIT LAB; SAVEC=CONTLAB
#line 5174 "test-new/nrimp10s-77.imp"
OLDLINE = LINE;
#line 5174 "test-new/nrimp10s-77.imp"
SAVEE = EXITLAB;
#line 5174 "test-new/nrimp10s-77.imp"
SAVEC = CONTLAB;
// 5175 EXITLAB=ELAB; CONTLAB=CLAB
#line 5175 "test-new/nrimp10s-77.imp"
EXITLAB = ELAB;
#line 5175 "test-new/nrimp10s-77.imp"
CONTLAB = CLAB;
// 5176 %WHILE NEXTP<=FINISHAR %CYCLE
#line 5176 "test-new/nrimp10s-77.imp"
L_04BA:;
#line 5176 "test-new/nrimp10s-77.imp"
if (NEXTP > FINISHAR) goto L_04BB;
// 5177 COMPILE A STMNT
#line 5177 "test-new/nrimp10s-77.imp"
COMPILEASTMNT();
// 5178 %REPEAT
#line 5178 "test-new/nrimp10s-77.imp"
goto L_04BA;
#line 5178 "test-new/nrimp10s-77.imp"
L_04BB:;
// 5179 EXIT LAB=SAVEE; CONTLAB=SAVEC
#line 5179 "test-new/nrimp10s-77.imp"
EXITLAB = SAVEE;
#line 5179 "test-new/nrimp10s-77.imp"
CONTLAB = SAVEC;
// 5180 P=FINISHAR+6
#line 5180 "test-new/nrimp10s-77.imp"
P = FINISHAR + 6;
// 5181 %IF A(P)=1 %AND UA=0 %THEN FAULT2(12,OLDLINE,0)
#line 5181 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_04BC;
#line 5181 "test-new/nrimp10s-77.imp"
if (UA != 0) goto L_04BC;
#line 5181 "test-new/nrimp10s-77.imp"
FAULT2(12, OLDLINE, 0);
#line 5181 "test-new/nrimp10s-77.imp"
L_04BC:;
// 5182 %END
#line 5182 "test-new/nrimp10s-77.imp"
return;
#line 5182 "test-new/nrimp10s-77.imp"
} /* end of CCYCBODY */
// 5183
// 5184 %ROUTINE CLOOP(%INTEGER ALT, MARKC, MARKUI)
#line 5184 "test-new/nrimp10s-77.imp"
void CLOOP(int ALT, int MARKC, int MARKUI) {
// 5185 !***********************************************************************
// 5186 !* ALT=1 FOR %WHILE, =2 FOR %UNTIL, =3 FOR %FOR *
// 5187 !* MARKC IS TO THE CONDITION OR CONTROL CLAUSE *
// 5188 !* MARKUI IS TO THE UI, SPECIAL FOR %CYCLE *
// 5189 !***********************************************************************
// 5190 %INTEGER L1,L2,L3,CCRES,ELRES
#line 5190 "test-new/nrimp10s-77.imp"
int L1;
#line 5190 "test-new/nrimp10s-77.imp"
int L2;
#line 5190 "test-new/nrimp10s-77.imp"
int L3;
#line 5190 "test-new/nrimp10s-77.imp"
int CCRES;
#line 5190 "test-new/nrimp10s-77.imp"
int ELRES;
// 5191 %INTEGER FORNAME,INITTYPE,INITVAL,STEPTYPE,STEPVAL,FINALTYPE,FINALVAL,FACC,FDISP,FBASE,INITP,REPMASK,USEDEBJ,DEBTO
#line 5191 "test-new/nrimp10s-77.imp"
int FORNAME;
#line 5191 "test-new/nrimp10s-77.imp"
int INITTYPE;
#line 5191 "test-new/nrimp10s-77.imp"
int INITVAL;
#line 5191 "test-new/nrimp10s-77.imp"
int STEPTYPE;
#line 5191 "test-new/nrimp10s-77.imp"
int STEPVAL;
#line 5191 "test-new/nrimp10s-77.imp"
int FINALTYPE;
#line 5191 "test-new/nrimp10s-77.imp"
int FINALVAL;
#line 5191 "test-new/nrimp10s-77.imp"
int FACC;
#line 5191 "test-new/nrimp10s-77.imp"
int FDISP;
#line 5191 "test-new/nrimp10s-77.imp"
int FBASE;
#line 5191 "test-new/nrimp10s-77.imp"
int INITP;
#line 5191 "test-new/nrimp10s-77.imp"
int REPMASK;
#line 5191 "test-new/nrimp10s-77.imp"
int USEDEBJ;
#line 5191 "test-new/nrimp10s-77.imp"
int DEBTO;
#line 5191 "test-new/nrimp10s-77.imp"
auto void FOREXP(int *ETYPE, int *EVALUE, int TOTEMP, int USEREG);
#line 5191 "test-new/nrimp10s-77.imp"
auto void VALIDATEFOR(void);
// 5192 %ROUTINESPEC FOREXP(%INTEGERNAME ETYPE,EVALUE,%INTEGER TT,REG)
// 5193 %ROUTINESPEC VALIDATE FOR
// 5194 %SWITCH SW(0:6)
#line 5194 "test-new/nrimp10s-77.imp"
int SW_index;
#line 5194 "test-new/nrimp10s-77.imp"
int SW_line;
#line 5194 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 5194 "test-new/nrimp10s-77.imp"
static const void *SW[7] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 5195 P=MARKC
#line 5195 "test-new/nrimp10s-77.imp"
P = MARKC;
// 5196 SFLABEL=SFLABEL-2
#line 5196 "test-new/nrimp10s-77.imp"
SFLABEL = SFLABEL - 2;
// 5197 L1=SFLABEL; L2=L1+1
#line 5197 "test-new/nrimp10s-77.imp"
L1 = SFLABEL;
#line 5197 "test-new/nrimp10s-77.imp"
L2 = L1 + 1;
// 5198 !
// 5199 ! SET L3 FOR ALTS 0,5&6 ONLY
// 5200 !
// 5201 L3=0
#line 5201 "test-new/nrimp10s-77.imp"
L3 = 0;
// 5202 %IF B'1100001'&1<<ALT#0 %THEN L3=SFLABEL-1 %AND SFLABEL=L3
#line 5202 "test-new/nrimp10s-77.imp"
if (97 & 1 << ALT == 0) goto L_04BD;
#line 5202 "test-new/nrimp10s-77.imp"
L3 = SFLABEL - 1;
#line 5202 "test-new/nrimp10s-77.imp"
SFLABEL = L3;
#line 5202 "test-new/nrimp10s-77.imp"
L_04BD:;
// 5203 !
// 5204 ! UPDATE THE LINE NUMBER FOR ALTS 1 TO 3 ONLY
// 5205 !
// 5206 %IF 1<=ALT<=3 %THEN SET LINE
#line 5206 "test-new/nrimp10s-77.imp"
{
// Double-sided test on ALT (Part I)
#line 5206 "test-new/nrimp10s-77.imp"
int tmp;
#line 5206 "test-new/nrimp10s-77.imp"
if (1 > (tmp = ALT)) goto L_04BE;
// Double-sided test on ALT (Part II)
#line 5206 "test-new/nrimp10s-77.imp"
if (tmp > 3) goto L_04BE;
#line 5206 "test-new/nrimp10s-77.imp"
}
#line 5206 "test-new/nrimp10s-77.imp"
SETLINE();
#line 5206 "test-new/nrimp10s-77.imp"
L_04BE:;
// 5207 !
// 5208 ! ENTER THE FIRST LABEL(L1) FOR ALL ALTS EXCEPT 3 & 6
// 5209 !
// 5210 %IF B'0110111'&1<<ALT#0 %THEN ELRES=ENTER LAB(L1,0)
#line 5210 "test-new/nrimp10s-77.imp"
if (55 & 1 << ALT == 0) goto L_04BF;
#line 5210 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L1, 0);
#line 5210 "test-new/nrimp10s-77.imp"
L_04BF:;
// 5211 ->SW(ALT)
#line 5211 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = ALT;
goto case_SW_dispatch;
// 5212 SW(0): ! %CYCLE
#line 5212 "test-new/nrimp10s-77.imp"
case_SW_0:;
// 5213 C CYC BODY(1,L2,L3)
#line 5213 "test-new/nrimp10s-77.imp"
CCYCBODY(1, L2, L3);
// 5214 ELRES=ENTER LAB(L3,B'011')
#line 5214 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L3, 3);
// 5215 %IF A(P)=1 %START; ! %REPEAT %UNTIL <COND>
#line 5215 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_04C1;
// 5216 P=P+1; CCRES=CCOND(0,1,L1)
#line 5216 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 5216 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 1, L1);
// 5217 %FINISH %ELSE ENTER JUMP(15,L1,0)
#line 5217 "test-new/nrimp10s-77.imp"
goto L_04C2;
#line 5217 "test-new/nrimp10s-77.imp"
L_04C1:;
#line 5217 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, L1, 0);
#line 5217 "test-new/nrimp10s-77.imp"
L_04C2:;
// 5218 ELRES=ENTER LAB(L2,B'011')
#line 5218 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L2, 3);
// 5219 WAYOUT: ! REMOVE LABELS NOT REQUIRED
#line 5219 "test-new/nrimp10s-77.imp"
U_1027:;
// 5220 REMOVE LAB(L1)
#line 5220 "test-new/nrimp10s-77.imp"
REMOVELAB(L1);
// 5221 REMOVE LAB(L2)
#line 5221 "test-new/nrimp10s-77.imp"
REMOVELAB(L2);
// 5222 REMOVE LAB(L3) %IF L3>0
#line 5222 "test-new/nrimp10s-77.imp"
if (L3 <= 0) goto L_04C3;
#line 5222 "test-new/nrimp10s-77.imp"
REMOVELAB(L3);
#line 5222 "test-new/nrimp10s-77.imp"
L_04C3:;
// 5223 %RETURN
#line 5223 "test-new/nrimp10s-77.imp"
return;
// 5224 SW(1): ! UI WHILE COND
#line 5224 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 5225 CCRES=CCOND(0,1,L2)
#line 5225 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 1, L2);
// 5226 P=MARKUI
#line 5226 "test-new/nrimp10s-77.imp"
P = MARKUI;
// 5227 CUI(1)
#line 5227 "test-new/nrimp10s-77.imp"
CUI(1);
// 5228 ENTERJUMP(15,L1,0); ! UNCONDITIONALLY BACK TO WHILE
#line 5228 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, L1, 0);
// 5229 ELRES =ENTER LAB(L2,B'111'); ! CONDITIONAL(?) & REPLACE ENV
#line 5229 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L2, 7);
// 5230 ->WAYOUT
#line 5230 "test-new/nrimp10s-77.imp"
goto U_1027;
// 5231 SW(2): ! UI %UNTIL COND
#line 5231 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 5232 P=MARKUI
#line 5232 "test-new/nrimp10s-77.imp"
P = MARKUI;
// 5233 CUI(1)
#line 5233 "test-new/nrimp10s-77.imp"
CUI(1);
// 5234 P=MARKC
#line 5234 "test-new/nrimp10s-77.imp"
P = MARKC;
// 5235 CCRES=CCOND(0,1,L1)
#line 5235 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 1, L1);
// 5236 ->WAYOUT
#line 5236 "test-new/nrimp10s-77.imp"
goto U_1027;
// 5237 SW(3): ! UI %FOR ....
#line 5237 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 5238 SW(6): ! %FOR ... %CYCLE
#line 5238 "test-new/nrimp10s-77.imp"
case_SW_6:;
// 5239
// 5240 FORNAME=FROMAR2(P)
#line 5240 "test-new/nrimp10s-77.imp"
FORNAME = FROMAR2(P);
// 5241 INITP=P+2; P=INITP
#line 5241 "test-new/nrimp10s-77.imp"
INITP = P + 2;
#line 5241 "test-new/nrimp10s-77.imp"
P = INITP;
// 5242 COPY TAG(FORNAME)
#line 5242 "test-new/nrimp10s-77.imp"
COPYTAG(FORNAME);
// 5243 FDISP=K; FBASE=I; FACC=2*NAM
#line 5243 "test-new/nrimp10s-77.imp"
FDISP = K;
#line 5243 "test-new/nrimp10s-77.imp"
FBASE = I;
#line 5243 "test-new/nrimp10s-77.imp"
FACC = 2 * NAM;
// 5244 FAULT2(91,0,FORNAME) %UNLESS TYPE=1 %AND PREC=5 %AND ROUT=0=ARR
#line 5244 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_04C4;
#line 5244 "test-new/nrimp10s-77.imp"
if (PREC != 5) goto L_04C4;
#line 5244 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 5244 "test-new/nrimp10s-77.imp"
int tmp;
#line 5244 "test-new/nrimp10s-77.imp"
if (ROUT != (tmp = 0)) goto L_04C4;
// Double-sided test on 0 (Part II)
#line 5244 "test-new/nrimp10s-77.imp"
if (tmp == ARR) goto L_04C5;
#line 5244 "test-new/nrimp10s-77.imp"
}
#line 5244 "test-new/nrimp10s-77.imp"
L_04C4:;
#line 5244 "test-new/nrimp10s-77.imp"
FAULT2(91, 0, FORNAME);
#line 5244 "test-new/nrimp10s-77.imp"
L_04C5:;
// 5245 WARN(4,FORNAME) %UNLESS FBASE=RBASE
#line 5245 "test-new/nrimp10s-77.imp"
if (FBASE == RBASE) goto L_04C6;
#line 5245 "test-new/nrimp10s-77.imp"
WARN(4, FORNAME);
#line 5245 "test-new/nrimp10s-77.imp"
L_04C6:;
// 5246 !
// 5247 SKIP EXP; ! P TO STEP EXPRSN
#line 5247 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 5248 FOR EXP(STEPTYPE,STEPVAL,1,ACCR); ! STEP TO ACCR AND TEMP
#line 5248 "test-new/nrimp10s-77.imp"
FOREXP(/*?*/ &STEPTYPE, /*?*/ &STEPVAL, 1, 0);
// 5249 %IF STEPTYPE=0 %START
#line 5249 "test-new/nrimp10s-77.imp"
if (STEPTYPE != 0) goto L_04C7;
// 5250 FAULT2(92,0,0) %IF STEPVAL=0; ! ZERO STEP
#line 5250 "test-new/nrimp10s-77.imp"
if (STEPVAL != 0) goto L_04C8;
#line 5250 "test-new/nrimp10s-77.imp"
FAULT2(92, 0, 0);
#line 5250 "test-new/nrimp10s-77.imp"
L_04C8:;
// 5251 %FINISH %ELSE %START
#line 5251 "test-new/nrimp10s-77.imp"
goto L_04C9;
#line 5251 "test-new/nrimp10s-77.imp"
L_04C7:;
// 5252 %IF PARMOPT#0 %THEN PPJ(26,11);! FAULT COMPUTED ZERO STEP
#line 5252 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_04CA;
#line 5252 "test-new/nrimp10s-77.imp"
PPJ(26, 11);
#line 5252 "test-new/nrimp10s-77.imp"
L_04CA:;
// 5253 %FINISH
#line 5253 "test-new/nrimp10s-77.imp"
L_04C9:;
// 5254 !
// 5255 FOR EXP(FINALTYPE,FINALVAL,1,ACCR);! EVALUATE FINAL
#line 5255 "test-new/nrimp10s-77.imp"
FOREXP(/*?*/ &FINALTYPE, /*?*/ &FINALVAL, 1, 0);
// 5256 !
// 5257 P=INITP
#line 5257 "test-new/nrimp10s-77.imp"
P = INITP;
// 5258 FOR EXP(INITTYPE,INITVAL,0,BREG);! INITIAL VALUE TO B
#line 5258 "test-new/nrimp10s-77.imp"
FOREXP(/*?*/ &INITTYPE, /*?*/ &INITVAL, 0, 7);
// 5259 %IF PARMOPT#0 %THEN VALIDATE FOR
#line 5259 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_04CB;
#line 5259 "test-new/nrimp10s-77.imp"
VALIDATEFOR();
#line 5259 "test-new/nrimp10s-77.imp"
L_04CB:;
// 5260 !
// 5261 USEDEBJ=0; ! DONT USE IT
#line 5261 "test-new/nrimp10s-77.imp"
USEDEBJ = 0;
// 5262 %IF STEPVAL=-1 %AND FINALTYPE!STEPTYPE=0 %AND FINALVAL=1 %START
#line 5262 "test-new/nrimp10s-77.imp"
if (STEPVAL != -1) goto L_04CC;
#line 5262 "test-new/nrimp10s-77.imp"
if (FINALTYPE | STEPTYPE != 0) goto L_04CC;
#line 5262 "test-new/nrimp10s-77.imp"
if (FINALVAL != 1) goto L_04CC;
// 5263 USEDEBJ=1; ! CAN USE BEST BRANCH INSTRN
#line 5263 "test-new/nrimp10s-77.imp"
USEDEBJ = 1;
// 5264 PSF1(LB,0,INITVAL) %IF INITTYPE=0
#line 5264 "test-new/nrimp10s-77.imp"
if (INITTYPE != 0) goto L_04CD;
#line 5264 "test-new/nrimp10s-77.imp"
PSF1(122, 0, INITVAL);
#line 5264 "test-new/nrimp10s-77.imp"
L_04CD:;
// 5265 %UNLESS INITTYPE=0 %AND INITVAL>=1 %THEN ENTERJUMP(32+13,L2,B'10'); ! JAF B>0 NO TRAVERSES
#line 5265 "test-new/nrimp10s-77.imp"
if (INITTYPE != 0) goto L_04CE;
#line 5265 "test-new/nrimp10s-77.imp"
if (INITVAL >= 1) goto L_04CF;
#line 5265 "test-new/nrimp10s-77.imp"
L_04CE:;
#line 5265 "test-new/nrimp10s-77.imp"
ENTERJUMP(32 + 13, L2, 2);
#line 5265 "test-new/nrimp10s-77.imp"
L_04CF:;
// 5266 DEBTO=CA; ! SAVE CA FOR DEBJ
#line 5266 "test-new/nrimp10s-77.imp"
DEBTO = CA;
// 5267 %FINISH %ELSE %START
#line 5267 "test-new/nrimp10s-77.imp"
goto L_04D0;
#line 5267 "test-new/nrimp10s-77.imp"
L_04CC:;
// 5268 %IF INITTYPE!STEPTYPE=0 %THEN %START
#line 5268 "test-new/nrimp10s-77.imp"
if (INITTYPE | STEPTYPE != 0) goto L_04D1;
// 5269 PSF1(LB,0,INITVAL-STEPVAL)
#line 5269 "test-new/nrimp10s-77.imp"
PSF1(122, 0, INITVAL - STEPVAL);
// 5270 %FINISH %ELSE %START
#line 5270 "test-new/nrimp10s-77.imp"
goto L_04D2;
#line 5270 "test-new/nrimp10s-77.imp"
L_04D1:;
// 5271 PSF1(LB,0,INITVAL) %IF INITTYPE=0
#line 5271 "test-new/nrimp10s-77.imp"
if (INITTYPE != 0) goto L_04D3;
#line 5271 "test-new/nrimp10s-77.imp"
PSF1(122, 0, INITVAL);
#line 5271 "test-new/nrimp10s-77.imp"
L_04D3:;
// 5272 PSF1(SBB,STEPTYPE,STEPVAL)
#line 5272 "test-new/nrimp10s-77.imp"
PSF1(34, STEPTYPE, STEPVAL);
// 5273 %FINISH
#line 5273 "test-new/nrimp10s-77.imp"
L_04D2:;
// 5274 !
// 5275 ! HAVE B SET TO INIT-STEP. FOR COMPUTED STEPS NOW MUST CHECK
// 5276 ! FOR NEGATIVE TRAVERSES. FOR FIXED STEPS THIS CAN BE SET
// 5277 ! IN MASK FOR REPEATING
// 5278 !
// 5279 %IF STEPTYPE=1 %THEN %START
#line 5279 "test-new/nrimp10s-77.imp"
if (STEPTYPE != 1) goto L_04D4;
// 5280 PF1(LSS,0,BREG,0)
#line 5280 "test-new/nrimp10s-77.imp"
PF1(98, 0, 7, 0);
// 5281 PSF1(IRSB,FINALTYPE,FINALVAL)
#line 5281 "test-new/nrimp10s-77.imp"
PSF1(228, FINALTYPE, FINALVAL);
// 5282 PSF1(IDV,1,STEPVAL)
#line 5282 "test-new/nrimp10s-77.imp"
PSF1(170, 1, STEPVAL);
// 5283 GRUSE(ACCR)=0
#line 5283 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5284 ENTERJUMP(37,L2,B'10')
#line 5284 "test-new/nrimp10s-77.imp"
ENTERJUMP(37, L2, 2);
// 5285 REPMASK=7
#line 5285 "test-new/nrimp10s-77.imp"
REPMASK = 7;
// 5286 %FINISH %ELSE REPMASK=8!(2<<(STEPVAL>>31)); ! A OR C
#line 5286 "test-new/nrimp10s-77.imp"
goto L_04D5;
#line 5286 "test-new/nrimp10s-77.imp"
L_04D4:;
#line 5286 "test-new/nrimp10s-77.imp"
REPMASK = 8 | 2 << ((unsigned int)STEPVAL >> 31);
#line 5286 "test-new/nrimp10s-77.imp"
L_04D5:;
// 5287 !
// 5288 ELRES=ENTER LAB(L1,0); ! LABEL FOR REPEATING
#line 5288 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L1, 0);
// 5289 !
// 5290 %IF STEPTYPE=0 %AND STEPVAL=1 %START
#line 5290 "test-new/nrimp10s-77.imp"
if (STEPTYPE != 0) goto L_04D6;
#line 5290 "test-new/nrimp10s-77.imp"
if (STEPVAL != 1) goto L_04D6;
// 5291 PSF1(CPIB,FINALTYPE,FINALVAL)
#line 5291 "test-new/nrimp10s-77.imp"
PSF1(46, FINALTYPE, FINALVAL);
// 5292 %FINISH %ELSE %START
#line 5292 "test-new/nrimp10s-77.imp"
goto L_04D7;
#line 5292 "test-new/nrimp10s-77.imp"
L_04D6:;
// 5293 PSF1(CPB,FINALTYPE,FINALVAL)
#line 5293 "test-new/nrimp10s-77.imp"
PSF1(38, FINALTYPE, FINALVAL);
// 5294 PSF1(ADB,STEPTYPE,STEPVAL)
#line 5294 "test-new/nrimp10s-77.imp"
PSF1(32, STEPTYPE, STEPVAL);
// 5295 %FINISH
#line 5295 "test-new/nrimp10s-77.imp"
L_04D7:;
// 5296 GRUSE(BREG)=0
#line 5296 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 5297 ENTER JUMP(REPMASK,L2,B'10')
#line 5297 "test-new/nrimp10s-77.imp"
ENTERJUMP(REPMASK, L2, 2);
// 5298 %FINISH
#line 5298 "test-new/nrimp10s-77.imp"
L_04D0:;
// 5299 BASE=FBASE; AREA=-1
#line 5299 "test-new/nrimp10s-77.imp"
BASE = FBASE;
#line 5299 "test-new/nrimp10s-77.imp"
AREA = -1;
// 5300 PSORLF1(STB,FACC,AREA CODE,FDISP)
#line 5300 "test-new/nrimp10s-77.imp"
PSORLF1(90, FACC, AREACODE(), FDISP);
// 5301 NOTE ASSMENT(BREG,2,FORNAME)
#line 5301 "test-new/nrimp10s-77.imp"
NOTEASSMENT(7, 2, FORNAME);
// 5302 !
// 5303 P=MARKUI; ! TO UI OR '%CYCLE'(HOLE)
#line 5303 "test-new/nrimp10s-77.imp"
P = MARKUI;
// 5304 %IF ALT=3 %THEN %START; ! DEAL WITH CONTROLLED STMNTS
#line 5304 "test-new/nrimp10s-77.imp"
if (ALT != 3) goto L_04D8;
// 5305 CUI(0)
#line 5305 "test-new/nrimp10s-77.imp"
CUI(0);
// 5306 %FINISH %ELSE %START
#line 5306 "test-new/nrimp10s-77.imp"
goto L_04D9;
#line 5306 "test-new/nrimp10s-77.imp"
L_04D8:;
// 5307 CCYCBODY(0,L2,L3)
#line 5307 "test-new/nrimp10s-77.imp"
CCYCBODY(0, L2, L3);
// 5308 ELRES=ENTER LAB(L3,B'011'); ! LABEL FOR CONTINUE
#line 5308 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L3, 3);
// 5309 %FINISH
#line 5309 "test-new/nrimp10s-77.imp"
L_04D9:;
// 5310 BASE=FBASE; ACCESS=FACC
#line 5310 "test-new/nrimp10s-77.imp"
BASE = FBASE;
#line 5310 "test-new/nrimp10s-77.imp"
ACCESS = FACC;
// 5311 AREA=-1; DISP=FDISP
#line 5311 "test-new/nrimp10s-77.imp"
AREA = -1;
#line 5311 "test-new/nrimp10s-77.imp"
DISP = FDISP;
// 5312 NAMEOP(2,BREG,4,FORNAME); ! CONTROL TO B
#line 5312 "test-new/nrimp10s-77.imp"
NAMEOP(2, 7, 4, FORNAME);
// 5313 %IF USEDEBJ=0 %THEN ENTER JUMP(15,L1,0) %ELSE PSF1(DEBJ,0,(DEBTO-CA)//2) %AND GRUSE(BREG)=0
#line 5313 "test-new/nrimp10s-77.imp"
if (USEDEBJ != 0) goto L_04DA;
#line 5313 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, L1, 0);
#line 5313 "test-new/nrimp10s-77.imp"
goto L_04DB;
#line 5313 "test-new/nrimp10s-77.imp"
L_04DA:;
#line 5313 "test-new/nrimp10s-77.imp"
PSF1(36, 0, ((long)(DEBTO - CA) / (long)2));
#line 5313 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
#line 5313 "test-new/nrimp10s-77.imp"
L_04DB:;
// 5314 ELRES=ENTERLAB(L2,B'111'!!(USEDEBJ<<2));! REPLACE ENV UNLESS DEBJ
#line 5314 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L2, 7 ^ USEDEBJ << 2);
// 5315 ! WHEN MERGE ENV
// 5316 ->WAYOUT
#line 5316 "test-new/nrimp10s-77.imp"
goto U_1027;
// 5317 SW(4): ! %WHILE COND %CYCLE
#line 5317 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 5318 CCRES = CCOND(0,1,L2)
#line 5318 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 1, L2);
// 5319 C CYC BODY(0,L2,L1)
#line 5319 "test-new/nrimp10s-77.imp"
CCYCBODY(0, L2, L1);
// 5320 ENTER JUMP(15,L1,0)
#line 5320 "test-new/nrimp10s-77.imp"
ENTERJUMP(15, L1, 0);
// 5321 ELRES = ENTER LAB(L2,B'111'); ! CONDITIONAL & REPLACE ENV
#line 5321 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L2, 7);
// 5322 ->WAYOUT
#line 5322 "test-new/nrimp10s-77.imp"
goto U_1027;
// 5323 SW(5): ! %UNTIL ... %CYCLE
#line 5323 "test-new/nrimp10s-77.imp"
case_SW_5:;
// 5324 ! ALSO %CYCLE... %REPEAT %UNTIL
// 5325 ! MARKUI TO %CYCLE
// 5326 P=MARKUI
#line 5326 "test-new/nrimp10s-77.imp"
P = MARKUI;
// 5327 C CYC BODY(0,L2,L3)
#line 5327 "test-new/nrimp10s-77.imp"
CCYCBODY(0, L2, L3);
// 5328 P=MARKC; ELRES=ENTER LAB(L3,B'011');! CONTINUE LABEL IF NEEDED
#line 5328 "test-new/nrimp10s-77.imp"
P = MARKC;
#line 5328 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L3, 3);
// 5329 CCRES=CCOND(0,1,L1)
#line 5329 "test-new/nrimp10s-77.imp"
CCRES = CCOND(0, 1, L1);
// 5330 ELRES=ENTER LAB(L2,B'011')
#line 5330 "test-new/nrimp10s-77.imp"
ELRES = ENTERLAB(L2, 3);
// 5331 ->WAYOUT
#line 5331 "test-new/nrimp10s-77.imp"
goto U_1027;
// 5332 %ROUTINE FOREXP(%INTEGERNAME ETYPE,EVALUE,%INTEGER TOTEMP,USEREG)
#line 5332 "test-new/nrimp10s-77.imp"
void FOREXP(int *ETYPE, int *EVALUE, int TOTEMP, int USEREG) {
// 5333 !***********************************************************************
// 5334 !* P INDEXES EXPRESSION. IF CONST PUT INTO EVALUE OTHERWISE *
// 5335 !* COMPILE TO USEREG AND STORE IN TEMP IF TOTEMP#0 *
// 5336 !***********************************************************************
// 5337 %INTEGER INP,VAL,OP
#line 5337 "test-new/nrimp10s-77.imp"
int INP;
#line 5337 "test-new/nrimp10s-77.imp"
int VAL;
#line 5337 "test-new/nrimp10s-77.imp"
int OP;
// 5338 INP=P; P=P+3
#line 5338 "test-new/nrimp10s-77.imp"
INP = P;
#line 5338 "test-new/nrimp10s-77.imp"
P = P + 3;
// 5339 %IF INTEXP(VAL)=0 %AND IMOD(VAL)<16_1FFFF %START
#line 5339 "test-new/nrimp10s-77.imp"
if (INTEXP(/*?*/ &VAL) != 0) goto L_04DC;
#line 5339 "test-new/nrimp10s-77.imp"
if (IMOD(VAL) >= 131071) goto L_04DC;
// 5340 EVALUE=VAL; ETYPE=0; ! EXPRESSION A LITERAL CONST
#line 5340 "test-new/nrimp10s-77.imp"
*EVALUE = VAL;
#line 5340 "test-new/nrimp10s-77.imp"
*ETYPE = 0;
// 5341 %RETURN
#line 5341 "test-new/nrimp10s-77.imp"
return;
// 5342 %FINISH
#line 5342 "test-new/nrimp10s-77.imp"
L_04DC:;
// 5343 P=INP
#line 5343 "test-new/nrimp10s-77.imp"
P = INP;
// 5344 CSEXP(USEREG,16_51); ! INTEGER MODE TO REG
#line 5344 "test-new/nrimp10s-77.imp"
CSEXP(USEREG, 81);
// 5345 ETYPE=1; ! NOT CONST
#line 5345 "test-new/nrimp10s-77.imp"
*ETYPE = 1;
// 5346 %IF TOTEMP#0 %START
#line 5346 "test-new/nrimp10s-77.imp"
if (TOTEMP == 0) goto L_04DD;
// 5347 GET WSP(VAL,1)
#line 5347 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &VAL, 1);
// 5348 %IF USEREG=ACCR %THEN OP=ST %ELSE OP=STB
#line 5348 "test-new/nrimp10s-77.imp"
if (USEREG != 0) goto L_04DE;
#line 5348 "test-new/nrimp10s-77.imp"
OP = 72;
#line 5348 "test-new/nrimp10s-77.imp"
goto L_04DF;
#line 5348 "test-new/nrimp10s-77.imp"
L_04DE:;
#line 5348 "test-new/nrimp10s-77.imp"
OP = 90;
#line 5348 "test-new/nrimp10s-77.imp"
L_04DF:;
// 5349 PSF1(OP,1,VAL)
#line 5349 "test-new/nrimp10s-77.imp"
PSF1(OP, 1, VAL);
// 5350 EVALUE=VAL
#line 5350 "test-new/nrimp10s-77.imp"
*EVALUE = VAL;
// 5351 %FINISH
#line 5351 "test-new/nrimp10s-77.imp"
L_04DD:;
// 5352 %END
#line 5352 "test-new/nrimp10s-77.imp"
return;
#line 5352 "test-new/nrimp10s-77.imp"
} /* end of FOREXP */
// 5353 %ROUTINE VALIDATE FOR
#line 5353 "test-new/nrimp10s-77.imp"
void VALIDATEFOR(void) {
// 5354 !***********************************************************************
// 5355 !* INITIAL VALUE IN BREG OR A CONSTANT *
// 5356 !***********************************************************************
// 5357 %INTEGER I
#line 5357 "test-new/nrimp10s-77.imp"
int I;
// 5358 %IF INITTYPE!STEPTYPE!FINALTYPE=0 %START
#line 5358 "test-new/nrimp10s-77.imp"
if (INITTYPE | STEPTYPE | FINALTYPE != 0) goto L_04E0;
// 5359 J=FINALVAL-INITVAL; ! ALL CONSTANT CAN CHECK NOW
#line 5359 "test-new/nrimp10s-77.imp"
J = FINALVAL - INITVAL;
// 5360 %IF (J//STEPVAL)*STEPVAL#J %THEN FAULT2(93,0,0)
#line 5360 "test-new/nrimp10s-77.imp"
if (((long)J / (long)STEPVAL) * STEPVAL == J) goto L_04E1;
#line 5360 "test-new/nrimp10s-77.imp"
FAULT2(93, 0, 0);
#line 5360 "test-new/nrimp10s-77.imp"
L_04E1:;
// 5361 %RETURN
#line 5361 "test-new/nrimp10s-77.imp"
return;
// 5362 %FINISH
#line 5362 "test-new/nrimp10s-77.imp"
L_04E0:;
// 5363 %IF STEPTYPE=0 %AND IMOD(STEPVAL)=1 %THEN %RETURN
#line 5363 "test-new/nrimp10s-77.imp"
if (STEPTYPE != 0) goto L_04E2;
#line 5363 "test-new/nrimp10s-77.imp"
if (IMOD(STEPVAL) != 1) goto L_04E2;
#line 5363 "test-new/nrimp10s-77.imp"
return;
#line 5363 "test-new/nrimp10s-77.imp"
L_04E2:;
// 5364 !
// 5365 ! CHECK BY PLANTING CODE
// 5366 !
// 5367 %IF INITTYPE=0 %THEN PSF1(LSS,0,INITVAL) %ELSE PF1(LSS,0,BREG,0)
#line 5367 "test-new/nrimp10s-77.imp"
if (INITTYPE != 0) goto L_04E3;
#line 5367 "test-new/nrimp10s-77.imp"
PSF1(98, 0, INITVAL);
#line 5367 "test-new/nrimp10s-77.imp"
goto L_04E4;
#line 5367 "test-new/nrimp10s-77.imp"
L_04E3:;
#line 5367 "test-new/nrimp10s-77.imp"
PF1(98, 0, 7, 0);
#line 5367 "test-new/nrimp10s-77.imp"
L_04E4:;
// 5368 PSF1(IRSB,FINALTYPE,FINALVAL)
#line 5368 "test-new/nrimp10s-77.imp"
PSF1(228, FINALTYPE, FINALVAL);
// 5369 PSF1(IMDV,STEPTYPE,STEPVAL)
#line 5369 "test-new/nrimp10s-77.imp"
PSF1(174, STEPTYPE, STEPVAL);
// 5370 PF1(LSS,0,TOS,0)
#line 5370 "test-new/nrimp10s-77.imp"
PF1(98, 0, 6, 0);
// 5371 GRUSE(ACCR)=0
#line 5371 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5372 PPJ(36,11)
#line 5372 "test-new/nrimp10s-77.imp"
PPJ(36, 11);
// 5373 %END
#line 5373 "test-new/nrimp10s-77.imp"
return;
#line 5373 "test-new/nrimp10s-77.imp"
} /* end of VALIDATEFOR */
// ?I unused
// 5374 %END
#line 5374 "test-new/nrimp10s-77.imp"
return;
#line 5374 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 5374 "test-new/nrimp10s-77.imp"
if (SW_index < 0 || SW_index > 6)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 5374 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 0];
#line 5374 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 5374 "test-new/nrimp10s-77.imp"
} /* end of CLOOP */
// 5375 %ROUTINE ASSIGN(%INTEGER ASSOP,P1)
#line 5375 "test-new/nrimp10s-77.imp"
void ASSIGN(int ASSOP, int P1) {
// 5376 !***********************************************************************
// 5377 !* HANDLES ARITHMETIC,STRING & ADDRESS ASSIGNMENTS TO VARIABLES *
// 5378 !* FORMAL PARAMETERS AND DOPEVECTORS *
// 5379 !* ASSOP:- *
// 5380 !* 1 IS FOR '==' *
// 5381 !* 2 IS FOR '=' *
// 5382 !* 3 IS FOR '<-' (JAM TRANSFER) *
// 5383 !* 4 IS FOR '->' (UNCONDITIONAL RESOLUTION) *
// 5384 !* >4 IS FOR STORE ACC BY 'ASSOP&3' INTO NAME *
// 5385 !* *
// 5386 !* P POINTS TO THE EXPRESSION. P1 TO THE NAME ON LHS *
// 5387 !***********************************************************************
// 5388 %INTEGER Q,QQ,KK,TYPEP,PRECP,PTYPEP,JJJ,P2,JJ,REG,STCODE,RHTYPE,ACCP,II,HEAD1,NOPS,TPCELL,LVL,BOT1,LHNAME,RHNAME
#line 5388 "test-new/nrimp10s-77.imp"
int Q;
#line 5388 "test-new/nrimp10s-77.imp"
int QQ;
#line 5388 "test-new/nrimp10s-77.imp"
int KK;
#line 5388 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 5388 "test-new/nrimp10s-77.imp"
int PRECP;
#line 5388 "test-new/nrimp10s-77.imp"
int PTYPEP;
#line 5388 "test-new/nrimp10s-77.imp"
int JJJ;
#line 5388 "test-new/nrimp10s-77.imp"
int P2;
#line 5388 "test-new/nrimp10s-77.imp"
int JJ;
#line 5388 "test-new/nrimp10s-77.imp"
int REG;
#line 5388 "test-new/nrimp10s-77.imp"
int STCODE;
#line 5388 "test-new/nrimp10s-77.imp"
int RHTYPE;
#line 5388 "test-new/nrimp10s-77.imp"
int ACCP;
#line 5388 "test-new/nrimp10s-77.imp"
int II;
#line 5388 "test-new/nrimp10s-77.imp"
int HEAD1;
#line 5388 "test-new/nrimp10s-77.imp"
int NOPS;
#line 5388 "test-new/nrimp10s-77.imp"
int TPCELL;
#line 5388 "test-new/nrimp10s-77.imp"
int LVL;
#line 5388 "test-new/nrimp10s-77.imp"
int BOT1;
#line 5388 "test-new/nrimp10s-77.imp"
int LHNAME;
#line 5388 "test-new/nrimp10s-77.imp"
int RHNAME;
// 5389 %RECORD (RD) R{(RD)
#line 5389 "test-new/nrimp10s-77.imp"
struct RD R;
// 5390 %SWITCH SW(0:3); ! TO SWITCH ON ASSOP
#line 5390 "test-new/nrimp10s-77.imp"
int SW_index;
#line 5390 "test-new/nrimp10s-77.imp"
int SW_line;
#line 5390 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 5390 "test-new/nrimp10s-77.imp"
static const void *SW[4] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 5391 P2=P
#line 5391 "test-new/nrimp10s-77.imp"
P2 = P;
// 5392 %IF ASSOP>4 %THEN RHTYPE=TYPE
#line 5392 "test-new/nrimp10s-77.imp"
if (ASSOP <= 4) goto L_04E5;
#line 5392 "test-new/nrimp10s-77.imp"
RHTYPE = TYPE;
#line 5392 "test-new/nrimp10s-77.imp"
L_04E5:;
// 5393 LHNAME=A(P1)<<8!A(P1+1)
#line 5393 "test-new/nrimp10s-77.imp"
LHNAME = A[P1] << 8 | A[P1 + 1];
// 5394 P=P1; REDUCE TAG; ! LOOK AT LH SIDE
#line 5394 "test-new/nrimp10s-77.imp"
P = P1;
#line 5394 "test-new/nrimp10s-77.imp"
REDUCETAG();
// 5395 PTYPEP=PTYPE; JJ=J
#line 5395 "test-new/nrimp10s-77.imp"
PTYPEP = PTYPE;
#line 5395 "test-new/nrimp10s-77.imp"
JJ = J;
// 5396 KK=K; II=I; LVL=OLDI
#line 5396 "test-new/nrimp10s-77.imp"
KK = K;
#line 5396 "test-new/nrimp10s-77.imp"
II = I;
#line 5396 "test-new/nrimp10s-77.imp"
LVL = OLDI;
// 5397 TPCELL=TCELL; ACCP=ACC
#line 5397 "test-new/nrimp10s-77.imp"
TPCELL = TCELL;
#line 5397 "test-new/nrimp10s-77.imp"
ACCP = ACC;
// 5398 P=P2; TYPEP=TYPE; PRECP=PREC; ! SAVE USEFUL INFO FOR LATER
#line 5398 "test-new/nrimp10s-77.imp"
P = P2;
#line 5398 "test-new/nrimp10s-77.imp"
TYPEP = TYPE;
#line 5398 "test-new/nrimp10s-77.imp"
PRECP = PREC;
// 5399 -> SW(ASSOP&3)
#line 5399 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = ASSOP & 3;
goto case_SW_dispatch;
// 5400 !
// 5401 SW(2):SW(3): ! ARITHMETIC ASSIGNMENTS
#line 5401 "test-new/nrimp10s-77.imp"
case_SW_2:;
#line 5401 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 5402 %IF TYPE=3 %THEN ->RECOP
#line 5402 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_04E6;
#line 5402 "test-new/nrimp10s-77.imp"
goto U_1027;
#line 5402 "test-new/nrimp10s-77.imp"
L_04E6:;
// 5403 TYPE=1 %UNLESS TYPE=2 %OR TYPE=5;! IN CASE OF RUBBISHY SUBNAMES
#line 5403 "test-new/nrimp10s-77.imp"
if (TYPE == 2) goto L_04E7;
#line 5403 "test-new/nrimp10s-77.imp"
if (TYPE == 5) goto L_04E7;
#line 5403 "test-new/nrimp10s-77.imp"
TYPE = 1;
#line 5403 "test-new/nrimp10s-77.imp"
L_04E7:;
// 5404 ->STring %IF TYPE=5; ! LHS IS A STRING
#line 5404 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_04E8;
#line 5404 "test-new/nrimp10s-77.imp"
goto U_1028;
#line 5404 "test-new/nrimp10s-77.imp"
L_04E8:;
// 5405 BACK: HEAD1=0; ! CLEAR TEMPORAYRY LIST HEADS
#line 5405 "test-new/nrimp10s-77.imp"
U_102E:;
#line 5405 "test-new/nrimp10s-77.imp"
HEAD1 = 0;
// 5406 TYPE=1 %UNLESS TYPE=2; ! DEAL WITH UNSET NAMES
#line 5406 "test-new/nrimp10s-77.imp"
if (TYPE == 2) goto L_04E9;
#line 5406 "test-new/nrimp10s-77.imp"
TYPE = 1;
#line 5406 "test-new/nrimp10s-77.imp"
L_04E9:;
// 5407 TYPEP=TYPE
#line 5407 "test-new/nrimp10s-77.imp"
TYPEP = TYPE;
// 5408 NOPS=1<<18+1; P=P2+3
#line 5408 "test-new/nrimp10s-77.imp"
NOPS = (1 << 18) + 1;
#line 5408 "test-new/nrimp10s-77.imp"
P = P2 + 3;
// 5409 PUSH(HEAD1,ASSOP&3+33,PRECP,0); ! ASSIGNMENT OPERATOR
#line 5409 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &HEAD1, (ASSOP & 3) + 33, PRECP, 0);
// 5410 BOT1=HEAD1
#line 5410 "test-new/nrimp10s-77.imp"
BOT1 = HEAD1;
// 5411 PUSH(HEAD1,PTYPEP<<16!2,P1,0); ! LHS
#line 5411 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &HEAD1, PTYPEP << 16 | 2, P1, 0);
// 5412 %IF ASSOP>4 %THEN %START
#line 5412 "test-new/nrimp10s-77.imp"
if (ASSOP <= 4) goto L_04EA;
// 5413 FAULT(24,0) %UNLESS TYPE=RHTYPE
#line 5413 "test-new/nrimp10s-77.imp"
if (TYPE == RHTYPE) goto L_04EB;
#line 5413 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 5413 "test-new/nrimp10s-77.imp"
L_04EB:;
// 5414 PUSH(HEAD1,RHTYPE<<16!9,0,0)
#line 5414 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &HEAD1, RHTYPE << 16 | 9, 0, 0);
// 5415 OLINK(ACCR)=HEAD1
#line 5415 "test-new/nrimp10s-77.imp"
OLINK[0] = HEAD1;
// 5416 %FINISH %ELSE TORP(HEAD1,BOT1,NOPS); ! RHS TO REVERSE POLISH
#line 5416 "test-new/nrimp10s-77.imp"
goto L_04EC;
#line 5416 "test-new/nrimp10s-77.imp"
L_04EA:;
#line 5416 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &HEAD1, /*?*/ &BOT1, /*?*/ &NOPS);
#line 5416 "test-new/nrimp10s-77.imp"
L_04EC:;
// 5417 EXPOP(HEAD1,-1,NOPS,256+PRECP<<4+TYPEP); ! PLANT CODE
#line 5417 "test-new/nrimp10s-77.imp"
EXPOP(HEAD1, -1, NOPS, 256 + (PRECP << 4) + TYPEP);
// 5418 ! CLEAR LIST(HEAD1)
// 5419 ASLIST(BOT1)_LINK=ASL
#line 5419 "test-new/nrimp10s-77.imp"
ASLIST[BOT1].LINK = ASL;
// 5420 ASL=HEAD1
#line 5420 "test-new/nrimp10s-77.imp"
ASL = HEAD1;
// 5421 %RETURN
#line 5421 "test-new/nrimp10s-77.imp"
return;
// 5422 !NA: NOTE ASSMENT(-1,ASSOP&3,A(P1))
// 5423 STring: ! STRINGS
#line 5423 "test-new/nrimp10s-77.imp"
U_1028:;
// 5424 !
// 5425 ! PICK OFF NULL STRINGS AND SUBSTITUTE A CRAFTY MVL FOR S=""
// 5426 !
// 5427 %IF A(P+3)=4 %AND A(P+4)=2 %AND A(P+5)=16_35 %AND A(P+10)=0 %AND A(P+11)=2 %THEN %START
#line 5427 "test-new/nrimp10s-77.imp"
if (A[P + 3] != 4) goto L_04ED;
#line 5427 "test-new/nrimp10s-77.imp"
if (A[P + 4] != 2) goto L_04ED;
#line 5427 "test-new/nrimp10s-77.imp"
if (A[P + 5] != 53) goto L_04ED;
#line 5427 "test-new/nrimp10s-77.imp"
if (A[P + 10] != 0) goto L_04ED;
#line 5427 "test-new/nrimp10s-77.imp"
if (A[P + 11] != 2) goto L_04ED;
// 5428 Q=P+12-A(P+10)>>1
#line 5428 "test-new/nrimp10s-77.imp"
Q = P + 12 - ((unsigned int)A[P + 10] >> 1);
// 5429 P=P1; CNAME(1,DR)
#line 5429 "test-new/nrimp10s-77.imp"
P = P1;
#line 5429 "test-new/nrimp10s-77.imp"
CNAME(1, 1);
// 5430 PF2(MVL,0,1,0,0,0)
#line 5430 "test-new/nrimp10s-77.imp"
PF2(176, 0, 1, 0, 0, 0);
// 5431 P=Q; %RETURN
#line 5431 "test-new/nrimp10s-77.imp"
P = Q;
#line 5431 "test-new/nrimp10s-77.imp"
return;
// 5432 %FINISH
#line 5432 "test-new/nrimp10s-77.imp"
L_04ED:;
// 5433 %IF ASSOP<=3 %THEN CSTREXP(0,ACCR)
#line 5433 "test-new/nrimp10s-77.imp"
if (ASSOP > 3) goto L_04EE;
#line 5433 "test-new/nrimp10s-77.imp"
CSTREXP(0, 0);
#line 5433 "test-new/nrimp10s-77.imp"
L_04EE:;
// 5434 ASSOP=ASSOP&3
#line 5434 "test-new/nrimp10s-77.imp"
ASSOP = ASSOP & 3;
// 5435 QQ=STRINGL; Q=P
#line 5435 "test-new/nrimp10s-77.imp"
QQ = STRINGL;
#line 5435 "test-new/nrimp10s-77.imp"
Q = P;
// 5436 REGISTER(ACCR)=1
#line 5436 "test-new/nrimp10s-77.imp"
REGISTER[0] = 1;
// 5437 OLINK(ACCR)=ADDR(R)
#line 5437 "test-new/nrimp10s-77.imp"
OLINK[0] = _imp_ADDR(/*?*/ &R);
// 5438 R_PTYPE=16_51; R_FLAG=9; R_UPTYPE=0
#line 5438 "test-new/nrimp10s-77.imp"
R.PTYPE = 81;
#line 5438 "test-new/nrimp10s-77.imp"
R.FLAG = 9;
#line 5438 "test-new/nrimp10s-77.imp"
R.UPTYPE = 0;
// 5439 R_XB=ACCR
#line 5439 "test-new/nrimp10s-77.imp"
R.XB = 0;
// 5440 P=P1; CNAME(1,DR)
#line 5440 "test-new/nrimp10s-77.imp"
P = P1;
#line 5440 "test-new/nrimp10s-77.imp"
CNAME(1, 1);
// 5441 %IF R_FLAG#9 %THEN PF1(LSD,0,TOS,0)
#line 5441 "test-new/nrimp10s-77.imp"
if (R.FLAG == 9) goto L_04EF;
#line 5441 "test-new/nrimp10s-77.imp"
PF1(100, 0, 6, 0);
#line 5441 "test-new/nrimp10s-77.imp"
L_04EF:;
// 5442 PF1(IAD,0,PC,SPECIAL CONSTS(2))
#line 5442 "test-new/nrimp10s-77.imp"
PF1(224, 0, 4, SPECIALCONSTS(2));
// 5443 %IF ASSOP#3 %AND (ROUT#0 %OR NAM#0=ARR) %AND QQ=0 %START
#line 5443 "test-new/nrimp10s-77.imp"
if (ASSOP == 3) goto L_04F0;
#line 5443 "test-new/nrimp10s-77.imp"
if (ROUT != 0) goto L_04F1;
#line 5443 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 5443 "test-new/nrimp10s-77.imp"
int tmp;
#line 5443 "test-new/nrimp10s-77.imp"
if (NAM == (tmp = 0)) goto L_04F0;
// Double-sided test on 0 (Part II)
#line 5443 "test-new/nrimp10s-77.imp"
if (tmp != ARR) goto L_04F0;
#line 5443 "test-new/nrimp10s-77.imp"
}
#line 5443 "test-new/nrimp10s-77.imp"
L_04F1:;
#line 5443 "test-new/nrimp10s-77.imp"
if (QQ != 0) goto L_04F0;
// 5444 ! LHS=MAP : DR BOUND NOT VALID
// 5445 ! ALSO NAMES MAPPED ==STRING(ADDR)
// 5446 %IF PARMOPT#0 %THEN PPJ(0,18) %ELSE %START
#line 5446 "test-new/nrimp10s-77.imp"
if (PARMOPT == 0) goto L_04F2;
#line 5446 "test-new/nrimp10s-77.imp"
PPJ(0, 18);
#line 5446 "test-new/nrimp10s-77.imp"
goto L_04F3;
#line 5446 "test-new/nrimp10s-77.imp"
L_04F2:;
// 5447 PF1(STUH,0,BREG,0)
#line 5447 "test-new/nrimp10s-77.imp"
PF1(74, 0, 7, 0);
// 5448 PF1(LUH,0,BREG,0)
#line 5448 "test-new/nrimp10s-77.imp"
PF1(106, 0, 7, 0);
// 5449 PF1(LDB,0,BREG,0)
#line 5449 "test-new/nrimp10s-77.imp"
PF1(118, 0, 7, 0);
// 5450 %FINISH
#line 5450 "test-new/nrimp10s-77.imp"
L_04F3:;
// 5451 GRUSE(BREG)=0
#line 5451 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 5452 %FINISH
#line 5452 "test-new/nrimp10s-77.imp"
L_04F0:;
// 5453 GRUSE(ACCR)=0
#line 5453 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5454 REGISTER(ACCR)=0
#line 5454 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 5455 %IF QQ>0 %AND ASSOP#3 %THEN PF2(MV,0,0,QQ,0,0) %ELSESTART
#line 5455 "test-new/nrimp10s-77.imp"
if (QQ <= 0) goto L_04F4;
#line 5455 "test-new/nrimp10s-77.imp"
if (ASSOP == 3) goto L_04F4;
#line 5455 "test-new/nrimp10s-77.imp"
PF2(178, 0, 0, QQ, 0, 0);
#line 5455 "test-new/nrimp10s-77.imp"
goto L_04F5;
#line 5455 "test-new/nrimp10s-77.imp"
L_04F4:;
// 5456 %IF ASSOP=3 %THEN PF1(STD,0,TOS,0)
#line 5456 "test-new/nrimp10s-77.imp"
if (ASSOP != 3) goto L_04F6;
#line 5456 "test-new/nrimp10s-77.imp"
PF1(88, 0, 6, 0);
#line 5456 "test-new/nrimp10s-77.imp"
L_04F6:;
// 5457 PF2(MV,1,1,0,0,UNASSPAT&255)
#line 5457 "test-new/nrimp10s-77.imp"
PF2(178, 1, 1, 0, 0, -2122219135 & 255);
// 5458 %IF PARMARR#0 %OR ASSOP=3 %THEN PSF1(USH,0,8) %AND PSF1(USH,0,-40)
#line 5458 "test-new/nrimp10s-77.imp"
if (PARMARR != 0) goto L_04F7;
#line 5458 "test-new/nrimp10s-77.imp"
if (ASSOP != 3) goto L_04F8;
#line 5458 "test-new/nrimp10s-77.imp"
L_04F7:;
#line 5458 "test-new/nrimp10s-77.imp"
PSF1(200, 0, 8);
#line 5458 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -40);
#line 5458 "test-new/nrimp10s-77.imp"
L_04F8:;
// 5459 %IF PARMARR#0 %AND ASSOP=2 %THEN PPJ(36,9)
#line 5459 "test-new/nrimp10s-77.imp"
if (PARMARR == 0) goto L_04F9;
#line 5459 "test-new/nrimp10s-77.imp"
if (ASSOP != 2) goto L_04F9;
#line 5459 "test-new/nrimp10s-77.imp"
PPJ(36, 9);
#line 5459 "test-new/nrimp10s-77.imp"
L_04F9:;
// 5460 %IF ASSOP=3 %THEN %START
#line 5460 "test-new/nrimp10s-77.imp"
if (ASSOP != 3) goto L_04FA;
// 5461 PF1(IRSB,2,TOS,0)
#line 5461 "test-new/nrimp10s-77.imp"
PF1(228, 2, 6, 0);
// 5462 PF1(ST,2,7,0); ! STORE AMENDED CURRENT LENGTH {EMAS Imp9 vs Imp77 - ST is both a constant and a label in EMAS Imp9}
#line 5462 "test-new/nrimp10s-77.imp"
PF1(72, 2, 7, 0);
// 5463 %FINISH
#line 5463 "test-new/nrimp10s-77.imp"
L_04FA:;
// 5464 %FINISH
#line 5464 "test-new/nrimp10s-77.imp"
L_04F5:;
// 5465 P=Q; %RETURN
#line 5465 "test-new/nrimp10s-77.imp"
P = Q;
#line 5465 "test-new/nrimp10s-77.imp"
return;
// 5466 !
// 5467 ! THIS SECTION DEALS WITH OPERATIONS ON COMPLETE RECORDS
// 5468 !
// 5469 RECOP: ! LHS IS RECORD WITHOUT SUBNAME
#line 5469 "test-new/nrimp10s-77.imp"
U_1027:;
// 5470 REG=ACCR; ! IN CASE FAULT 66
#line 5470 "test-new/nrimp10s-77.imp"
REG = 0;
// 5471 Q=TSEXP(JJJ)
#line 5471 "test-new/nrimp10s-77.imp"
Q = TSEXP(/*?*/ &JJJ);
// 5472 %IF Q=1 %AND JJJ=0 %START; ! CLEAR A RECORD TO ZERO
#line 5472 "test-new/nrimp10s-77.imp"
if (Q != 1) goto L_04FB;
#line 5472 "test-new/nrimp10s-77.imp"
if (JJJ != 0) goto L_04FB;
// 5473 P=P1; CNAME(3,DR)
#line 5473 "test-new/nrimp10s-77.imp"
P = P1;
#line 5473 "test-new/nrimp10s-77.imp"
CNAME(3, 1);
// 5474 %IF ACC<=128 %THEN JJ=0 %AND KK=ACC-1 %ELSE %START
#line 5474 "test-new/nrimp10s-77.imp"
if (ACC > 128) goto L_04FC;
#line 5474 "test-new/nrimp10s-77.imp"
JJ = 0;
#line 5474 "test-new/nrimp10s-77.imp"
KK = ACC - 1;
#line 5474 "test-new/nrimp10s-77.imp"
goto L_04FD;
#line 5474 "test-new/nrimp10s-77.imp"
L_04FC:;
// 5475 JJ=1; KK=0
#line 5475 "test-new/nrimp10s-77.imp"
JJ = 1;
#line 5475 "test-new/nrimp10s-77.imp"
KK = 0;
// 5476 %IF NAM#0 %OR ARR#0 %THEN PSF1(LDB,0,ACC)
#line 5476 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_04FE;
#line 5476 "test-new/nrimp10s-77.imp"
if (ARR == 0) goto L_04FF;
#line 5476 "test-new/nrimp10s-77.imp"
L_04FE:;
#line 5476 "test-new/nrimp10s-77.imp"
PSF1(118, 0, ACC);
#line 5476 "test-new/nrimp10s-77.imp"
L_04FF:;
// 5477 %FINISH
#line 5477 "test-new/nrimp10s-77.imp"
L_04FD:;
// 5478 PF2(MVL,JJ,1,KK,0,0)
#line 5478 "test-new/nrimp10s-77.imp"
PF2(176, JJ, 1, KK, 0, 0);
// 5479 %FINISH %ELSE %START
#line 5479 "test-new/nrimp10s-77.imp"
goto L_0500;
#line 5479 "test-new/nrimp10s-77.imp"
L_04FB:;
// 5480 ->BACK %UNLESS TYPE=3 %AND A(P2+3)=4 %AND A(P2+4)=1
#line 5480 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_0501;
#line 5480 "test-new/nrimp10s-77.imp"
if (A[P2 + 3] != 4) goto L_0501;
#line 5480 "test-new/nrimp10s-77.imp"
if (A[P2 + 4] == 1) goto L_0502;
#line 5480 "test-new/nrimp10s-77.imp"
L_0501:;
#line 5480 "test-new/nrimp10s-77.imp"
goto U_102E;
#line 5480 "test-new/nrimp10s-77.imp"
L_0502:;
// 5481 P=P2+5; CNAME(3,ACCR)
#line 5481 "test-new/nrimp10s-77.imp"
P = P2 + 5;
#line 5481 "test-new/nrimp10s-77.imp"
CNAME(3, 0);
// 5482 ACCP=ACC
#line 5482 "test-new/nrimp10s-77.imp"
ACCP = ACC;
// 5483 %UNLESS A(P)=2 %THEN FAULT2(66,0,LHNAME) %AND ->F00
#line 5483 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0503;
#line 5483 "test-new/nrimp10s-77.imp"
FAULT2(66, 0, LHNAME);
#line 5483 "test-new/nrimp10s-77.imp"
goto U_102F;
#line 5483 "test-new/nrimp10s-77.imp"
L_0503:;
// 5484 R_PTYPE=16_61; R_FLAG=9
#line 5484 "test-new/nrimp10s-77.imp"
R.PTYPE = 97;
#line 5484 "test-new/nrimp10s-77.imp"
R.FLAG = 9;
// 5485 R_XB=ACCR<<5; R_D=0
#line 5485 "test-new/nrimp10s-77.imp"
R.XB = 0 << 5;
#line 5485 "test-new/nrimp10s-77.imp"
R.D = 0;
// 5486 OLINK(ACCR)=ADDR(R)
#line 5486 "test-new/nrimp10s-77.imp"
OLINK[0] = _imp_ADDR(/*?*/ &R);
// 5487 REGISTER(ACCR)=1
#line 5487 "test-new/nrimp10s-77.imp"
REGISTER[0] = 1;
// 5488 P=P1; CNAME(3,DR)
#line 5488 "test-new/nrimp10s-77.imp"
P = P1;
#line 5488 "test-new/nrimp10s-77.imp"
CNAME(3, 1);
// 5489 REGISTER(ACCR)=0
#line 5489 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 5490 %IF R_FLAG#9 %THEN PF1(LSD,0,TOS,0)
#line 5490 "test-new/nrimp10s-77.imp"
if (R.FLAG == 9) goto L_0504;
#line 5490 "test-new/nrimp10s-77.imp"
PF1(100, 0, 6, 0);
#line 5490 "test-new/nrimp10s-77.imp"
L_0504:;
// 5491 %IF ASSOP=2 %AND ACCP#ACC %THEN FAULT2(67,LHNAME,FROMAR2(P2+5)) %AND ->F00
#line 5491 "test-new/nrimp10s-77.imp"
if (ASSOP != 2) goto L_0505;
#line 5491 "test-new/nrimp10s-77.imp"
if (ACCP == ACC) goto L_0505;
#line 5491 "test-new/nrimp10s-77.imp"
FAULT2(67, LHNAME, FROMAR2(P2 + 5));
#line 5491 "test-new/nrimp10s-77.imp"
goto U_102F;
#line 5491 "test-new/nrimp10s-77.imp"
L_0505:;
// 5492 %IF ACCP>ACC %THEN ACCP=ACC
#line 5492 "test-new/nrimp10s-77.imp"
if (ACCP <= ACC) goto L_0506;
#line 5492 "test-new/nrimp10s-77.imp"
ACCP = ACC;
#line 5492 "test-new/nrimp10s-77.imp"
L_0506:;
// 5493 {%UNTIL ACCP=0} %CYCLE
#line 5493 "test-new/nrimp10s-77.imp"
L_0507:;
// 5494 %IF ACCP>128 %THEN KK=128 %ELSE KK=ACCP
#line 5494 "test-new/nrimp10s-77.imp"
if (ACCP <= 128) goto L_0508;
#line 5494 "test-new/nrimp10s-77.imp"
KK = 128;
#line 5494 "test-new/nrimp10s-77.imp"
goto L_0509;
#line 5494 "test-new/nrimp10s-77.imp"
L_0508:;
#line 5494 "test-new/nrimp10s-77.imp"
KK = ACCP;
#line 5494 "test-new/nrimp10s-77.imp"
L_0509:;
// 5495 PF2(MV,0,0,KK-1,0,0)
#line 5495 "test-new/nrimp10s-77.imp"
PF2(178, 0, 0, KK - 1, 0, 0);
// 5496 ACCP=ACCP-KK
#line 5496 "test-new/nrimp10s-77.imp"
ACCP = ACCP - KK;
// 5497 %REPEAT %UNTIL ACCP=0
#line 5497 "test-new/nrimp10s-77.imp"
if (ACCP == 0) goto L_050A;
#line 5497 "test-new/nrimp10s-77.imp"
goto L_0507;
#line 5497 "test-new/nrimp10s-77.imp"
L_050A:;
// 5498 GRUSE(ACCR)=0
#line 5498 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5499 %FINISH
#line 5499 "test-new/nrimp10s-77.imp"
L_0500:;
// 5500 P=P2; SKIP EXP
#line 5500 "test-new/nrimp10s-77.imp"
P = P2;
#line 5500 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 5501 GRUSE(DR)=0
#line 5501 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
// 5502 %RETURN
#line 5502 "test-new/nrimp10s-77.imp"
return;
// 5503 SW(0): ! RESOLUTION
#line 5503 "test-new/nrimp10s-77.imp"
case_SW_0:;
// 5504 P=P1; CNAME(2,DR)
#line 5504 "test-new/nrimp10s-77.imp"
P = P1;
#line 5504 "test-new/nrimp10s-77.imp"
CNAME(2, 1);
// 5505 P=P2;
#line 5505 "test-new/nrimp10s-77.imp"
P = P2;
// 5506 %IF TYPE=5 %THEN CRES(0) %ELSE %START
#line 5506 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_050B;
#line 5506 "test-new/nrimp10s-77.imp"
CRES(0);
#line 5506 "test-new/nrimp10s-77.imp"
goto L_050C;
#line 5506 "test-new/nrimp10s-77.imp"
L_050B:;
// 5507 SKIP EXP
#line 5507 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 5508 FAULT2(71,0,FROMAR2(P1)) %UNLESS TYPE=7
#line 5508 "test-new/nrimp10s-77.imp"
if (TYPE == 7) goto L_050D;
#line 5508 "test-new/nrimp10s-77.imp"
FAULT2(71, 0, FROMAR2(P1));
#line 5508 "test-new/nrimp10s-77.imp"
L_050D:;
// 5509 %FINISH
#line 5509 "test-new/nrimp10s-77.imp"
L_050C:;
// 5510 %RETURN
#line 5510 "test-new/nrimp10s-77.imp"
return;
// 5511 SW(1): ! '==' AND %NAME PARAMETERS
#line 5511 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 5512 REG=ACCR; STCODE=ST; ! NORMALLY USE ACC
#line 5512 "test-new/nrimp10s-77.imp"
REG = 0;
#line 5512 "test-new/nrimp10s-77.imp"
STCODE = 72;
// 5513 ->F81 %UNLESS A(P2+3)=4 %AND A(P2+4)=1
#line 5513 "test-new/nrimp10s-77.imp"
if (A[P2 + 3] != 4) goto L_050E;
#line 5513 "test-new/nrimp10s-77.imp"
if (A[P2 + 4] == 1) goto L_050F;
#line 5513 "test-new/nrimp10s-77.imp"
L_050E:;
#line 5513 "test-new/nrimp10s-77.imp"
goto U_1033;
#line 5513 "test-new/nrimp10s-77.imp"
L_050F:;
// 5514 FAULT2(82,0,LHNAME) %AND ->F00 %UNLESS NAM=1; ! ONLY POINTERS ON LHS OF==
#line 5514 "test-new/nrimp10s-77.imp"
if (NAM == 1) goto L_0510;
#line 5514 "test-new/nrimp10s-77.imp"
FAULT2(82, 0, LHNAME);
#line 5514 "test-new/nrimp10s-77.imp"
goto U_102F;
#line 5514 "test-new/nrimp10s-77.imp"
L_0510:;
// 5515 P=P2+5
#line 5515 "test-new/nrimp10s-77.imp"
P = P2 + 5;
// 5516 RHNAME=A(P)<<8!A(P+1)
#line 5516 "test-new/nrimp10s-77.imp"
RHNAME = A[P] << 8 | A[P + 1];
// 5517 ->ARRNAME %IF ARR=1
#line 5517 "test-new/nrimp10s-77.imp"
if (ARR != 1) goto L_0511;
#line 5517 "test-new/nrimp10s-77.imp"
goto U_1034;
#line 5517 "test-new/nrimp10s-77.imp"
L_0511:;
// 5518 %IF A(P1+2)=2=A(P1+3) %START; ! LHS SCALAR POINTERNAME
#line 5518 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 2 (Part I)
#line 5518 "test-new/nrimp10s-77.imp"
int tmp;
#line 5518 "test-new/nrimp10s-77.imp"
if (A[P1 + 2] != (tmp = 2)) goto L_0512;
// Double-sided test on 2 (Part II)
#line 5518 "test-new/nrimp10s-77.imp"
if (tmp != A[P1 + 3]) goto L_0512;
#line 5518 "test-new/nrimp10s-77.imp"
}
// 5519 COPYTAG(RHNAME) ; ! LOOK AT RHS
#line 5519 "test-new/nrimp10s-77.imp"
COPYTAG(RHNAME);
// 5520 %IF PTYPE#SNPT %AND ARR#0 %THEN REG=DR %AND STCODE=STD
#line 5520 "test-new/nrimp10s-77.imp"
if (PTYPE == 4102) goto L_0513;
#line 5520 "test-new/nrimp10s-77.imp"
if (ARR == 0) goto L_0513;
#line 5520 "test-new/nrimp10s-77.imp"
REG = 1;
#line 5520 "test-new/nrimp10s-77.imp"
STCODE = 88;
#line 5520 "test-new/nrimp10s-77.imp"
L_0513:;
// 5521 %FINISH
#line 5521 "test-new/nrimp10s-77.imp"
L_0512:;
// 5522 CNAME(3,REG); ! DESCRPTR TO ACC
#line 5522 "test-new/nrimp10s-77.imp"
CNAME(3, REG);
// 5523 R_PTYPE=16_61; R_FLAG=9
#line 5523 "test-new/nrimp10s-77.imp"
R.PTYPE = 97;
#line 5523 "test-new/nrimp10s-77.imp"
R.FLAG = 9;
// 5524 R_XB=REG
#line 5524 "test-new/nrimp10s-77.imp"
R.XB = REG;
// 5525 OLINK(REG)=ADDR(R)
#line 5525 "test-new/nrimp10s-77.imp"
OLINK[REG] = _imp_ADDR(/*?*/ &R);
// 5526 REGISTER(REG)=1
#line 5526 "test-new/nrimp10s-77.imp"
REGISTER[REG] = 1;
// 5527 ->F81 %UNLESS A(P)=2; ! NO REST OF EXP ON RHS
#line 5527 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0514;
#line 5527 "test-new/nrimp10s-77.imp"
goto U_1033;
#line 5527 "test-new/nrimp10s-77.imp"
L_0514:;
// 5528 Q=P+1; P=P1
#line 5528 "test-new/nrimp10s-77.imp"
Q = P + 1;
#line 5528 "test-new/nrimp10s-77.imp"
P = P1;
// 5529 ->F83 %UNLESS TYPE=TYPEP %AND PREC=PRECP
#line 5529 "test-new/nrimp10s-77.imp"
if (TYPE != TYPEP) goto L_0515;
#line 5529 "test-new/nrimp10s-77.imp"
if (PREC == PRECP) goto L_0516;
#line 5529 "test-new/nrimp10s-77.imp"
L_0515:;
#line 5529 "test-new/nrimp10s-77.imp"
goto U_1035;
#line 5529 "test-new/nrimp10s-77.imp"
L_0516:;
// 5530 ->F86 %UNLESS OLDI<=LVL %OR BASE=0 %OR NAM#0
#line 5530 "test-new/nrimp10s-77.imp"
if (OLDI <= LVL) goto L_0517;
#line 5530 "test-new/nrimp10s-77.imp"
if (BASE == 0) goto L_0517;
#line 5530 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_0517;
#line 5530 "test-new/nrimp10s-77.imp"
goto U_1036;
#line 5530 "test-new/nrimp10s-77.imp"
L_0517:;
// 5531 ! GLOBAL == NONOWN LOCAL
// 5532 CNAME(6,0)
#line 5532 "test-new/nrimp10s-77.imp"
CNAME(6, 0);
// 5533 %IF R_FLAG#9 %THEN %START
#line 5533 "test-new/nrimp10s-77.imp"
if (R.FLAG == 9) goto L_0518;
// 5534 %IF REG#ACCR %THEN ABORT
#line 5534 "test-new/nrimp10s-77.imp"
if (REG == 0) goto L_0519;
#line 5534 "test-new/nrimp10s-77.imp"
ABORT();
#line 5534 "test-new/nrimp10s-77.imp"
L_0519:;
// 5535 PF1(LSD,0,TOS,0)
#line 5535 "test-new/nrimp10s-77.imp"
PF1(100, 0, 6, 0);
// 5536 GRUSE(ACCR)=0
#line 5536 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 5537 %FINISH
#line 5537 "test-new/nrimp10s-77.imp"
L_0518:;
// 5538 REGISTER(REG)=0
#line 5538 "test-new/nrimp10s-77.imp"
REGISTER[REG] = 0;
// 5539 COM: PSORLF1(STCODE,ACCESS,AREA CODE,DISP)
#line 5539 "test-new/nrimp10s-77.imp"
U_1037:;
#line 5539 "test-new/nrimp10s-77.imp"
PSORLF1(STCODE, ACCESS, AREACODE(), DISP);
// 5540 %IF REG=DR %AND ACCESS#0 %THEN ABORT
#line 5540 "test-new/nrimp10s-77.imp"
if (REG != 1) goto L_051A;
#line 5540 "test-new/nrimp10s-77.imp"
if (ACCESS == 0) goto L_051A;
#line 5540 "test-new/nrimp10s-77.imp"
ABORT();
#line 5540 "test-new/nrimp10s-77.imp"
L_051A:;
// 5541 NOTE ASSMENT(REG,1,A(P1)<<8!A(P1+1))
#line 5541 "test-new/nrimp10s-77.imp"
NOTEASSMENT(REG, 1, A[P1] << 8 | A[P1 + 1]);
// 5542 P=Q; %RETURN
#line 5542 "test-new/nrimp10s-77.imp"
P = Q;
#line 5542 "test-new/nrimp10s-77.imp"
return;
// 5543 ARRNAME: CNAME(12,ACCR)
#line 5543 "test-new/nrimp10s-77.imp"
U_1034:;
#line 5543 "test-new/nrimp10s-77.imp"
CNAME(12, 0);
// 5544 %IF ACCESS>=8 %THEN ACCESS=ACCESS-4 %ELSE ACCESS=0
#line 5544 "test-new/nrimp10s-77.imp"
if (ACCESS < 8) goto L_051B;
#line 5544 "test-new/nrimp10s-77.imp"
ACCESS = ACCESS - 4;
#line 5544 "test-new/nrimp10s-77.imp"
goto L_051C;
#line 5544 "test-new/nrimp10s-77.imp"
L_051B:;
#line 5544 "test-new/nrimp10s-77.imp"
ACCESS = 0;
#line 5544 "test-new/nrimp10s-77.imp"
L_051C:;
// 5545 ->F83 %UNLESS TYPE=TYPEP %AND PREC=PRECP %AND ARR>0
#line 5545 "test-new/nrimp10s-77.imp"
if (TYPE != TYPEP) goto L_051D;
#line 5545 "test-new/nrimp10s-77.imp"
if (PREC != PRECP) goto L_051D;
#line 5545 "test-new/nrimp10s-77.imp"
if (ARR > 0) goto L_051E;
#line 5545 "test-new/nrimp10s-77.imp"
L_051D:;
#line 5545 "test-new/nrimp10s-77.imp"
goto U_1035;
#line 5545 "test-new/nrimp10s-77.imp"
L_051E:;
// 5546 ->F86 %UNLESS OLDI<=LVL %OR BASE=0 %OR NAM#0
#line 5546 "test-new/nrimp10s-77.imp"
if (OLDI <= LVL) goto L_051F;
#line 5546 "test-new/nrimp10s-77.imp"
if (BASE == 0) goto L_051F;
#line 5546 "test-new/nrimp10s-77.imp"
if (NAM != 0) goto L_051F;
#line 5546 "test-new/nrimp10s-77.imp"
goto U_1036;
#line 5546 "test-new/nrimp10s-77.imp"
L_051F:;
// 5547 ! GLOBAL == NONOWN LOCAL
// 5548 TYPE=0
#line 5548 "test-new/nrimp10s-77.imp"
TYPE = 0;
// 5549 NAMEOP(2,ACCR,16,-1)
#line 5549 "test-new/nrimp10s-77.imp"
NAMEOP(2, 0, 16, -1);
// 5550 R_PTYPE=16_72; R_UPTYPE=0
#line 5550 "test-new/nrimp10s-77.imp"
R.PTYPE = 114;
#line 5550 "test-new/nrimp10s-77.imp"
R.UPTYPE = 0;
// 5551 R_FLAG=9; R_XB=ACCR
#line 5551 "test-new/nrimp10s-77.imp"
R.FLAG = 9;
#line 5551 "test-new/nrimp10s-77.imp"
R.XB = 0;
// 5552 R_D=-1
#line 5552 "test-new/nrimp10s-77.imp"
R.D = -1;
// 5553 REGISTER(ACCR)=1
#line 5553 "test-new/nrimp10s-77.imp"
REGISTER[0] = 1;
// 5554 OLINK(ACCR)=ADDR(R)
#line 5554 "test-new/nrimp10s-77.imp"
OLINK[0] = _imp_ADDR(/*?*/ &R);
// 5555 ->F81 %UNLESS A(P)=2
#line 5555 "test-new/nrimp10s-77.imp"
if (A[P] == 2) goto L_0520;
#line 5555 "test-new/nrimp10s-77.imp"
goto U_1033;
#line 5555 "test-new/nrimp10s-77.imp"
L_0520:;
// 5556 Q=P+1; P=P1
#line 5556 "test-new/nrimp10s-77.imp"
Q = P + 1;
#line 5556 "test-new/nrimp10s-77.imp"
P = P1;
// 5557 CNAME(6,0)
#line 5557 "test-new/nrimp10s-77.imp"
CNAME(6, 0);
// 5558 PF1(LSQ,0,TOS,0) %UNLESS R_FLAG=9
#line 5558 "test-new/nrimp10s-77.imp"
if (R.FLAG == 9) goto L_0521;
#line 5558 "test-new/nrimp10s-77.imp"
PF1(102, 0, 6, 0);
#line 5558 "test-new/nrimp10s-77.imp"
L_0521:;
// 5559 REGISTER(ACCR)=0
#line 5559 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 5560 ->COM
#line 5560 "test-new/nrimp10s-77.imp"
goto U_1037;
// 5561 F83: FAULT2(83,LHNAME,RHNAME); ->F00
#line 5561 "test-new/nrimp10s-77.imp"
U_1035:;
#line 5561 "test-new/nrimp10s-77.imp"
FAULT2(83, LHNAME, RHNAME);
#line 5561 "test-new/nrimp10s-77.imp"
goto U_102F;
// 5562 F86: FAULT2(86,LHNAME,RHNAME); ->F00
#line 5562 "test-new/nrimp10s-77.imp"
U_1036:;
#line 5562 "test-new/nrimp10s-77.imp"
FAULT2(86, LHNAME, RHNAME);
#line 5562 "test-new/nrimp10s-77.imp"
goto U_102F;
// 5563 F81: FAULT2(81,0,LHNAME)
#line 5563 "test-new/nrimp10s-77.imp"
U_1033:;
#line 5563 "test-new/nrimp10s-77.imp"
FAULT2(81, 0, LHNAME);
// 5564 F00:
#line 5564 "test-new/nrimp10s-77.imp"
U_102F:;
// 5565 REGISTER(REG)=0
#line 5565 "test-new/nrimp10s-77.imp"
REGISTER[REG] = 0;
// 5566 P=P2; SKIP EXP
#line 5566 "test-new/nrimp10s-77.imp"
P = P2;
#line 5566 "test-new/nrimp10s-77.imp"
SKIPEXP();
// 5567 %END
#line 5567 "test-new/nrimp10s-77.imp"
return;
#line 5567 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 5567 "test-new/nrimp10s-77.imp"
if (SW_index < 0 || SW_index > 3)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 5567 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 0];
#line 5567 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 5567 "test-new/nrimp10s-77.imp"
} /* end of ASSIGN */
// 5568 %ROUTINE CSEXP(%INTEGER REG,MODE)
#line 5568 "test-new/nrimp10s-77.imp"
void CSEXP(int REG, int MODE) {
// 5569 !***********************************************************************
// 5570 !* COMPILE A SIGNED EXPRESSION TO REGISTER 'REG' IN MODE 'MODE' *
// 5571 !* MODE=1 FOR %INTEGER, =2 REAL, =3 LONG,=0 INTEGER %IF POSSIBLE *
// 5572 !* MODE=5 FOR ADDRESS EXPRESSNS(IE LEAVE ANY CONSTANT IN 'ADISP')*
// 5573 !***********************************************************************
// 5574 %INTEGER EXPHEAD,NOPS,EXPBOT
#line 5574 "test-new/nrimp10s-77.imp"
int EXPHEAD;
#line 5574 "test-new/nrimp10s-77.imp"
int NOPS;
#line 5574 "test-new/nrimp10s-77.imp"
int EXPBOT;
// 5575 EXPHEAD=0; EXPBOT=0
#line 5575 "test-new/nrimp10s-77.imp"
EXPHEAD = 0;
#line 5575 "test-new/nrimp10s-77.imp"
EXPBOT = 0;
// 5576 NOPS=0
#line 5576 "test-new/nrimp10s-77.imp"
NOPS = 0;
// 5577 P=P+3
#line 5577 "test-new/nrimp10s-77.imp"
P = P + 3;
// 5578 TORP(EXPHEAD,EXPBOT,NOPS)
#line 5578 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &EXPHEAD, /*?*/ &EXPBOT, /*?*/ &NOPS);
// 5579 !
// 5580 EXPOP(EXPHEAD,REG,NOPS,MODE)
#line 5580 "test-new/nrimp10s-77.imp"
EXPOP(EXPHEAD, REG, NOPS, MODE);
// 5581 ! CLEAR LIST(EXPHEAD)
// 5582 ASLIST(EXPBOT)_LINK=ASL
#line 5582 "test-new/nrimp10s-77.imp"
ASLIST[EXPBOT].LINK = ASL;
// 5583 ASL=EXPHEAD
#line 5583 "test-new/nrimp10s-77.imp"
ASL = EXPHEAD;
// 5584 %END
#line 5584 "test-new/nrimp10s-77.imp"
return;
#line 5584 "test-new/nrimp10s-77.imp"
} /* end of CSEXP */
// 5585 %INTEGERFN CONSTEXP(%INTEGER PRECTYPE)
#line 5585 "test-new/nrimp10s-77.imp"
int CONSTEXP(int PRECTYPE) {
// 5586 !***********************************************************************
// 5587 !* COMPILES AN EXPRESSION WHICH SHOULD EVALUATE TO A CONSTANT OF *
// 5588 !* TYPE 'PRECTYPE'. P AS FOR FN INTEXP. *
// 5589 !***********************************************************************
// 5590 %INTEGER EXPHEAD,EXPBOT,NOPS,RES
#line 5590 "test-new/nrimp10s-77.imp"
int EXPHEAD;
#line 5590 "test-new/nrimp10s-77.imp"
int EXPBOT;
#line 5590 "test-new/nrimp10s-77.imp"
int NOPS;
#line 5590 "test-new/nrimp10s-77.imp"
int RES;
// 5591 EXPHEAD=0; EXPBOT=0; NOPS=0; RES=0
#line 5591 "test-new/nrimp10s-77.imp"
EXPHEAD = 0;
#line 5591 "test-new/nrimp10s-77.imp"
EXPBOT = 0;
#line 5591 "test-new/nrimp10s-77.imp"
NOPS = 0;
#line 5591 "test-new/nrimp10s-77.imp"
RES = 0;
// 5592 TORP(EXPHEAD,EXPBOT,NOPS)
#line 5592 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &EXPHEAD, /*?*/ &EXPBOT, /*?*/ &NOPS);
// 5593 ->WAYOUT %UNLESS NOPS&16_00040000=0
#line 5593 "test-new/nrimp10s-77.imp"
if (NOPS & 262144 == 0) goto L_0522;
#line 5593 "test-new/nrimp10s-77.imp"
goto U_1038;
#line 5593 "test-new/nrimp10s-77.imp"
L_0522:;
// 5594 EXPOP(EXPHEAD,ACCR,NOPS,16_200+PRECTYPE)
#line 5594 "test-new/nrimp10s-77.imp"
EXPOP(EXPHEAD, 0, NOPS, 512 + PRECTYPE);
// 5595 %IF EXPOPND_FLAG=3 %THEN RES=EXPOPND_XTRA %AND ->WAYOUT
#line 5595 "test-new/nrimp10s-77.imp"
if (EXPOPND.FLAG != 3) goto L_0523;
#line 5595 "test-new/nrimp10s-77.imp"
RES = EXPOPND.XTRA;
#line 5595 "test-new/nrimp10s-77.imp"
goto U_1038;
#line 5595 "test-new/nrimp10s-77.imp"
L_0523:;
// 5596 ->WAYOUT %UNLESS EXPOPND_FLAG<=1
#line 5596 "test-new/nrimp10s-77.imp"
if (EXPOPND.FLAG <= 1) goto L_0524;
#line 5596 "test-new/nrimp10s-77.imp"
goto U_1038;
#line 5596 "test-new/nrimp10s-77.imp"
L_0524:;
// 5597 RES=ADDR(EXPOPND_D)
#line 5597 "test-new/nrimp10s-77.imp"
RES = _imp_ADDR(/*?*/ &EXPOPND.D);
// 5598 WAYOUT:
#line 5598 "test-new/nrimp10s-77.imp"
U_1038:;
// 5599 %MONITOR %IF RES=0 %AND DCOMP#0
#line 5599 "test-new/nrimp10s-77.imp"
if (RES != 0) goto L_0525;
#line 5599 "test-new/nrimp10s-77.imp"
if (DCOMP == 0) goto L_0525;
#line 5599 "test-new/nrimp10s-77.imp"
/*_imp_monitor(__LINE__, __FILE__, PRETTY_FUNCTION);*/
#line 5599 "test-new/nrimp10s-77.imp"
L_0525:;
// 5600 ASLIST(EXPBOT)_LINK=ASL
#line 5600 "test-new/nrimp10s-77.imp"
ASLIST[EXPBOT].LINK = ASL;
// 5601 ASL=EXPHEAD
#line 5601 "test-new/nrimp10s-77.imp"
ASL = EXPHEAD;
// 5602 %RESULT=RES
#line 5602 "test-new/nrimp10s-77.imp"
return RES;
// 5603 %END
#line 5603 "test-new/nrimp10s-77.imp"
} /* end of CONSTEXP */
// 5604 %INTEGERFN INTEXP(%INTEGERNAME VALUE)
#line 5604 "test-new/nrimp10s-77.imp"
int INTEXP(int *VALUE) {
// 5605 !***********************************************************************
// 5606 !* COMPILES AN EXPRESSION WHICH SHOULD EVALUATE TO A CONSTANT *
// 5607 !* VALUE RETURNED IN VALUE. RESULT#0 IF FAILED TO EVALUATE *
// 5608 !* P POINTS TO P(+') IN (+')(OPERNAD)(RESTOFEXPR) *
// 5609 !***********************************************************************
// 5610 %INTEGER EXPHEAD,EXPBOT,NOPS,CODE,SPTYPE,SACC
#line 5610 "test-new/nrimp10s-77.imp"
int EXPHEAD;
#line 5610 "test-new/nrimp10s-77.imp"
int EXPBOT;
#line 5610 "test-new/nrimp10s-77.imp"
int NOPS;
#line 5610 "test-new/nrimp10s-77.imp"
int CODE;
#line 5610 "test-new/nrimp10s-77.imp"
int SPTYPE;
#line 5610 "test-new/nrimp10s-77.imp"
int SACC;
// 5611 EXPHEAD=0; EXPBOT=0; NOPS=0; CODE=0
#line 5611 "test-new/nrimp10s-77.imp"
EXPHEAD = 0;
#line 5611 "test-new/nrimp10s-77.imp"
EXPBOT = 0;
#line 5611 "test-new/nrimp10s-77.imp"
NOPS = 0;
#line 5611 "test-new/nrimp10s-77.imp"
CODE = 0;
// 5612 SPTYPE=PTYPE; SACC=ACC; ! CALLED IN DECLARATIONS
#line 5612 "test-new/nrimp10s-77.imp"
SPTYPE = PTYPE;
#line 5612 "test-new/nrimp10s-77.imp"
SACC = ACC;
// 5613 TORP(EXPHEAD,EXPBOT,NOPS)
#line 5613 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &EXPHEAD, /*?*/ &EXPBOT, /*?*/ &NOPS);
// 5614 %IF NOPS&16_00040000=0 %AND TYPE=1 %START
#line 5614 "test-new/nrimp10s-77.imp"
if (NOPS & 262144 != 0) goto L_0526;
#line 5614 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0526;
// 5615 EXPOP(EXPHEAD,ACCR,NOPS,16_251)
#line 5615 "test-new/nrimp10s-77.imp"
EXPOP(EXPHEAD, 0, NOPS, 593);
// 5616 CODE=1 %UNLESS EXPOPND_FLAG<=1 %AND EXPOPND_PTYPE=16_51
#line 5616 "test-new/nrimp10s-77.imp"
if (EXPOPND.FLAG > 1) goto L_0527;
#line 5616 "test-new/nrimp10s-77.imp"
if (EXPOPND.PTYPE == 81) goto L_0528;
#line 5616 "test-new/nrimp10s-77.imp"
L_0527:;
#line 5616 "test-new/nrimp10s-77.imp"
CODE = 1;
#line 5616 "test-new/nrimp10s-77.imp"
L_0528:;
// 5617 VALUE=EXPOPND_D
#line 5617 "test-new/nrimp10s-77.imp"
*VALUE = EXPOPND.D;
// 5618 %FINISH %ELSE CODE=1 %AND VALUE=1
#line 5618 "test-new/nrimp10s-77.imp"
goto L_0529;
#line 5618 "test-new/nrimp10s-77.imp"
L_0526:;
#line 5618 "test-new/nrimp10s-77.imp"
CODE = 1;
#line 5618 "test-new/nrimp10s-77.imp"
*VALUE = 1;
#line 5618 "test-new/nrimp10s-77.imp"
L_0529:;
// 5619 ASLIST(EXPBOT)_LINK=ASL
#line 5619 "test-new/nrimp10s-77.imp"
ASLIST[EXPBOT].LINK = ASL;
// 5620 ASL=EXPHEAD
#line 5620 "test-new/nrimp10s-77.imp"
ASL = EXPHEAD;
// 5621 ACC=SACC; PTYPE=SPTYPE
#line 5621 "test-new/nrimp10s-77.imp"
ACC = SACC;
#line 5621 "test-new/nrimp10s-77.imp"
PTYPE = SPTYPE;
// 5622 UNPACK
#line 5622 "test-new/nrimp10s-77.imp"
UNPACK();
// 5623 %RESULT=CODE
#line 5623 "test-new/nrimp10s-77.imp"
return CODE;
// 5624 %END
#line 5624 "test-new/nrimp10s-77.imp"
} /* end of INTEXP */
// 5625 %ROUTINE TORP(%INTEGERNAME HEAD,BOT,NOPS)
#line 5625 "test-new/nrimp10s-77.imp"
void TORP(int *HEAD, int *BOT, int *NOPS) {
// 5626 !***********************************************************************
// 5627 !* CONVERT THE SIGNED EXPRESSION INDEXED BY P INTO REVERSE *
// 5628 !* POLISH NOTATION. THE REVERSE POLISH LIST IS ADDED TO 'HEAD' *
// 5629 !* WHICH MAY CONTAIN ANOTHER EXPRESSION. THE NUMBER OF OPERATORS *
// 5630 !* IS ADDED TO NOPS. *
// 5631 !* N.B. AN INTEGER EXPRESSION IS A SPECIAL CASE OF A REAL EXPRSN *
// 5632 !* THE TOP 20 BITS OF NOPS ARE USED TO RETURN DETAILS OF THE EXPR *
// 5633 !* THESE BITS SIGNIFY AS FOLLOWS:- *
// 5634 !* 1<<17 CONTAINS VARIABLE OF MORE THAN 32 BITS *
// 5635 !* 1<<18 NOT CONSTANT EXPRSSN IE CONTAINS AT LEAST 1 VARIABLE *
// 5636 !* 1<<19 COMPLEX IE CONTAINS FN CALL OR NEEDS DR TO EVALUATE *
// 5637 !* 1<<20 CONTAINS THE OPERATOR + *
// 5638 !* 1<<21 CONTAINS THE - OPERATOR(INCLUDES UNARY MINUS) *
// 5639 !* 1<<22 CONTAINS OPERATOR !! (INCUDES UNARY NOT) *
// 5640 !* 1<<23-7 CONTAINS OPERATORS !,*,//,/,& RESPECTIVELY *
// 5641 !* 1<28&9 CONTAINS << OR >> *
// 5642 !* 1<<30 CONTAINS EXPONETIATION *
// 5643 !***********************************************************************
// 5644 %SWITCH OPERAND(1:3)
#line 5644 "test-new/nrimp10s-77.imp"
int OPERAND_index;
#line 5644 "test-new/nrimp10s-77.imp"
int OPERAND_line;
#line 5644 "test-new/nrimp10s-77.imp"
char *OPERAND_file;
#line 5644 "test-new/nrimp10s-77.imp"
static const void *OPERAND[3] = {&&case_OPERAND_missing, &&case_OPERAND_missing, &&case_OPERAND_missing};
// 5645 %CONSTBYTEINTEGERARRAY PRECEDENCE(1:15)=3,3,4,5,5,4,3,3,4,4,5,5,3,5,5;
#line 5645 "test-new/nrimp10s-77.imp"
const unsigned char PRECEDENCE[15] = {3, 3, 4, 5, 5, 4, 3, 3, 4, 4, 5, 5, 3, 5, 5};
// 5646 %CONSTBYTEINTEGERARRAY OPVAL(1:15)=20,21,27,37,30,24,22,23,25,26,
#line 5646 "test-new/nrimp10s-77.imp"
const unsigned char OPVAL[15] = {20, 21, 27, 37, 30, 24, 22, 23, 25, 26, 28, 29, 20, 37, 30};
// 5647+ 28,29,20,37,30;
// 5648 %INTEGER RPHEAD,PASSHEAD,SAVEHEAD,REAL,REALOP,COMPLEX,{%C
#line 5648 "test-new/nrimp10s-77.imp"
int RPHEAD;
#line 5648 "test-new/nrimp10s-77.imp"
int PASSHEAD;
#line 5648 "test-new/nrimp10s-77.imp"
int SAVEHEAD;
#line 5648 "test-new/nrimp10s-77.imp"
int REAL;
#line 5648 "test-new/nrimp10s-77.imp"
int REALOP;
#line 5648 "test-new/nrimp10s-77.imp"
int COMPLEX;
#line 5648 "test-new/nrimp10s-77.imp"
int OPERATOR;
#line 5648 "test-new/nrimp10s-77.imp"
int OPPREC;
#line 5648 "test-new/nrimp10s-77.imp"
int OPND;
#line 5648 "test-new/nrimp10s-77.imp"
int C;
#line 5648 "test-new/nrimp10s-77.imp"
int D;
#line 5648 "test-new/nrimp10s-77.imp"
int E;
#line 5648 "test-new/nrimp10s-77.imp"
int RPTYPE;
#line 5648 "test-new/nrimp10s-77.imp"
int RPINF;
#line 5648 "test-new/nrimp10s-77.imp"
int BDISP;
#line 5648 "test-new/nrimp10s-77.imp"
int OPNAME;
#line 5648 "test-new/nrimp10s-77.imp"
int OPMASK;
#line 5648 "test-new/nrimp10s-77.imp"
int XTRA;
#line 5648 "test-new/nrimp10s-77.imp"
int RPBOT;
#line 5648 "test-new/nrimp10s-77.imp"
int OPSTK;
#line 5648 "test-new/nrimp10s-77.imp"
int OPPSTK;
#line 5648 "test-new/nrimp10s-77.imp"
int PASSBOT;
// 5649+ OPERATOR,OPPREC,OPND,C,D,E,RPTYPE,RPINF,BDISP,{%C
// 5650+ OPNAME,OPMASK,XTRA,RPBOT,OPSTK,OPPSTK,PASSBOT
// 5651 %RECORD(LISTF)%NAME LCELL{(LISTF)
#line 5651 "test-new/nrimp10s-77.imp"
struct LISTF *LCELL;
// 5652 !
// 5653 PASSHEAD=0; RPHEAD=0; SAVEHEAD=0
#line 5653 "test-new/nrimp10s-77.imp"
PASSHEAD = 0;
#line 5653 "test-new/nrimp10s-77.imp"
RPHEAD = 0;
#line 5653 "test-new/nrimp10s-77.imp"
SAVEHEAD = 0;
// 5654 REAL=0; REALOP=0; BDISP=0
#line 5654 "test-new/nrimp10s-77.imp"
REAL = 0;
#line 5654 "test-new/nrimp10s-77.imp"
REALOP = 0;
#line 5654 "test-new/nrimp10s-77.imp"
BDISP = 0;
// 5655 RPBOT=0; OPSTK=0; OPPSTK=0
#line 5655 "test-new/nrimp10s-77.imp"
RPBOT = 0;
#line 5655 "test-new/nrimp10s-77.imp"
OPSTK = 0;
#line 5655 "test-new/nrimp10s-77.imp"
OPPSTK = 0;
// 5656 !
// 5657 C=A(P)
#line 5657 "test-new/nrimp10s-77.imp"
C = A[P];
// 5658 %IF 2<=C<=3 %THEN %START; ! INITIAL '-' OR '\'
#line 5658 "test-new/nrimp10s-77.imp"
{
// Double-sided test on C (Part I)
#line 5658 "test-new/nrimp10s-77.imp"
int tmp;
#line 5658 "test-new/nrimp10s-77.imp"
if (2 > (tmp = C)) goto L_052A;
// Double-sided test on C (Part II)
#line 5658 "test-new/nrimp10s-77.imp"
if (tmp > 3) goto L_052A;
#line 5658 "test-new/nrimp10s-77.imp"
}
// 5659 NOPS=NOPS+1
#line 5659 "test-new/nrimp10s-77.imp"
*NOPS = *NOPS + 1;
// 5660 ! '-' =(11,3) '\' =(10,5)
// 5661 OPSTK=4-C
#line 5661 "test-new/nrimp10s-77.imp"
OPSTK = 4 - C;
// 5662 OPPSTK=C<<1-1
#line 5662 "test-new/nrimp10s-77.imp"
OPPSTK = (C << 1) - 1;
// 5663 OPMASK=1<<(19+C); ! - %OR !!
#line 5663 "test-new/nrimp10s-77.imp"
OPMASK = 1 << 19 + C;
// 5664 %FINISH %ELSE OPMASK=0
#line 5664 "test-new/nrimp10s-77.imp"
goto L_052B;
#line 5664 "test-new/nrimp10s-77.imp"
L_052A:;
#line 5664 "test-new/nrimp10s-77.imp"
OPMASK = 0;
#line 5664 "test-new/nrimp10s-77.imp"
L_052B:;
// 5665 NEXTOPND:OPND=A(P+1); P=P+2
#line 5665 "test-new/nrimp10s-77.imp"
U_1033:;
#line 5665 "test-new/nrimp10s-77.imp"
OPND = A[P + 1];
#line 5665 "test-new/nrimp10s-77.imp"
P = P + 2;
// 5666 COMPLEX=0; XTRA=0
#line 5666 "test-new/nrimp10s-77.imp"
COMPLEX = 0;
#line 5666 "test-new/nrimp10s-77.imp"
XTRA = 0;
// 5667 -> OPERAND(OPND); ! SWITCH ON OPERAND
#line 5667 "test-new/nrimp10s-77.imp"
OPERAND_line = __LINE__;
OPERAND_file = __FILE__;
OPERAND_index = OPND;
goto case_OPERAND_dispatch;
// 5668 OPERAND(1): ! NAME
#line 5668 "test-new/nrimp10s-77.imp"
case_OPERAND_1:;
// 5669 OPNAME=A(P)<<8+A(P+1)
#line 5669 "test-new/nrimp10s-77.imp"
OPNAME = (A[P] << 8) + A[P + 1];
// 5670 LCELL==ASLIST(TAGS(OPNAME))
#line 5670 "test-new/nrimp10s-77.imp"
LCELL = (struct LISTF *)/*?*/ &ASLIST[TAGS[OPNAME]];
// 5671 PTYPE=LCELL_S1>>16
#line 5671 "test-new/nrimp10s-77.imp"
PTYPE = (unsigned int)LCELL->S1 >> 16;
// 5672 %IF PTYPE=16_FFFF %THEN PTYPE=7;! NAME NOT SET
#line 5672 "test-new/nrimp10s-77.imp"
if (PTYPE != 65535) goto L_052D;
#line 5672 "test-new/nrimp10s-77.imp"
PTYPE = 7;
#line 5672 "test-new/nrimp10s-77.imp"
L_052D:;
// 5673 TYPE=PTYPE&7; PREC=PTYPE>>4&15
#line 5673 "test-new/nrimp10s-77.imp"
TYPE = PTYPE & 7;
#line 5673 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)PTYPE >> 4 & 15;
// 5674 %IF PTYPE=SNPT %THEN %START
#line 5674 "test-new/nrimp10s-77.imp"
if (PTYPE != 4102) goto L_052E;
// 5675 D=LCELL_S3>>16
#line 5675 "test-new/nrimp10s-77.imp"
D = (unsigned int)LCELL->S3 >> 16;
// 5676 %IF D=38 %AND A(P+2)=2 %THEN %START; ! PICK OFF NL
#line 5676 "test-new/nrimp10s-77.imp"
if (D != 38) goto L_052F;
#line 5676 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_052F;
// 5677 RPTYPE=0; RPINF=10; PTYPE=16_51; P=P+2; ->SKNAM
#line 5677 "test-new/nrimp10s-77.imp"
RPTYPE = 0;
#line 5677 "test-new/nrimp10s-77.imp"
RPINF = 10;
#line 5677 "test-new/nrimp10s-77.imp"
PTYPE = 81;
#line 5677 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 5677 "test-new/nrimp10s-77.imp"
goto U_1034;
// 5678 %FINISH
#line 5678 "test-new/nrimp10s-77.imp"
L_052F:;
// 5679 %IF D=52 %AND A(P+2)=2 %START;! PICK OFF PI
#line 5679 "test-new/nrimp10s-77.imp"
if (D != 52) goto L_0530;
#line 5679 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_0530;
// 5680 RPTYPE=1; PTYPE=16_62; RPINF=16_413243F6
#line 5680 "test-new/nrimp10s-77.imp"
RPTYPE = 1;
#line 5680 "test-new/nrimp10s-77.imp"
PTYPE = 98;
#line 5680 "test-new/nrimp10s-77.imp"
RPINF = 1093813238;
// 5681 XTRA=16_A8885A31
#line 5681 "test-new/nrimp10s-77.imp"
XTRA = -1467459023;
// 5682 P=P+2; REAL=1; ->SKNAM
#line 5682 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 5682 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5682 "test-new/nrimp10s-77.imp"
goto U_1034;
// 5683 %FINISH
#line 5683 "test-new/nrimp10s-77.imp"
L_0530:;
// 5684 COMPLEX=1
#line 5684 "test-new/nrimp10s-77.imp"
COMPLEX = 1;
// 5685 PTYPE=TSNAME(D); UNPACK
#line 5685 "test-new/nrimp10s-77.imp"
PTYPE = TSNAME[D];
#line 5685 "test-new/nrimp10s-77.imp"
UNPACK();
// 5686 %FINISH
#line 5686 "test-new/nrimp10s-77.imp"
L_052E:;
// 5687 %IF PTYPE&16_FF00=16_4000 %AND A(P+2)=2=A(P+3) %AND 1<=TYPE<=2 %THEN %START; ! CONST VAR
#line 5687 "test-new/nrimp10s-77.imp"
if (PTYPE & 65280 != 16384) goto L_0531;
#line 5687 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 2 (Part I)
#line 5687 "test-new/nrimp10s-77.imp"
int tmp;
#line 5687 "test-new/nrimp10s-77.imp"
if (A[P + 2] != (tmp = 2)) goto L_0531;
// Double-sided test on 2 (Part II)
#line 5687 "test-new/nrimp10s-77.imp"
if (tmp != A[P + 3]) goto L_0531;
#line 5687 "test-new/nrimp10s-77.imp"
}
#line 5687 "test-new/nrimp10s-77.imp"
{
// Double-sided test on TYPE (Part I)
#line 5687 "test-new/nrimp10s-77.imp"
int tmp;
#line 5687 "test-new/nrimp10s-77.imp"
if (1 > (tmp = TYPE)) goto L_0531;
// Double-sided test on TYPE (Part II)
#line 5687 "test-new/nrimp10s-77.imp"
if (tmp > 2) goto L_0531;
#line 5687 "test-new/nrimp10s-77.imp"
}
// 5688 LCELL_S1=LCELL_S1!16_8000; ! SET USED BIT
#line 5688 "test-new/nrimp10s-77.imp"
LCELL->S1 = LCELL->S1 | 32768;
// 5689 RPINF=LCELL_S2; XTRA=LCELL_S3
#line 5689 "test-new/nrimp10s-77.imp"
RPINF = LCELL->S2;
#line 5689 "test-new/nrimp10s-77.imp"
XTRA = LCELL->S3;
// 5690 RPTYPE=1; PTYPE=PTYPE&255
#line 5690 "test-new/nrimp10s-77.imp"
RPTYPE = 1;
#line 5690 "test-new/nrimp10s-77.imp"
PTYPE = PTYPE & 255;
// 5691 %IF TYPE=1 %AND PREC<=5 %AND 16_FFFE0000<=RPINF<=16_1FFFF %THEN RPTYPE=0 %AND PTYPE=16_51
#line 5691 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0532;
#line 5691 "test-new/nrimp10s-77.imp"
if (PREC > 5) goto L_0532;
#line 5691 "test-new/nrimp10s-77.imp"
{
// Double-sided test on RPINF (Part I)
#line 5691 "test-new/nrimp10s-77.imp"
int tmp;
#line 5691 "test-new/nrimp10s-77.imp"
if (-131072 > (tmp = RPINF)) goto L_0532;
// Double-sided test on RPINF (Part II)
#line 5691 "test-new/nrimp10s-77.imp"
if (tmp > 131071) goto L_0532;
#line 5691 "test-new/nrimp10s-77.imp"
}
#line 5691 "test-new/nrimp10s-77.imp"
RPTYPE = 0;
#line 5691 "test-new/nrimp10s-77.imp"
PTYPE = 81;
#line 5691 "test-new/nrimp10s-77.imp"
L_0532:;
// 5692 %IF PREC=7 %THEN RPTYPE=3
#line 5692 "test-new/nrimp10s-77.imp"
if (PREC != 7) goto L_0533;
#line 5692 "test-new/nrimp10s-77.imp"
RPTYPE = 3;
#line 5692 "test-new/nrimp10s-77.imp"
L_0533:;
// 5693 REAL=1 %IF TYPE=2
#line 5693 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_0534;
#line 5693 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5693 "test-new/nrimp10s-77.imp"
L_0534:;
// 5694 P=P+2; ->SKNAM
#line 5694 "test-new/nrimp10s-77.imp"
P = P + 2;
#line 5694 "test-new/nrimp10s-77.imp"
goto U_1034;
// 5695 %FINISH
#line 5695 "test-new/nrimp10s-77.imp"
L_0531:;
// 5696 XTRA=OPNAME
#line 5696 "test-new/nrimp10s-77.imp"
XTRA = OPNAME;
// 5697 %IF PTYPE&16_3F00#0 %OR PARMCHK=1 %OR PREC<5 %THEN COMPLEX=1 %AND XTRA=-1
#line 5697 "test-new/nrimp10s-77.imp"
if (PTYPE & 16128 != 0) goto L_0535;
#line 5697 "test-new/nrimp10s-77.imp"
if (PARMCHK == 1) goto L_0535;
#line 5697 "test-new/nrimp10s-77.imp"
if (PREC >= 5) goto L_0536;
#line 5697 "test-new/nrimp10s-77.imp"
L_0535:;
#line 5697 "test-new/nrimp10s-77.imp"
COMPLEX = 1;
#line 5697 "test-new/nrimp10s-77.imp"
XTRA = -1;
#line 5697 "test-new/nrimp10s-77.imp"
L_0536:;
// 5698 OPMASK=OPMASK!(COMPLEX<<19)
#line 5698 "test-new/nrimp10s-77.imp"
OPMASK = OPMASK | COMPLEX << 19;
// 5699 %IF A(P+2)#2 %OR A(P+3)#2 %THEN XTRA=-1;! XTRA=NAME FOR LOCAL SCALRS ONLY
#line 5699 "test-new/nrimp10s-77.imp"
if (A[P + 2] != 2) goto L_0537;
#line 5699 "test-new/nrimp10s-77.imp"
if (A[P + 3] == 2) goto L_0538;
#line 5699 "test-new/nrimp10s-77.imp"
L_0537:;
#line 5699 "test-new/nrimp10s-77.imp"
XTRA = -1;
#line 5699 "test-new/nrimp10s-77.imp"
L_0538:;
// 5700 %IF TYPE=3 %THEN %START
#line 5700 "test-new/nrimp10s-77.imp"
if (TYPE != 3) goto L_0539;
// 5701 D=P; KFORM=LCELL_S3&16_FFFF
#line 5701 "test-new/nrimp10s-77.imp"
D = P;
#line 5701 "test-new/nrimp10s-77.imp"
KFORM = LCELL->S3 & 65535;
// 5702 C=COPY RECORD TAG(E); P=D;
#line 5702 "test-new/nrimp10s-77.imp"
C = COPYRECORDTAG(/*?*/ &E);
#line 5702 "test-new/nrimp10s-77.imp"
P = D;
// 5703 COMPLEX=1 %UNLESS E=1 %AND 1<=TYPE<=2 %AND NAM=ARR=0 %AND PREC#3
#line 5703 "test-new/nrimp10s-77.imp"
if (E != 1) goto L_053A;
#line 5703 "test-new/nrimp10s-77.imp"
{
// Double-sided test on TYPE (Part I)
#line 5703 "test-new/nrimp10s-77.imp"
int tmp;
#line 5703 "test-new/nrimp10s-77.imp"
if (1 > (tmp = TYPE)) goto L_053A;
// Double-sided test on TYPE (Part II)
#line 5703 "test-new/nrimp10s-77.imp"
if (tmp > 2) goto L_053A;
#line 5703 "test-new/nrimp10s-77.imp"
}
#line 5703 "test-new/nrimp10s-77.imp"
{
// Double-sided test on ARR (Part I)
#line 5703 "test-new/nrimp10s-77.imp"
int tmp;
#line 5703 "test-new/nrimp10s-77.imp"
if (NAM != (tmp = ARR)) goto L_053A;
// Double-sided test on ARR (Part II)
#line 5703 "test-new/nrimp10s-77.imp"
if (tmp != 0) goto L_053A;
#line 5703 "test-new/nrimp10s-77.imp"
}
#line 5703 "test-new/nrimp10s-77.imp"
if (PREC != 3) goto L_053B;
#line 5703 "test-new/nrimp10s-77.imp"
L_053A:;
#line 5703 "test-new/nrimp10s-77.imp"
COMPLEX = 1;
#line 5703 "test-new/nrimp10s-77.imp"
L_053B:;
// 5704 %FINISH
#line 5704 "test-new/nrimp10s-77.imp"
L_0539:;
// 5705 %IF PREC>=6 %THEN OPMASK=OPMASK!1<<17;! MORE THAN 32 BITS
#line 5705 "test-new/nrimp10s-77.imp"
if (PREC < 6) goto L_053C;
#line 5705 "test-new/nrimp10s-77.imp"
OPMASK = OPMASK | 1 << 17;
#line 5705 "test-new/nrimp10s-77.imp"
L_053C:;
// 5706 RPTYPE=2; RPINF=P; PTYPE=16_51 %IF PTYPE=7
#line 5706 "test-new/nrimp10s-77.imp"
RPTYPE = 2;
#line 5706 "test-new/nrimp10s-77.imp"
RPINF = P;
#line 5706 "test-new/nrimp10s-77.imp"
if (PTYPE != 7) goto L_053D;
#line 5706 "test-new/nrimp10s-77.imp"
PTYPE = 81;
#line 5706 "test-new/nrimp10s-77.imp"
L_053D:;
// 5707 %IF TYPE=5 %THEN FAULT2(76,0,OPNAME) %AND RPTYPE=0 %AND PTYPE=16_51
#line 5707 "test-new/nrimp10s-77.imp"
if (TYPE != 5) goto L_053E;
#line 5707 "test-new/nrimp10s-77.imp"
FAULT2(76, 0, OPNAME);
#line 5707 "test-new/nrimp10s-77.imp"
RPTYPE = 0;
#line 5707 "test-new/nrimp10s-77.imp"
PTYPE = 81;
#line 5707 "test-new/nrimp10s-77.imp"
L_053E:;
// 5708 %IF TYPE=2 %THEN REAL=1
#line 5708 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_053F;
#line 5708 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5708 "test-new/nrimp10s-77.imp"
L_053F:;
// 5709 P=P+2
#line 5709 "test-new/nrimp10s-77.imp"
P = P + 2;
// 5710 SKNAM: %IF A(P)=2 %THEN P=P+1 %ELSE SKIP APP
#line 5710 "test-new/nrimp10s-77.imp"
U_1034:;
#line 5710 "test-new/nrimp10s-77.imp"
if (A[P] != 2) goto L_0540;
#line 5710 "test-new/nrimp10s-77.imp"
P = P + 1;
#line 5710 "test-new/nrimp10s-77.imp"
goto L_0541;
#line 5710 "test-new/nrimp10s-77.imp"
L_0540:;
#line 5710 "test-new/nrimp10s-77.imp"
SKIPAPP();
#line 5710 "test-new/nrimp10s-77.imp"
L_0541:;
// 5711 %IF A(P)=1 %THEN P=P+3 %AND ->SKNAM
#line 5711 "test-new/nrimp10s-77.imp"
if (A[P] != 1) goto L_0542;
#line 5711 "test-new/nrimp10s-77.imp"
P = P + 3;
#line 5711 "test-new/nrimp10s-77.imp"
goto U_1034;
#line 5711 "test-new/nrimp10s-77.imp"
L_0542:;
// 5712 P=P+2
#line 5712 "test-new/nrimp10s-77.imp"
P = P + 2;
// 5713 INS: %IF RPTYPE=2 %THEN OPMASK=OPMASK!1<<18
#line 5713 "test-new/nrimp10s-77.imp"
U_1035:;
#line 5713 "test-new/nrimp10s-77.imp"
if (RPTYPE != 2) goto L_0543;
#line 5713 "test-new/nrimp10s-77.imp"
OPMASK = OPMASK | 1 << 18;
#line 5713 "test-new/nrimp10s-77.imp"
L_0543:;
// 5714 BINSERT(RPHEAD,RPBOT,PTYPE<<16!COMPLEX<<8!RPTYPE,RPINF,XTRA)
#line 5714 "test-new/nrimp10s-77.imp"
BINSERT(/*?*/ &RPHEAD, /*?*/ &RPBOT, PTYPE << 16 | COMPLEX << 8 | RPTYPE, RPINF, XTRA);
// 5715 -> OP
#line 5715 "test-new/nrimp10s-77.imp"
goto U_1036;
// 5716 OPERAND(2): ! CONSTANT
#line 5716 "test-new/nrimp10s-77.imp"
case_OPERAND_2:;
// 5717 PTYPE=A(P); D=PTYPE>>4
#line 5717 "test-new/nrimp10s-77.imp"
PTYPE = A[P];
#line 5717 "test-new/nrimp10s-77.imp"
D = (unsigned int)PTYPE >> 4;
// 5718 C=PTYPE&7
#line 5718 "test-new/nrimp10s-77.imp"
C = PTYPE & 7;
// 5719 %IF D=4 %THEN %START
#line 5719 "test-new/nrimp10s-77.imp"
if (D != 4) goto L_0544;
// 5720 RPINF=FROM AR2(P+1)
#line 5720 "test-new/nrimp10s-77.imp"
RPINF = FROMAR2(P + 1);
// 5721 PTYPE=16_51
#line 5721 "test-new/nrimp10s-77.imp"
PTYPE = 81;
// 5722 %FINISH %ELSE RPINF=FROM AR4(P+1)
#line 5722 "test-new/nrimp10s-77.imp"
goto L_0545;
#line 5722 "test-new/nrimp10s-77.imp"
L_0544:;
#line 5722 "test-new/nrimp10s-77.imp"
RPINF = FROMAR4(P + 1);
#line 5722 "test-new/nrimp10s-77.imp"
L_0545:;
// 5723 REAL=1 %IF C=2; RPTYPE=1
#line 5723 "test-new/nrimp10s-77.imp"
if (C != 2) goto L_0546;
#line 5723 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5723 "test-new/nrimp10s-77.imp"
L_0546:;
#line 5723 "test-new/nrimp10s-77.imp"
RPTYPE = 1;
// 5724 %IF D=6 %THEN XTRA=FROM AR4(P+5)
#line 5724 "test-new/nrimp10s-77.imp"
if (D != 6) goto L_0547;
#line 5724 "test-new/nrimp10s-77.imp"
XTRA = FROMAR4(P + 5);
#line 5724 "test-new/nrimp10s-77.imp"
L_0547:;
// 5725 %IF C=5 %THEN %START; ! STRING CONSTANT
#line 5725 "test-new/nrimp10s-77.imp"
if (C != 5) goto L_0548;
// 5726 FAULT2(77,0,0); RPINF=1; RPTYPE=0
#line 5726 "test-new/nrimp10s-77.imp"
FAULT2(77, 0, 0);
#line 5726 "test-new/nrimp10s-77.imp"
RPINF = 1;
#line 5726 "test-new/nrimp10s-77.imp"
RPTYPE = 0;
// 5727 P=P+A(P+5)+7; PTYPE=16_51
#line 5727 "test-new/nrimp10s-77.imp"
P = P + A[P + 5] + 7;
#line 5727 "test-new/nrimp10s-77.imp"
PTYPE = 81;
// 5728 %FINISH %ELSE %START
#line 5728 "test-new/nrimp10s-77.imp"
goto L_0549;
#line 5728 "test-new/nrimp10s-77.imp"
L_0548:;
// 5729 %IF D=7 %THEN XTRA=ADDR(A(P+1)) %AND RPTYPE=3
#line 5729 "test-new/nrimp10s-77.imp"
if (D != 7) goto L_054A;
#line 5729 "test-new/nrimp10s-77.imp"
XTRA = _imp_ADDR(/*?*/ &A[P + 1]);
#line 5729 "test-new/nrimp10s-77.imp"
RPTYPE = 3;
#line 5729 "test-new/nrimp10s-77.imp"
L_054A:;
// 5730 %IF PTYPE=16_51 %AND 16_FFFE0000<=RPINF<=16_1FFFF %THEN RPTYPE=0
#line 5730 "test-new/nrimp10s-77.imp"
if (PTYPE != 81) goto L_054B;
#line 5730 "test-new/nrimp10s-77.imp"
{
// Double-sided test on RPINF (Part I)
#line 5730 "test-new/nrimp10s-77.imp"
int tmp;
#line 5730 "test-new/nrimp10s-77.imp"
if (-131072 > (tmp = RPINF)) goto L_054B;
// Double-sided test on RPINF (Part II)
#line 5730 "test-new/nrimp10s-77.imp"
if (tmp > 131071) goto L_054B;
#line 5730 "test-new/nrimp10s-77.imp"
}
#line 5730 "test-new/nrimp10s-77.imp"
RPTYPE = 0;
#line 5730 "test-new/nrimp10s-77.imp"
L_054B:;
// 5731 P=P+2+BYTES(D)
#line 5731 "test-new/nrimp10s-77.imp"
P = P + 2 + BYTES[D];
// 5732 %FINISH; -> INS
#line 5732 "test-new/nrimp10s-77.imp"
L_0549:;
#line 5732 "test-new/nrimp10s-77.imp"
goto U_1035;
// 5733 OPERAND(3): ! SUB EXPRESSION
#line 5733 "test-new/nrimp10s-77.imp"
case_OPERAND_3:;
// 5734 PASSHEAD=0; PASSBOT=0
#line 5734 "test-new/nrimp10s-77.imp"
PASSHEAD = 0;
#line 5734 "test-new/nrimp10s-77.imp"
PASSBOT = 0;
// 5735 P=P+3
#line 5735 "test-new/nrimp10s-77.imp"
P = P + 3;
// 5736 TORP(PASSHEAD,PASSBOT,NOPS)
#line 5736 "test-new/nrimp10s-77.imp"
TORP(/*?*/ &PASSHEAD, /*?*/ &PASSBOT, NOPS);
// 5737 REAL=1 %IF TYPE=2
#line 5737 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_054C;
#line 5737 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5737 "test-new/nrimp10s-77.imp"
L_054C:;
// 5738 ! CONCAT(RPHEAD,PASSHEAD)
// 5739 %IF RPBOT=0 %THEN RPHEAD=PASSHEAD %ELSE ASLIST(RPBOT)_LINK=PASSHEAD
#line 5739 "test-new/nrimp10s-77.imp"
if (RPBOT != 0) goto L_054D;
#line 5739 "test-new/nrimp10s-77.imp"
RPHEAD = PASSHEAD;
#line 5739 "test-new/nrimp10s-77.imp"
goto L_054E;
#line 5739 "test-new/nrimp10s-77.imp"
L_054D:;
#line 5739 "test-new/nrimp10s-77.imp"
ASLIST[RPBOT].LINK = PASSHEAD;
#line 5739 "test-new/nrimp10s-77.imp"
L_054E:;
// 5740 RPBOT=PASSBOT
#line 5740 "test-new/nrimp10s-77.imp"
RPBOT = PASSBOT;
// 5741 P=P+1
#line 5741 "test-new/nrimp10s-77.imp"
P = P + 1;
// 5742 OP: ! DEAL WITH OPERATOR
#line 5742 "test-new/nrimp10s-77.imp"
U_1036:;
// 5743 -> EOE %IF A(P-1)=2; ! EXPR FINISHED
#line 5743 "test-new/nrimp10s-77.imp"
if (A[P - 1] != 2) goto L_054F;
#line 5743 "test-new/nrimp10s-77.imp"
goto U_1037;
#line 5743 "test-new/nrimp10s-77.imp"
L_054F:;
// 5744 OPERATOR=A(P)
#line 5744 "test-new/nrimp10s-77.imp"
OPERATOR = A[P];
// 5745 !
// 5746 ! THE STRING OPERATOR '.' CAUSES CHAOS IN AN ARITHMETIC EXPRSN
// 5747 ! SO FAULT IT AND CHANGE IT TO THE INNOCUOUS '+'
// 5748 !
// 5749 %IF OPERATOR=CONCOP %THEN FAULT2(78,0,0)
#line 5749 "test-new/nrimp10s-77.imp"
if (OPERATOR != 13) goto L_0550;
#line 5749 "test-new/nrimp10s-77.imp"
FAULT2(78, 0, 0);
#line 5749 "test-new/nrimp10s-77.imp"
L_0550:;
// 5750 OPPREC=PRECEDENCE(OPERATOR)
#line 5750 "test-new/nrimp10s-77.imp"
OPPREC = PRECEDENCE[OPERATOR - 1];
// 5751 OPERATOR=OPVAL(OPERATOR)
#line 5751 "test-new/nrimp10s-77.imp"
OPERATOR = OPVAL[OPERATOR - 1];
// 5752 %IF OPERATOR=26 %OR OPERATOR=30 %THEN REAL=1
#line 5752 "test-new/nrimp10s-77.imp"
if (OPERATOR == 26) goto L_0551;
#line 5752 "test-new/nrimp10s-77.imp"
if (OPERATOR != 30) goto L_0552;
#line 5752 "test-new/nrimp10s-77.imp"
L_0551:;
#line 5752 "test-new/nrimp10s-77.imp"
REAL = 1;
#line 5752 "test-new/nrimp10s-77.imp"
L_0552:;
// 5753 NOPS=NOPS+1
#line 5753 "test-new/nrimp10s-77.imp"
*NOPS = *NOPS + 1;
// 5754 !
// 5755 ! UNLOAD THE OPERATOR STACK OF ALL OPERATORS WHOSE PRECEDENCE IS
// 5756 ! NOT LOWER THAN THE CURRENT OPERATOR. AN EMPTY STACK GIVES'-1'
// 5757 ! AS PRECEDENCE.
// 5758 !
// 5759 %WHILE OPPREC<=OPPSTK&31 %CYCLE
#line 5759 "test-new/nrimp10s-77.imp"
L_0553:;
#line 5759 "test-new/nrimp10s-77.imp"
if (OPPREC > OPPSTK & 31) goto L_0554;
// 5760 BINSERT(RPHEAD,RPBOT,OPSTK&31+9,0,0)
#line 5760 "test-new/nrimp10s-77.imp"
BINSERT(/*?*/ &RPHEAD, /*?*/ &RPBOT, (OPSTK & 31) + 9, 0, 0);
// 5761 OPSTK=OPSTK>>5; OPPSTK=OPPSTK>>5
#line 5761 "test-new/nrimp10s-77.imp"
OPSTK = (unsigned int)OPSTK >> 5;
#line 5761 "test-new/nrimp10s-77.imp"
OPPSTK = (unsigned int)OPPSTK >> 5;
// 5762 %REPEAT
#line 5762 "test-new/nrimp10s-77.imp"
goto L_0553;
#line 5762 "test-new/nrimp10s-77.imp"
L_0554:;
// 5763 !
// 5764 ! THE CURRENT OPERATOR CAN NOW BE STORED
// 5765 !
// 5766 OPSTK=OPSTK<<5!(OPERATOR-9)
#line 5766 "test-new/nrimp10s-77.imp"
OPSTK = OPSTK << 5 | OPERATOR - 9;
// 5767 OPPSTK=OPPSTK<<5!OPPREC
#line 5767 "test-new/nrimp10s-77.imp"
OPPSTK = OPPSTK << 5 | OPPREC;
// 5768 %IF OPERATOR>=31 %THEN OPERATOR=30
#line 5768 "test-new/nrimp10s-77.imp"
if (OPERATOR < 31) goto L_0555;
#line 5768 "test-new/nrimp10s-77.imp"
OPERATOR = 30;
#line 5768 "test-new/nrimp10s-77.imp"
L_0555:;
// 5769 OPMASK=OPMASK!(1<<OPERATOR)
#line 5769 "test-new/nrimp10s-77.imp"
OPMASK = OPMASK | 1 << OPERATOR;
// 5770 -> NEXTOPND
#line 5770 "test-new/nrimp10s-77.imp"
goto U_1033;
// 5771 EOE: ! END OF EXPRESSION
#line 5771 "test-new/nrimp10s-77.imp"
U_1037:;
// 5772 ! EMPTY REMAINING OPERATORS
// 5773 %WHILE OPSTK#0 %CYCLE
#line 5773 "test-new/nrimp10s-77.imp"
L_0556:;
#line 5773 "test-new/nrimp10s-77.imp"
if (OPSTK == 0) goto L_0557;
// 5774 BINSERT(RPHEAD,RPBOT,OPSTK&31+9,0,0)
#line 5774 "test-new/nrimp10s-77.imp"
BINSERT(/*?*/ &RPHEAD, /*?*/ &RPBOT, (OPSTK & 31) + 9, 0, 0);
// 5775 OPSTK=OPSTK>>5
#line 5775 "test-new/nrimp10s-77.imp"
OPSTK = (unsigned int)OPSTK >> 5;
// 5776 %REPEAT
#line 5776 "test-new/nrimp10s-77.imp"
goto L_0556;
#line 5776 "test-new/nrimp10s-77.imp"
L_0557:;
// 5777 PTYPE=REAL+1
#line 5777 "test-new/nrimp10s-77.imp"
PTYPE = REAL + 1;
// 5778 TYPE=PTYPE
#line 5778 "test-new/nrimp10s-77.imp"
TYPE = PTYPE;
// 5779 ! CONCAT(RPHEAD,HEAD)
// 5780 %IF HEAD=0 %THEN BOT=RPBOT %ELSE ASLIST(RPBOT)_LINK=HEAD
#line 5780 "test-new/nrimp10s-77.imp"
if (*HEAD != 0) goto L_0558;
#line 5780 "test-new/nrimp10s-77.imp"
*BOT = RPBOT;
#line 5780 "test-new/nrimp10s-77.imp"
goto L_0559;
#line 5780 "test-new/nrimp10s-77.imp"
L_0558:;
#line 5780 "test-new/nrimp10s-77.imp"
ASLIST[RPBOT].LINK = *HEAD;
#line 5780 "test-new/nrimp10s-77.imp"
L_0559:;
// 5781 HEAD=RPHEAD; ! HEAD BACK TO TOP OF LIST
#line 5781 "test-new/nrimp10s-77.imp"
*HEAD = RPHEAD;
// 5782 NOPS=NOPS!OPMASK
#line 5782 "test-new/nrimp10s-77.imp"
*NOPS = *NOPS | OPMASK;
// 5783 %END
#line 5783 "test-new/nrimp10s-77.imp"
return;
#line 5783 "test-new/nrimp10s-77.imp"
case_OPERAND_dispatch:
#line 5783 "test-new/nrimp10s-77.imp"
if (OPERAND_index < 1 || OPERAND_index > 3)
_imp_signalf(6, 3, OPERAND_index, "->OPERAND(%d) out of bounds at %s line %d", OPERAND_index, OPERAND_file,
OPERAND_line);
#line 5783 "test-new/nrimp10s-77.imp"
goto *OPERAND[OPERAND_index - 1];
#line 5783 "test-new/nrimp10s-77.imp"
case_OPERAND_missing:
_imp_signalf(8, 2, OPERAND_index, "switch jump to undefined label OPERAND(%d): at %s line %d", OPERAND_index,
OPERAND_file, OPERAND_line);
#line 5783 "test-new/nrimp10s-77.imp"
} /* end of TORP */
// 5784 %ROUTINE EXPOP(%INTEGER INHEAD,REG,NOPS,MODE)
#line 5784 "test-new/nrimp10s-77.imp"
void EXPOP(int INHEAD, int REG, int NOPS, int MODE) {
#line 5784 "test-new/nrimp10s-77.imp"
auto void CTOP(int *FLAG);
#line 5784 "test-new/nrimp10s-77.imp"
auto void VMY(void);
#line 5784 "test-new/nrimp10s-77.imp"
auto void VMY1(void);
#line 5784 "test-new/nrimp10s-77.imp"
auto void CHOOSE(int *CHOICE);
#line 5784 "test-new/nrimp10s-77.imp"
auto void PUT(void);
#line 5784 "test-new/nrimp10s-77.imp"
auto void STARSTAR(void);
#line 5784 "test-new/nrimp10s-77.imp"
auto void REXP(void);
#line 5784 "test-new/nrimp10s-77.imp"
auto void LOAD(struct RD * OPND, int REG, int MODE);
#line 5784 "test-new/nrimp10s-77.imp"
auto void FLOAT(struct RD * OPND, int OTHERPTYPE);
#line 5784 "test-new/nrimp10s-77.imp"
auto void COERCET(struct RD * OPND1, struct RD * OPND2, int MODE);
#line 5784 "test-new/nrimp10s-77.imp"
auto void COERCEP(struct RD * OPND1, struct RD * OPND2);
#line 5784 "test-new/nrimp10s-77.imp"
auto void LENGTHEN(struct RD * OPND);
#line 5784 "test-new/nrimp10s-77.imp"
auto void SHORTEN(struct RD * OPND);
// 5785 !***********************************************************************
// 5786 !* EVALUATE A LIST OF OPERAND AND'NOPS' OPERATORS AND LEAVE *
// 5787 !* THE RESULT IN REG *
// 5788 !* INHEAD HOLDS THE LIST THE BOTTOM BYTE OF STREAM 1 DEFINES THE *
// 5789 !* ENTRY AS FOLLOWS:- *
// 5790 !* 0 = SHORT (INTEGER) CONSTANT <18 BITS --S2=CONSTANT *
// 5791 !* 1 = OTHER CONSTANT S2 (+S3 IF NEEDED) = CONSTANT *
// 5792 !* 2 = VARIABLE S2 POINT TO AR ENTRY FOR NAME&SUBSCRIPTS *
// 5793 !* (3 = DOPE VECTOR ITEM IF NEEDED) *
// 5794 !* (4 = CONDITONAL EXPRESSION AS IN ALGOL) *
// 5795 !* 7 = INTERMEDIATE RESULT UNDER LNB S2=DISPLCMNT FROM LNB *
// 5796 !* 8 = INTERMEDIATE RESULT STACKED *
// 5797 !* 9 = INTERMEDIATE RESULT IN A REGISTER S2 = REG *
// 5798 !* *
// 5799 !* 10-19 = UNARY OPERATOR S2=OP S3 =EXTRA *
// 5800 !* 20 UP = BINARY OPERATOR *
// 5801 !* *
// 5802 !* ARRAY MCINST HOLD THE OPCODES CORRESPONDING TO THE OPERATORS:- *
// 5803 !* TOP BYTE = REAL FORWARD FORM *
// 5804 !* 2ND BYTE = REAL REVERSE FORM *
// 5805 !* 3RD BYTE = INTEGER FORWARD FORM *
// 5806 !* BTM BYTE = INTEGER REVERSE FORM *
// 5807 !* MODE HAS TYPE & PREC REQD +256 BIT IF NO RESULT REQD *
// 5808 !***********************************************************************
// 5809 %ROUTINESPEC CTOP(%INTEGERNAME A)
// 5810 %ROUTINESPEC VMY
// 5811 %ROUTINESPEC VMY1
// 5812 %ROUTINESPEC CHOOSE(%INTEGERNAME I)
// 5813 %ROUTINESPEC PUT
// 5814 %ROUTINESPEC STARSTAR
// 5815 %ROUTINESPEC REXP
// 5816 %ROUTINESPEC LOAD(%RECORD(RD)%NAME OP,%INTEGER REG,MODE)
// 5817 %ROUTINESPEC FLOAT(%RECORD(RD)%NAME OPND,%INTEGER OTHERPTYPE)
// 5818 %ROUTINESPEC COERCET(%RECORD(RD)%NAME OP1,OP2,%INTEGER MODE)
// 5819 %ROUTINESPEC COERCEP(%RECORD(RD)%NAME OP1,OP2)
// 5820 %ROUTINESPEC LENGTHEN(%RECORD(RD)%NAME OP)
// 5821 %ROUTINESPEC SHORTEN (%RECORD(RD)%NAME OP)
// 5822 !
// 5823 %INTEGERARRAY OPERAND(1:2),STK(0:99)
#line 5823 "test-new/nrimp10s-77.imp"
int OPERAND[2];
#line 5823 "test-new/nrimp10s-77.imp"
int STK[100];
// 5824 %RECORD(LISTF)%NAME LIST{(LISTF)
#line 5824 "test-new/nrimp10s-77.imp"
struct LISTF *LIST;
// 5825 %RECORD(RD)%name OPND1,OPND2,OPND {(RD)
#line 5825 "test-new/nrimp10s-77.imp"
struct RD *OPND1;
#line 5825 "test-new/nrimp10s-77.imp"
struct RD *OPND2;
#line 5825 "test-new/nrimp10s-77.imp"
struct RD *OPND;
// 5826 !
// 5827 %INTEGER C,D,KK,JJ,OPCODE,COMM,XTRA,PP,PT,JJJ,LOADREG,EVALREG,STPTR,CONSTFORM,CONDFORM,SAVEP
#line 5827 "test-new/nrimp10s-77.imp"
int C;
#line 5827 "test-new/nrimp10s-77.imp"
int D;
#line 5827 "test-new/nrimp10s-77.imp"
int KK;
#line 5827 "test-new/nrimp10s-77.imp"
int JJ;
#line 5827 "test-new/nrimp10s-77.imp"
int OPCODE;
#line 5827 "test-new/nrimp10s-77.imp"
int COMM;
#line 5827 "test-new/nrimp10s-77.imp"
int XTRA;
#line 5827 "test-new/nrimp10s-77.imp"
int PP;
#line 5827 "test-new/nrimp10s-77.imp"
int PT;
#line 5827 "test-new/nrimp10s-77.imp"
int JJJ;
#line 5827 "test-new/nrimp10s-77.imp"
int LOADREG;
#line 5827 "test-new/nrimp10s-77.imp"
int EVALREG;
#line 5827 "test-new/nrimp10s-77.imp"
int STPTR;
#line 5827 "test-new/nrimp10s-77.imp"
int CONSTFORM;
#line 5827 "test-new/nrimp10s-77.imp"
int CONDFORM;
#line 5827 "test-new/nrimp10s-77.imp"
int SAVEP;
// 5828 %CONSTINTEGERARRAY MCINST(10:37)=16_8E8E,16_F4F4E4E4,16_A8A8,
#line 5828 "test-new/nrimp10s-77.imp"
const int MCINST[28] = {36494, -185277212, 43176, -185277212,
[4 ... 9] = 0, -252649248, -218832156, 36494,
35980, -84219158, 43692, -1162084352,
35466, [18 ... 19] = 51200, -100663296, -151591194,
16122086, 738208768, 33554944, [25 ... 26] = 1207977984,
59904};
// 5829+ 16_F4F4E4E4,0(6),
// 5830+ 16_F0F0E0E0,16_F2F4E2E4,
// 5831+ 16_8E8E,16_8C8C,16_FAFAEAEA,
// 5832+ 16_AAAC,16_BABC0000,
// 5833+ 16_8A8A,16_C800(2),16_FA000000,
// 5834+ 16_F6F6E6E6,16_00F600E6,
// 5835+ 16_2C002C00,16_02000200,
// 5836+ 16_48004800(2),16_EA00;
// 5837 %CONSTBYTEINTEGERARRAY CORULES(20:37)=16_1F(2),16_11(2),16_1F,16_11,
#line 5837 "test-new/nrimp10s-77.imp"
const unsigned char CORULES[18] = {[0 ... 1] = 31, [2 ... 3] = 17, 31, 17, 18, 17, 1, 1, 0,
[11 ... 12] = 31, [13 ... 16] = 0, 1};
// 5838+ 16_12,16_11,1,1,0,16_1F(2),
// 5839+ 0(4),1;
// 5840 %CONSTBYTEINTEGERARRAY FCOMP(1:28)={%C
#line 5840 "test-new/nrimp10s-77.imp"
const unsigned char FCOMP[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};
// 5841+ 8,10,2,7,12,4,7,
// 5842+ 8,12,4,7,10,2,7,
// 5843+ 16,34,17,32,33,18,32,
// 5844+ 16,33,18,32,34,17,32;
// 5845 %SWITCH SW(10:37)
#line 5845 "test-new/nrimp10s-77.imp"
int SW_index;
#line 5845 "test-new/nrimp10s-77.imp"
int SW_line;
#line 5845 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 5845 "test-new/nrimp10s-77.imp"
static const void *SW[28] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 5846 !
// 5847 STPTR=0; CONSTFORM= MODE&512
#line 5847 "test-new/nrimp10s-77.imp"
STPTR = 0;
#line 5847 "test-new/nrimp10s-77.imp"
CONSTFORM = MODE & 512;
// 5848 CONDFORM=MODE&256
#line 5848 "test-new/nrimp10s-77.imp"
CONDFORM = MODE & 256;
// 5849 SAVEP=P
#line 5849 "test-new/nrimp10s-77.imp"
SAVEP = P;
// 5850 EVALREG=ACCR; ! EVALUATE IN ACC UNLESS
#line 5850 "test-new/nrimp10s-77.imp"
EVALREG = 0;
// 5851 %IF REG=BREG %AND NOPS&16_7EC20000=0 %THEN EVALREG=BREG
#line 5851 "test-new/nrimp10s-77.imp"
if (REG != 7) goto L_055A;
#line 5851 "test-new/nrimp10s-77.imp"
if (NOPS & 2126643200 != 0) goto L_055A;
#line 5851 "test-new/nrimp10s-77.imp"
EVALREG = 7;
#line 5851 "test-new/nrimp10s-77.imp"
L_055A:;
// 5852 ! ONLY '+' %AND '*' PRESENT
// 5853 ! NOTHING >32 BITS
// 5854 NEXT: LIST==ASLIST(INHEAD)
#line 5854 "test-new/nrimp10s-77.imp"
U_101F:;
#line 5854 "test-new/nrimp10s-77.imp"
LIST = (struct LISTF *)/*?*/ &ASLIST[INHEAD];
// 5855 C=LIST_S1; XTRA=LIST_S2
#line 5855 "test-new/nrimp10s-77.imp"
C = LIST->S1;
#line 5855 "test-new/nrimp10s-77.imp"
XTRA = LIST->S2;
// 5856 JJ=C&255; D=INHEAD
#line 5856 "test-new/nrimp10s-77.imp"
JJ = C & 255;
#line 5856 "test-new/nrimp10s-77.imp"
D = INHEAD;
// 5857 INHEAD=LIST_LINK
#line 5857 "test-new/nrimp10s-77.imp"
INHEAD = LIST->LINK;
// 5858 -> OPERATOR %IF JJ>=10
#line 5858 "test-new/nrimp10s-77.imp"
if (JJ < 10) goto L_055B;
#line 5858 "test-new/nrimp10s-77.imp"
goto U_1039;
#line 5858 "test-new/nrimp10s-77.imp"
L_055B:;
// 5859 !
// 5860 ! ANY OPERAND WHICH MAY NEED DR OR B OR ACC IN THEIR EVALUATION
// 5861 ! EG FUNCTIONS,ARRAY ELEMENTS ETC ARE FETCHED AND STACKKED FIRST
// 5862 !
// 5863 OPERAND(1)=ADDR(ASLIST(D))
#line 5863 "test-new/nrimp10s-77.imp"
OPERAND[0] = _imp_ADDR(/*?*/ &ASLIST[D]);
// 5864 { OPND1==ASLIST(D) { <--- format mismatch!
// 5865 OPND1==RECORD(ADDR(ASLIST(D))) { force format.
#line 5865 "test-new/nrimp10s-77.imp"
OPND1 = (struct RD *)_imp_RECORD(_imp_ADDR(/*?*/ &ASLIST[D]));
// 5866 {
// 5867 { This looks weird!
// 5868 {
// 5869 { %RECORDFORMAT RD(%BYTEINTEGER UPTYPE,PTYPE,XB,FLAG,%C
// 5870 { %INTEGER D,XTRA)
// 5871 {
// 5872 { %RECORDFORMAT LISTF(%INTEGER S1,S2,S3,LINK)
// 5873 {
// 5874 { %RECORDARRAY ASLIST(0:ASL)(LISTF)
// 5875 {
// 5876 { %RECORDNAME OPND1,OPND2,OPND (RD)
// 5877 {
// 5878 %IF OPND1_FLAG=2 %AND OPND1_XB#0 %THEN LOAD(OPND1,EVALREG,0)
#line 5878 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 2) goto L_055C;
#line 5878 "test-new/nrimp10s-77.imp"
if (OPND1->XB == 0) goto L_055C;
#line 5878 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 0);
#line 5878 "test-new/nrimp10s-77.imp"
L_055C:;
// 5879 STK(STPTR)=OPERAND(1)
#line 5879 "test-new/nrimp10s-77.imp"
STK[STPTR] = OPERAND[0];
// 5880 STPTR=STPTR+1
#line 5880 "test-new/nrimp10s-77.imp"
STPTR = STPTR + 1;
// 5881 ABORT %IF STPTR>99
#line 5881 "test-new/nrimp10s-77.imp"
if (STPTR <= 99) goto L_055D;
#line 5881 "test-new/nrimp10s-77.imp"
ABORT();
#line 5881 "test-new/nrimp10s-77.imp"
L_055D:;
// 5882 ANYMORE:
#line 5882 "test-new/nrimp10s-77.imp"
U_103A:;
// 5883 ->NEXT %UNLESS INHEAD=0 %OR MODE=100
#line 5883 "test-new/nrimp10s-77.imp"
if (INHEAD == 0) goto L_055E;
#line 5883 "test-new/nrimp10s-77.imp"
if (MODE == 100) goto L_055E;
#line 5883 "test-new/nrimp10s-77.imp"
goto U_101F;
#line 5883 "test-new/nrimp10s-77.imp"
L_055E:;
// 5884 -> FINISH
#line 5884 "test-new/nrimp10s-77.imp"
goto U_103B;
// 5885 OPERATOR:
#line 5885 "test-new/nrimp10s-77.imp"
U_1039:;
// 5886 %IF JJ<19 %THEN KK=1 %ELSE KK=2; ! UNARY OR BINARY
#line 5886 "test-new/nrimp10s-77.imp"
if (JJ >= 19) goto L_055F;
#line 5886 "test-new/nrimp10s-77.imp"
KK = 1;
#line 5886 "test-new/nrimp10s-77.imp"
goto L_0560;
#line 5886 "test-new/nrimp10s-77.imp"
L_055F:;
#line 5886 "test-new/nrimp10s-77.imp"
KK = 2;
#line 5886 "test-new/nrimp10s-77.imp"
L_0560:;
// 5887 %CYCLE KK=KK,-1,1
#line 5887 "test-new/nrimp10s-77.imp"
// %for KK = KK, -1, 1 %cycle
#line 5887 "test-new/nrimp10s-77.imp"
{
int _control, _initial = KK, _increment = -1, _final = 1;
#line 5887 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle KK = KK, -1, 1");
_control = KK = _initial - _increment;
#line 5887 "test-new/nrimp10s-77.imp"
L_0561:
#line 5887 "test-new/nrimp10s-77.imp"
if (KK != _control) _imp_signal(4, 2, 0, "Corrupt control variable KK");
#line 5887 "test-new/nrimp10s-77.imp"
if (KK == _final) goto L_0562;
#line 5887 "test-new/nrimp10s-77.imp"
_control += _increment;
KK -= 1;
// 5888 STPTR=STPTR-1
#line 5888 "test-new/nrimp10s-77.imp"
STPTR = STPTR - 1;
// 5889 C=STK(STPTR)
#line 5889 "test-new/nrimp10s-77.imp"
C = STK[STPTR];
// 5890 OPERAND(KK)=C
#line 5890 "test-new/nrimp10s-77.imp"
OPERAND[KK - 1] = C;
// 5891 %REPEAT
#line 5891 "test-new/nrimp10s-77.imp"
goto L_0561;
#line 5891 "test-new/nrimp10s-77.imp"
}
#line 5891 "test-new/nrimp10s-77.imp"
L_0562:;
// 5892 OPCODE=MCINST(JJ)
#line 5892 "test-new/nrimp10s-77.imp"
OPCODE = MCINST[JJ - 10];
// 5893 COMM=1
#line 5893 "test-new/nrimp10s-77.imp"
COMM = 1;
// 5894 OPND1 == RECORD(OPERAND(1))
#line 5894 "test-new/nrimp10s-77.imp"
OPND1 = (struct RD *)_imp_RECORD(OPERAND[0]);
// 5895 OPND2 == OPND1
#line 5895 "test-new/nrimp10s-77.imp"
OPND2 = (struct RD *)OPND1;
// 5896 %IF JJ>=19 %THEN %START
#line 5896 "test-new/nrimp10s-77.imp"
if (JJ < 19) goto L_0564;
// 5897 OPND2==RECORD(OPERAND(2))
#line 5897 "test-new/nrimp10s-77.imp"
OPND2 = (struct RD *)_imp_RECORD(OPERAND[1]);
// 5898 C=CORULES(JJ)
#line 5898 "test-new/nrimp10s-77.imp"
C = CORULES[JJ - 20];
// 5899 %IF C&15#0 %THEN COERCET(OPND1,OPND2,C&15)
#line 5899 "test-new/nrimp10s-77.imp"
if (C & 15 == 0) goto L_0565;
#line 5899 "test-new/nrimp10s-77.imp"
COERCET(OPND1, OPND2, C & 15);
#line 5899 "test-new/nrimp10s-77.imp"
L_0565:;
// 5900 %IF C>>4#0 %THEN COERCEP(OPND1,OPND2)
#line 5900 "test-new/nrimp10s-77.imp"
if ((unsigned int)C >> 4 == 0) goto L_0566;
#line 5900 "test-new/nrimp10s-77.imp"
COERCEP(OPND1, OPND2);
#line 5900 "test-new/nrimp10s-77.imp"
L_0566:;
// 5901 %FINISH
#line 5901 "test-new/nrimp10s-77.imp"
L_0564:;
// 5902 %IF JJ>19 %START
#line 5902 "test-new/nrimp10s-77.imp"
if (JJ <= 19) goto L_0567;
// 5903 CHOOSE(COMM)
#line 5903 "test-new/nrimp10s-77.imp"
CHOOSE(/*?*/ &COMM);
// 5904 OPND1==RECORD(OPERAND(COMM))
#line 5904 "test-new/nrimp10s-77.imp"
OPND1 = (struct RD *)_imp_RECORD(OPERAND[COMM - 1]);
// 5905 OPND2==RECORD(OPERAND(3-COMM))
#line 5905 "test-new/nrimp10s-77.imp"
OPND2 = (struct RD *)_imp_RECORD(OPERAND[3 - COMM - 1]);
// 5906 %FINISH
#line 5906 "test-new/nrimp10s-77.imp"
L_0567:;
// 5907 PTYPE=OPND1_PTYPE; TYPE=PTYPE&7
#line 5907 "test-new/nrimp10s-77.imp"
PTYPE = OPND1->PTYPE;
#line 5907 "test-new/nrimp10s-77.imp"
TYPE = PTYPE & 7;
// 5908 %IF TYPE=1 %THEN OPCODE=OPCODE&16_FFFF %ELSE OPCODE=OPCODE>>16;! INTEGER OR REAL FORMS
#line 5908 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0568;
#line 5908 "test-new/nrimp10s-77.imp"
OPCODE = OPCODE & 65535;
#line 5908 "test-new/nrimp10s-77.imp"
goto L_0569;
#line 5908 "test-new/nrimp10s-77.imp"
L_0568:;
#line 5908 "test-new/nrimp10s-77.imp"
OPCODE = (unsigned int)OPCODE >> 16;
#line 5908 "test-new/nrimp10s-77.imp"
L_0569:;
// 5909 %IF 2#OPND1_FLAG<4 %AND 2#OPND2_FLAG<4 %THEN CTOP(JJ)
#line 5909 "test-new/nrimp10s-77.imp"
{
// Double-sided test on OPND1->FLAG (Part I)
#line 5909 "test-new/nrimp10s-77.imp"
int tmp;
#line 5909 "test-new/nrimp10s-77.imp"
if (2 == (tmp = OPND1->FLAG)) goto L_056A;
// Double-sided test on OPND1->FLAG (Part II)
#line 5909 "test-new/nrimp10s-77.imp"
if (tmp >= 4) goto L_056A;
#line 5909 "test-new/nrimp10s-77.imp"
}
#line 5909 "test-new/nrimp10s-77.imp"
{
// Double-sided test on OPND2->FLAG (Part I)
#line 5909 "test-new/nrimp10s-77.imp"
int tmp;
#line 5909 "test-new/nrimp10s-77.imp"
if (2 == (tmp = OPND2->FLAG)) goto L_056A;
// Double-sided test on OPND2->FLAG (Part II)
#line 5909 "test-new/nrimp10s-77.imp"
if (tmp >= 4) goto L_056A;
#line 5909 "test-new/nrimp10s-77.imp"
}
#line 5909 "test-new/nrimp10s-77.imp"
CTOP(/*?*/ &JJ);
#line 5909 "test-new/nrimp10s-77.imp"
L_056A:;
// 5910 -> STRES %IF JJ=0; ! CTOP CARRIED OUT
#line 5910 "test-new/nrimp10s-77.imp"
if (JJ != 0) goto L_056B;
#line 5910 "test-new/nrimp10s-77.imp"
goto U_103C;
#line 5910 "test-new/nrimp10s-77.imp"
L_056B:;
// 5911 -> SW(JJ)
#line 5911 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = JJ;
goto case_SW_dispatch;
// 5912 SW(10): ! \
#line 5912 "test-new/nrimp10s-77.imp"
case_SW_10:;
// 5913 LOAD(OPND1,EVALREG,2)
#line 5913 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 5914 FAULT(24,0) %UNLESS TYPE=1 %OR TYPE=7
#line 5914 "test-new/nrimp10s-77.imp"
if (TYPE == 1) goto L_056D;
#line 5914 "test-new/nrimp10s-77.imp"
if (TYPE == 7) goto L_056D;
#line 5914 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 5914 "test-new/nrimp10s-77.imp"
L_056D:;
// 5915 PSF1(OPCODE&255,0,-1); ! NEQ -1
#line 5915 "test-new/nrimp10s-77.imp"
PSF1(OPCODE & 255, 0, -1);
// 5916 GRUSE(EVALREG)=0
#line 5916 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 0;
// 5917 SUSE: OLINK(EVALREG)=OPERAND(COMM)
#line 5917 "test-new/nrimp10s-77.imp"
U_103D:;
#line 5917 "test-new/nrimp10s-77.imp"
OLINK[EVALREG] = OPERAND[COMM - 1];
// 5918 STRES: STK(STPTR)=OPERAND(COMM)
#line 5918 "test-new/nrimp10s-77.imp"
U_103C:;
#line 5918 "test-new/nrimp10s-77.imp"
STK[STPTR] = OPERAND[COMM - 1];
// 5919 STPTR=STPTR+1
#line 5919 "test-new/nrimp10s-77.imp"
STPTR = STPTR + 1;
// 5920 ->ANYMORE
#line 5920 "test-new/nrimp10s-77.imp"
goto U_103A;
// 5921 SW(11): ! NEGATE
#line 5921 "test-new/nrimp10s-77.imp"
case_SW_11:;
// 5922 LOAD(OPND1,EVALREG,2)
#line 5922 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 5923 %IF EVALREG=BREG %THEN PSF1(SLB,0,0) %AND PF1(SBB,0,TOS,0) %ELSE PSF1(OPCODE&255,0,0); ! IRSB 0 OR RRSB 0
#line 5923 "test-new/nrimp10s-77.imp"
if (EVALREG != 7) goto L_056E;
#line 5923 "test-new/nrimp10s-77.imp"
PSF1(82, 0, 0);
#line 5923 "test-new/nrimp10s-77.imp"
PF1(34, 0, 6, 0);
#line 5923 "test-new/nrimp10s-77.imp"
goto L_056F;
#line 5923 "test-new/nrimp10s-77.imp"
L_056E:;
#line 5923 "test-new/nrimp10s-77.imp"
PSF1(OPCODE & 255, 0, 0);
#line 5923 "test-new/nrimp10s-77.imp"
L_056F:;
// 5924 GRUSE(EVALREG)=0
#line 5924 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 0;
// 5925 -> SUSE
#line 5925 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5926 SW(12): ! FLOAT
#line 5926 "test-new/nrimp10s-77.imp"
case_SW_12:;
// 5927 ABORT
#line 5927 "test-new/nrimp10s-77.imp"
ABORT();
// 5928 SW(13): ! ABS
#line 5928 "test-new/nrimp10s-77.imp"
case_SW_13:;
// 5929 LOAD(OPND1,EVALREG,2); ! OPERAND TO ACC
#line 5929 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 5930 %IF TYPE=2 %THEN C=2 %ELSE C=6
#line 5930 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_0570;
#line 5930 "test-new/nrimp10s-77.imp"
C = 2;
#line 5930 "test-new/nrimp10s-77.imp"
goto L_0571;
#line 5930 "test-new/nrimp10s-77.imp"
L_0570:;
#line 5930 "test-new/nrimp10s-77.imp"
C = 6;
#line 5930 "test-new/nrimp10s-77.imp"
L_0571:;
// 5931 PF3(JAF,C,0,3); ! JAF *+3 ON ACC<0
#line 5931 "test-new/nrimp10s-77.imp"
PF3(6, C, 0, 3);
// 5932 PSF1(OPCODE&255,0,0); ! IRSB 0 OR RRSB 0
#line 5932 "test-new/nrimp10s-77.imp"
PSF1(OPCODE & 255, 0, 0);
// 5933 GRUSE(EVALREG)=0
#line 5933 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 0;
// 5934 ->SUSE
#line 5934 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5935 SW(14): ! STRETCH
#line 5935 "test-new/nrimp10s-77.imp"
case_SW_14:;
// 5936 ABORT
#line 5936 "test-new/nrimp10s-77.imp"
ABORT();
// 5937 SW(20): ! ADD
#line 5937 "test-new/nrimp10s-77.imp"
case_SW_20:;
// 5938 %IF TYPE=1 %AND GRUSE(EVALREG)=10 %AND OPND1_FLAG=2 %AND OPND2_FLAG=0 %AND REGISTER(EVALREG)=0 %START
#line 5938 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0572;
#line 5938 "test-new/nrimp10s-77.imp"
if (GRUSE[EVALREG] != 10) goto L_0572;
#line 5938 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 2) goto L_0572;
#line 5938 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG != 0) goto L_0572;
#line 5938 "test-new/nrimp10s-77.imp"
if (REGISTER[EVALREG] != 0) goto L_0572;
// 5939 P=OPND1_D; D=GRINF1(EVALREG)
#line 5939 "test-new/nrimp10s-77.imp"
P = OPND1->D;
#line 5939 "test-new/nrimp10s-77.imp"
D = GRINF1[EVALREG];
// 5940 %IF FROMAR2(P)=D&16_FFFF %AND A(P+2)=2=A(P+3) %START
#line 5940 "test-new/nrimp10s-77.imp"
if (FROMAR2(P) != D & 65535) goto L_0573;
#line 5940 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 2 (Part I)
#line 5940 "test-new/nrimp10s-77.imp"
int tmp;
#line 5940 "test-new/nrimp10s-77.imp"
if (A[P + 2] != (tmp = 2)) goto L_0573;
// Double-sided test on 2 (Part II)
#line 5940 "test-new/nrimp10s-77.imp"
if (tmp != A[P + 3]) goto L_0573;
#line 5940 "test-new/nrimp10s-77.imp"
}
// 5941 %IF EVALREG=ACCR %THEN C=IAD %ELSE C=ADB
#line 5941 "test-new/nrimp10s-77.imp"
if (EVALREG != 0) goto L_0574;
#line 5941 "test-new/nrimp10s-77.imp"
C = 224;
#line 5941 "test-new/nrimp10s-77.imp"
goto L_0575;
#line 5941 "test-new/nrimp10s-77.imp"
L_0574:;
#line 5941 "test-new/nrimp10s-77.imp"
C = 32;
#line 5941 "test-new/nrimp10s-77.imp"
L_0575:;
// 5942 PSF1(C,0,OPND2_D-D>>16)
#line 5942 "test-new/nrimp10s-77.imp"
PSF1(C, 0, OPND2->D - ((unsigned int)D >> 16));
// 5943 GRINF1(EVALREG)=D&16_FFFF!OPND2_D<<16
#line 5943 "test-new/nrimp10s-77.imp"
GRINF1[EVALREG] = D & 65535 | OPND2->D << 16;
// 5944 REGISTER(EVALREG)=1
#line 5944 "test-new/nrimp10s-77.imp"
REGISTER[EVALREG] = 1;
// 5945 OPND1_FLAG=9; OPND1_XB=EVALREG<<4
#line 5945 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 9;
#line 5945 "test-new/nrimp10s-77.imp"
OPND1->XB = EVALREG << 4;
// 5946 OPND1_D=0; ->SUSE
#line 5946 "test-new/nrimp10s-77.imp"
OPND1->D = 0;
#line 5946 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5947 %FINISH
#line 5947 "test-new/nrimp10s-77.imp"
L_0573:;
// 5948 %FINISH
#line 5948 "test-new/nrimp10s-77.imp"
L_0572:;
// 5949 BINOP: LOAD(OPND1,EVALREG,2);
#line 5949 "test-new/nrimp10s-77.imp"
U_103E:;
#line 5949 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 5950 LOAD(OPND2,EVALREG,1)
#line 5950 "test-new/nrimp10s-77.imp"
LOAD(OPND2, EVALREG, 1);
// 5951 PUT; -> SUSE
#line 5951 "test-new/nrimp10s-77.imp"
PUT();
#line 5951 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5952 SW(21): ! SUBTRACT
#line 5952 "test-new/nrimp10s-77.imp"
case_SW_21:;
// 5953 ->BINOP
#line 5953 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5954 SW(22): ! EXCLUSIVE OR
#line 5954 "test-new/nrimp10s-77.imp"
case_SW_22:;
// 5955 SW(23): ! OR
#line 5955 "test-new/nrimp10s-77.imp"
case_SW_23:;
// 5956 SW(27): ! AND
#line 5956 "test-new/nrimp10s-77.imp"
case_SW_27:;
// 5957 ->BINOP %IF TYPE=1
#line 5957 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0576;
#line 5957 "test-new/nrimp10s-77.imp"
goto U_103E;
#line 5957 "test-new/nrimp10s-77.imp"
L_0576:;
// 5958 F24: FAULT(24,0) %UNLESS TYPE=7
#line 5958 "test-new/nrimp10s-77.imp"
U_103F:;
#line 5958 "test-new/nrimp10s-77.imp"
if (TYPE == 7) goto L_0577;
#line 5958 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 5958 "test-new/nrimp10s-77.imp"
L_0577:;
// 5959 JJ=20; OPCODE=MCINST(20)
#line 5959 "test-new/nrimp10s-77.imp"
JJ = 20;
#line 5959 "test-new/nrimp10s-77.imp"
OPCODE = MCINST[10];
// 5960 ->BINOP; ! CHANGE OPN TO +
#line 5960 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5961 SW(28): ! SRL
#line 5961 "test-new/nrimp10s-77.imp"
case_SW_28:;
// 5962 %IF OPND2_FLAG=0 %THEN OPND2_D=-OPND2_D %ELSE %START
#line 5962 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG != 0) goto L_0578;
#line 5962 "test-new/nrimp10s-77.imp"
OPND2->D = -OPND2->D;
#line 5962 "test-new/nrimp10s-77.imp"
goto L_0579;
#line 5962 "test-new/nrimp10s-77.imp"
L_0578:;
// 5963 LOAD(OPND2,EVALREG,2); ! OPND TO ACC
#line 5963 "test-new/nrimp10s-77.imp"
LOAD(OPND2, EVALREG, 2);
// 5964 PSF1(IRSB,0,0); ! AND NEGATE IT
#line 5964 "test-new/nrimp10s-77.imp"
PSF1(228, 0, 0);
// 5965 GRUSE(EVALREG)=0
#line 5965 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 0;
// 5966 %FINISH
#line 5966 "test-new/nrimp10s-77.imp"
L_0579:;
// 5967 SW(29): ! SLL
#line 5967 "test-new/nrimp10s-77.imp"
case_SW_29:;
// 5968 %IF OPND2_PTYPE>>4=6 %THEN SHORTEN(OPND2);! LONINT TO INT
#line 5968 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND2->PTYPE >> 4 != 6) goto L_057A;
#line 5968 "test-new/nrimp10s-77.imp"
SHORTEN(OPND2);
#line 5968 "test-new/nrimp10s-77.imp"
L_057A:;
// 5969 -> BINOP
#line 5969 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5970 SW(24): ! MULT
#line 5970 "test-new/nrimp10s-77.imp"
case_SW_24:;
// 5971 -> BINOP
#line 5971 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5972 SW(25): ! INTEGER DIVISION
#line 5972 "test-new/nrimp10s-77.imp"
case_SW_25:;
// 5973 ->F24 %UNLESS TYPE=1
#line 5973 "test-new/nrimp10s-77.imp"
if (TYPE == 1) goto L_057B;
#line 5973 "test-new/nrimp10s-77.imp"
goto U_103F;
#line 5973 "test-new/nrimp10s-77.imp"
L_057B:;
// 5974 -> BINOP
#line 5974 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5975 SW(26): ! NORMAL DIVISION
#line 5975 "test-new/nrimp10s-77.imp"
case_SW_26:;
// 5976 -> BINOP
#line 5976 "test-new/nrimp10s-77.imp"
goto U_103E;
// 5977 SW(30): ! EXP IN REAL EXPRSN
#line 5977 "test-new/nrimp10s-77.imp"
case_SW_30:;
// 5978 %IF OPND1_PTYPE&7=1 %THEN FLOAT(OPND1,0)
#line 5978 "test-new/nrimp10s-77.imp"
if (OPND1->PTYPE & 7 != 1) goto L_057C;
#line 5978 "test-new/nrimp10s-77.imp"
FLOAT(OPND1, 0);
#line 5978 "test-new/nrimp10s-77.imp"
L_057C:;
// 5979 %IF OPND2_PTYPE&7=1 %THEN STARSTAR %AND ->SUSE
#line 5979 "test-new/nrimp10s-77.imp"
if (OPND2->PTYPE & 7 != 1) goto L_057D;
#line 5979 "test-new/nrimp10s-77.imp"
STARSTAR();
#line 5979 "test-new/nrimp10s-77.imp"
goto U_103D;
#line 5979 "test-new/nrimp10s-77.imp"
L_057D:;
// 5980 ! REAL**REAL BY SUBROUTINE
// 5981 REXP; COMM=2; ->SUSE
#line 5981 "test-new/nrimp10s-77.imp"
REXP();
#line 5981 "test-new/nrimp10s-77.imp"
COMM = 2;
#line 5981 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5982 SW(37): ! EXP IN INTEGER CONTEXT
#line 5982 "test-new/nrimp10s-77.imp"
case_SW_37:;
// 5983 STARSTAR; -> SUSE
#line 5983 "test-new/nrimp10s-77.imp"
STARSTAR();
#line 5983 "test-new/nrimp10s-77.imp"
goto U_103D;
// 5984 SW(31): ! COMPARISONS
#line 5984 "test-new/nrimp10s-77.imp"
case_SW_31:;
// 5985 SW(32): ! DSIDED COMPARISONS
#line 5985 "test-new/nrimp10s-77.imp"
case_SW_32:;
// 5986 PTYPE=OPND1_PTYPE
#line 5986 "test-new/nrimp10s-77.imp"
PTYPE = OPND1->PTYPE;
// 5987 ->Z1 %IF OPND1_FLAG<=1 %AND OPND1_D=0 %AND JJ=31 %AND (OPND1_XTRA=0 %OR PTYPE>>4=5);! INT 0 OR LONGINT 0
#line 5987 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG > 1) goto L_057E;
#line 5987 "test-new/nrimp10s-77.imp"
if (OPND1->D != 0) goto L_057E;
#line 5987 "test-new/nrimp10s-77.imp"
if (JJ != 31) goto L_057E;
#line 5987 "test-new/nrimp10s-77.imp"
if (OPND1->XTRA == 0) goto L_0563;
#line 5987 "test-new/nrimp10s-77.imp"
if ((unsigned int)PTYPE >> 4 != 5) goto L_057E;
#line 5987 "test-new/nrimp10s-77.imp"
L_0563:;
#line 5987 "test-new/nrimp10s-77.imp"
goto U_1040;
#line 5987 "test-new/nrimp10s-77.imp"
L_057E:;
// 5988 -> Z2 %IF OPND2_FLAG<=1 %AND OPND2_D=0 %AND (OPND2_XTRA=0 %OR OPND2_PTYPE>>4=5)
#line 5988 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG > 1) goto L_057F;
#line 5988 "test-new/nrimp10s-77.imp"
if (OPND2->D != 0) goto L_057F;
#line 5988 "test-new/nrimp10s-77.imp"
if (OPND2->XTRA == 0) goto L_0580;
#line 5988 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND2->PTYPE >> 4 != 5) goto L_057F;
#line 5988 "test-new/nrimp10s-77.imp"
L_0580:;
#line 5988 "test-new/nrimp10s-77.imp"
goto U_1041;
#line 5988 "test-new/nrimp10s-77.imp"
L_057F:;
// 5989 LOAD(OPND1,EVALREG,2)
#line 5989 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 5990 LOAD(OPND2,EVALREG,1)
#line 5990 "test-new/nrimp10s-77.imp"
LOAD(OPND2, EVALREG, 1);
// 5991 PUT
#line 5991 "test-new/nrimp10s-77.imp"
PUT();
// 5992 REGISTER(EVALREG)=0
#line 5992 "test-new/nrimp10s-77.imp"
REGISTER[EVALREG] = 0;
// 5993 BFFLAG=COMM-1; ! NOTE BACKWARDS OR FORWARDS
#line 5993 "test-new/nrimp10s-77.imp"
BFFLAG = COMM - 1;
// 5994 MASK=FCOMP(XTRA+7*BFFLAG)
#line 5994 "test-new/nrimp10s-77.imp"
MASK = FCOMP[XTRA + 7 * BFFLAG - 1];
// 5995 COMM=2; ->STRES; ! 2ND OPERAND MAY BE NEEDED IN
#line 5995 "test-new/nrimp10s-77.imp"
COMM = 2;
#line 5995 "test-new/nrimp10s-77.imp"
goto U_103C;
// 5996 ! DOUBLE SIDED AND IS THEREFORE
// 5997 ! TAKEN AS THE 'RESULT'
// 5998 Z1: COMM=3-COMM
#line 5998 "test-new/nrimp10s-77.imp"
U_1040:;
#line 5998 "test-new/nrimp10s-77.imp"
COMM = 3 - COMM;
// 5999 Z2: OPND==RECORD(OPERAND(COMM))
#line 5999 "test-new/nrimp10s-77.imp"
U_1041:;
#line 5999 "test-new/nrimp10s-77.imp"
OPND = (struct RD *)_imp_RECORD(OPERAND[COMM - 1]);
// 6000 C=EVALREG; D=EVALREG!!7
#line 6000 "test-new/nrimp10s-77.imp"
C = EVALREG;
#line 6000 "test-new/nrimp10s-77.imp"
D = EVALREG ^ 7;
// 6001 %IF OPND_FLAG=2 %AND GRUSE(D)=9 %AND (GRINF1(D)&16_FFFF=OPND_XTRA %OR GRINF1(D)>>16=OPND_XTRA) %THEN C=D
#line 6001 "test-new/nrimp10s-77.imp"
if (OPND->FLAG != 2) goto L_0581;
#line 6001 "test-new/nrimp10s-77.imp"
if (GRUSE[D] != 9) goto L_0581;
#line 6001 "test-new/nrimp10s-77.imp"
if (GRINF1[D] & 65535 == OPND->XTRA) goto L_0582;
#line 6001 "test-new/nrimp10s-77.imp"
if ((unsigned int)GRINF1[D] >> 16 != OPND->XTRA) goto L_0581;
#line 6001 "test-new/nrimp10s-77.imp"
L_0582:;
#line 6001 "test-new/nrimp10s-77.imp"
C = D;
#line 6001 "test-new/nrimp10s-77.imp"
L_0581:;
// 6002 LOAD(OPND,C,2)
#line 6002 "test-new/nrimp10s-77.imp"
LOAD(OPND, C, 2);
// 6003 REGISTER(C)=0
#line 6003 "test-new/nrimp10s-77.imp"
REGISTER[C] = 0;
// 6004 MASK=FCOMP(XTRA+7*COMM+7)
#line 6004 "test-new/nrimp10s-77.imp"
MASK = FCOMP[XTRA + 7 * COMM + 7 - 1];
// 6005 %IF TYPE=1 %THEN MASK=MASK+4
#line 6005 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0583;
#line 6005 "test-new/nrimp10s-77.imp"
MASK = MASK + 4;
#line 6005 "test-new/nrimp10s-77.imp"
L_0583:;
// 6006 %IF C=BREG %THEN MASK=MASK+8
#line 6006 "test-new/nrimp10s-77.imp"
if (C != 7) goto L_0584;
#line 6006 "test-new/nrimp10s-77.imp"
MASK = MASK + 8;
#line 6006 "test-new/nrimp10s-77.imp"
L_0584:;
// 6007 COMM=2; ->STRES
#line 6007 "test-new/nrimp10s-77.imp"
COMM = 2;
#line 6007 "test-new/nrimp10s-77.imp"
goto U_103C;
// 6008 SW(33): ! SPECIAL MH FOR ARRAY ACCESS
#line 6008 "test-new/nrimp10s-77.imp"
case_SW_33:;
// 6009 C=OPND2_D>>24; ! CURRENT DIMENSION
#line 6009 "test-new/nrimp10s-77.imp"
C = (unsigned int)OPND2->D >> 24;
// 6010 D=OPND2_D>>16&31; ! TOTAL NO OF DIMENSIONS
#line 6010 "test-new/nrimp10s-77.imp"
D = (unsigned int)OPND2->D >> 16 & 31;
// 6011 %IF D=1 %THEN VMY1 %ELSE VMY
#line 6011 "test-new/nrimp10s-77.imp"
if (D != 1) goto L_0585;
#line 6011 "test-new/nrimp10s-77.imp"
VMY1();
#line 6011 "test-new/nrimp10s-77.imp"
goto L_0586;
#line 6011 "test-new/nrimp10s-77.imp"
L_0585:;
#line 6011 "test-new/nrimp10s-77.imp"
VMY();
#line 6011 "test-new/nrimp10s-77.imp"
L_0586:;
// 6012 %IF OPND1_FLAG>1 %THEN OLINK(LOADREG)=OPERAND(COMM);! IF RESULT THEN PROTECT IT
#line 6012 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG <= 1) goto L_0587;
#line 6012 "test-new/nrimp10s-77.imp"
OLINK[LOADREG] = OPERAND[COMM - 1];
#line 6012 "test-new/nrimp10s-77.imp"
L_0587:;
// 6013 %IF C=1 %THEN ->STRES
#line 6013 "test-new/nrimp10s-77.imp"
if (C != 1) goto L_0588;
#line 6013 "test-new/nrimp10s-77.imp"
goto U_103C;
#line 6013 "test-new/nrimp10s-77.imp"
L_0588:;
// 6014 ->ANYMORE
#line 6014 "test-new/nrimp10s-77.imp"
goto U_103A;
// 6015 SW(34): ! ->LAB MASKS AND LAB AS OPND2
#line 6015 "test-new/nrimp10s-77.imp"
case_SW_34:;
// 6016 ! OPND1 MIDDLE OF D-SIDED
// 6017 ABORT
#line 6017 "test-new/nrimp10s-77.imp"
ABORT();
// 6018 SW(35): ! ASSIGN(=)
#line 6018 "test-new/nrimp10s-77.imp"
case_SW_35:;
// 6019 SW(36): ! ASSIGN(<-)
#line 6019 "test-new/nrimp10s-77.imp"
case_SW_36:;
// 6020 PT=OPND2_PTYPE; PP=OPND2_D
#line 6020 "test-new/nrimp10s-77.imp"
PT = OPND2->PTYPE;
#line 6020 "test-new/nrimp10s-77.imp"
PP = OPND2->D;
// 6021 %IF PT&7=1 %AND OPND1_PTYPE&7=2 %THEN FAULT(24,0)
#line 6021 "test-new/nrimp10s-77.imp"
if (PT & 7 != 1) goto L_0589;
#line 6021 "test-new/nrimp10s-77.imp"
if (OPND1->PTYPE & 7 != 2) goto L_0589;
#line 6021 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 6021 "test-new/nrimp10s-77.imp"
L_0589:;
// 6022 %IF PT&7=2 %AND OPND1_PTYPE&7=1 %THEN FLOAT(OPND1,OPND2_PTYPE)
#line 6022 "test-new/nrimp10s-77.imp"
if (PT & 7 != 2) goto L_058A;
#line 6022 "test-new/nrimp10s-77.imp"
if (OPND1->PTYPE & 7 != 1) goto L_058A;
#line 6022 "test-new/nrimp10s-77.imp"
FLOAT(OPND1, OPND2->PTYPE);
#line 6022 "test-new/nrimp10s-77.imp"
L_058A:;
// 6023 LOAD(OPND1,EVALREG,2); ! RHS TO ACC
#line 6023 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 6024 REGISTER(EVALREG)=2
#line 6024 "test-new/nrimp10s-77.imp"
REGISTER[EVALREG] = 2;
// 6025 C=PT>>4; D=OPND1_PTYPE>>4
#line 6025 "test-new/nrimp10s-77.imp"
C = (unsigned int)PT >> 4;
#line 6025 "test-new/nrimp10s-77.imp"
D = (unsigned int)OPND1->PTYPE >> 4;
// 6026 %IF C<5 %THEN C=5
#line 6026 "test-new/nrimp10s-77.imp"
if (C >= 5) goto L_058B;
#line 6026 "test-new/nrimp10s-77.imp"
C = 5;
#line 6026 "test-new/nrimp10s-77.imp"
L_058B:;
// 6027 %IF D<5 %THEN D=5
#line 6027 "test-new/nrimp10s-77.imp"
if (D >= 5) goto L_058C;
#line 6027 "test-new/nrimp10s-77.imp"
D = 5;
#line 6027 "test-new/nrimp10s-77.imp"
L_058C:;
// 6028 LENGTHEN(OPND1) %AND D=OPND1_PTYPE>>4 %WHILE D<C
#line 6028 "test-new/nrimp10s-77.imp"
L_058D:;
#line 6028 "test-new/nrimp10s-77.imp"
if (D >= C) goto L_058E;
#line 6028 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND1);
#line 6028 "test-new/nrimp10s-77.imp"
D = (unsigned int)OPND1->PTYPE >> 4;
#line 6028 "test-new/nrimp10s-77.imp"
goto L_058D;
#line 6028 "test-new/nrimp10s-77.imp"
L_058E:;
// 6029 %WHILE (C<D %AND TYPE=1 %AND JJ#36) %OR C<D-1 %CYCLE
#line 6029 "test-new/nrimp10s-77.imp"
L_058F:;
#line 6029 "test-new/nrimp10s-77.imp"
if (C >= D) goto L_0590;
#line 6029 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0590;
#line 6029 "test-new/nrimp10s-77.imp"
if (JJ != 36) goto L_0591;
#line 6029 "test-new/nrimp10s-77.imp"
L_0590:;
#line 6029 "test-new/nrimp10s-77.imp"
if (C >= D - 1) goto L_0592;
#line 6029 "test-new/nrimp10s-77.imp"
L_0591:;
// 6030 SHORTEN(OPND1)
#line 6030 "test-new/nrimp10s-77.imp"
SHORTEN(OPND1);
// 6031 D=OPND1_PTYPE>>4
#line 6031 "test-new/nrimp10s-77.imp"
D = (unsigned int)OPND1->PTYPE >> 4;
// 6032 %REPEAT
#line 6032 "test-new/nrimp10s-77.imp"
goto L_058F;
#line 6032 "test-new/nrimp10s-77.imp"
L_0592:;
// 6033 P=PP; CNAME(1,0); ! STORE CALL
#line 6033 "test-new/nrimp10s-77.imp"
P = PP;
#line 6033 "test-new/nrimp10s-77.imp"
CNAME(1, 0);
// 6034 D=DISP; C=ACCESS; JJJ=AREA; ! SAVE INFO FOR STORE
#line 6034 "test-new/nrimp10s-77.imp"
D = DISP;
#line 6034 "test-new/nrimp10s-77.imp"
C = ACCESS;
#line 6034 "test-new/nrimp10s-77.imp"
JJJ = AREA;
// 6035 KK=PREC
#line 6035 "test-new/nrimp10s-77.imp"
KK = PREC;
// 6036 LOAD(OPND1,EVALREG,2); ! IN CASE STACKED
#line 6036 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 2);
// 6037 %IF JJ=36 %AND TYPE=1 %START
#line 6037 "test-new/nrimp10s-77.imp"
if (JJ != 36) goto L_0593;
#line 6037 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_0593;
// 6038 %IF 3<=XTRA<=4 %THEN PF1(AND,0,0,(-1)>>(8*(6-XTRA))) %AND GRUSE(ACCR)=0
#line 6038 "test-new/nrimp10s-77.imp"
{
// Double-sided test on XTRA (Part I)
#line 6038 "test-new/nrimp10s-77.imp"
int tmp;
#line 6038 "test-new/nrimp10s-77.imp"
if (3 > (tmp = XTRA)) goto L_0594;
// Double-sided test on XTRA (Part II)
#line 6038 "test-new/nrimp10s-77.imp"
if (tmp > 4) goto L_0594;
#line 6038 "test-new/nrimp10s-77.imp"
}
#line 6038 "test-new/nrimp10s-77.imp"
PF1(138, 0, 0, (unsigned int)-1 >> 8 * (6 - XTRA));
#line 6038 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
#line 6038 "test-new/nrimp10s-77.imp"
L_0594:;
// 6039 %IF KK<=5 %AND PREC=6 %THEN PSF1(MPSR,0,17) %AND GRUSE(ACCR)=0
#line 6039 "test-new/nrimp10s-77.imp"
if (KK > 5) goto L_0595;
#line 6039 "test-new/nrimp10s-77.imp"
if (PREC != 6) goto L_0595;
#line 6039 "test-new/nrimp10s-77.imp"
PSF1(50, 0, 17);
#line 6039 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
#line 6039 "test-new/nrimp10s-77.imp"
L_0595:;
// 6040 %FINISH
#line 6040 "test-new/nrimp10s-77.imp"
L_0593:;
// 6041 %IF TYPE=2 %AND KK<PREC %THEN KK=STUH %ELSE KK=ST
#line 6041 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_0596;
#line 6041 "test-new/nrimp10s-77.imp"
if (KK >= PREC) goto L_0596;
#line 6041 "test-new/nrimp10s-77.imp"
KK = 74;
#line 6041 "test-new/nrimp10s-77.imp"
goto L_0597;
#line 6041 "test-new/nrimp10s-77.imp"
L_0596:;
#line 6041 "test-new/nrimp10s-77.imp"
KK = 72;
#line 6041 "test-new/nrimp10s-77.imp"
L_0597:;
// 6042 %IF EVALREG=BREG %THEN KK=STB
#line 6042 "test-new/nrimp10s-77.imp"
if (EVALREG != 7) goto L_0598;
#line 6042 "test-new/nrimp10s-77.imp"
KK = 90;
#line 6042 "test-new/nrimp10s-77.imp"
L_0598:;
// 6043 PSORLF1(KK,C,JJJ,D)
#line 6043 "test-new/nrimp10s-77.imp"
PSORLF1(KK, C, JJJ, D);
// 6044 %IF (C&1=0 %AND STNAME>0) %OR (C=3 %AND STNAME>>16>0) %THEN NOTE ASSMENT(EVALREG,JJ-33,STNAME)
#line 6044 "test-new/nrimp10s-77.imp"
if (C & 1 != 0) goto L_0599;
#line 6044 "test-new/nrimp10s-77.imp"
if (STNAME > 0) goto L_059A;
#line 6044 "test-new/nrimp10s-77.imp"
L_0599:;
#line 6044 "test-new/nrimp10s-77.imp"
if (C != 3) goto L_059B;
#line 6044 "test-new/nrimp10s-77.imp"
if ((unsigned int)STNAME >> 16 <= 0) goto L_059B;
#line 6044 "test-new/nrimp10s-77.imp"
L_059A:;
#line 6044 "test-new/nrimp10s-77.imp"
NOTEASSMENT(EVALREG, JJ - 33, STNAME);
#line 6044 "test-new/nrimp10s-77.imp"
L_059B:;
// 6045 %IF C>=2 %AND JJJ#7 %START; ! DR WILL BE LOADED SY STORE
#line 6045 "test-new/nrimp10s-77.imp"
if (C < 2) goto L_059C;
#line 6045 "test-new/nrimp10s-77.imp"
if (JJJ == 7) goto L_059C;
// 6046 %IF STNAME>0 %THEN GRUSE(DR)=7 %AND GRINF1(DR)=STNAME&16_FFFF %ELSE GRUSE(DR)=0
#line 6046 "test-new/nrimp10s-77.imp"
if (STNAME <= 0) goto L_059D;
#line 6046 "test-new/nrimp10s-77.imp"
GRUSE[1] = 7;
#line 6046 "test-new/nrimp10s-77.imp"
GRINF1[1] = STNAME & 65535;
#line 6046 "test-new/nrimp10s-77.imp"
goto L_059E;
#line 6046 "test-new/nrimp10s-77.imp"
L_059D:;
#line 6046 "test-new/nrimp10s-77.imp"
GRUSE[1] = 0;
#line 6046 "test-new/nrimp10s-77.imp"
L_059E:;
// 6047 %FINISH
#line 6047 "test-new/nrimp10s-77.imp"
L_059C:;
// 6048 %IF KK=STUH %THEN GRUSE(ACCR)=0
#line 6048 "test-new/nrimp10s-77.imp"
if (KK != 74) goto L_059F;
#line 6048 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
#line 6048 "test-new/nrimp10s-77.imp"
L_059F:;
// 6049 COMM=1; ->STRES
#line 6049 "test-new/nrimp10s-77.imp"
COMM = 1;
#line 6049 "test-new/nrimp10s-77.imp"
goto U_103C;
// 6050 FINISH: C=STK(STPTR-1)
#line 6050 "test-new/nrimp10s-77.imp"
U_103B:;
#line 6050 "test-new/nrimp10s-77.imp"
C = STK[STPTR - 1];
// 6051 OPERAND(1)=C
#line 6051 "test-new/nrimp10s-77.imp"
OPERAND[0] = C;
// 6052 OPND1==RECORD(C)
#line 6052 "test-new/nrimp10s-77.imp"
OPND1 = (struct RD *)_imp_RECORD(C);
// 6053 %IF OPND1_PTYPE>>4&15<5 %THEN OPND1_PTYPE=OPND1_PTYPE&16_F!16_50;! BITS&BYTES->INTEGERS
#line 6053 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->PTYPE >> 4 & 15 >= 5) goto L_05A0;
#line 6053 "test-new/nrimp10s-77.imp"
OPND1->PTYPE = OPND1->PTYPE & 15 | 80;
#line 6053 "test-new/nrimp10s-77.imp"
L_05A0:;
// 6054 %IF CONDFORM=0 %START; ! IN CONDS ONLY CC MATTERS
#line 6054 "test-new/nrimp10s-77.imp"
if (CONDFORM != 0) goto L_05A1;
// 6055 ! SKIP GETIING OPND INRIGHT FORM
// 6056 ! AND IN THE RIGHT REGISTER
// 6057 D=MODE>>4&7; D=5 %IF D<5
#line 6057 "test-new/nrimp10s-77.imp"
D = (unsigned int)MODE >> 4 & 7;
#line 6057 "test-new/nrimp10s-77.imp"
if (D >= 5) goto L_05A2;
#line 6057 "test-new/nrimp10s-77.imp"
D = 5;
#line 6057 "test-new/nrimp10s-77.imp"
L_05A2:;
// 6058 %IF MODE&7=2 %AND OPND1_PTYPE&7=1 %THEN FLOAT(OPND1,D<<4)
#line 6058 "test-new/nrimp10s-77.imp"
if (MODE & 7 != 2) goto L_05A3;
#line 6058 "test-new/nrimp10s-77.imp"
if (OPND1->PTYPE & 7 != 1) goto L_05A3;
#line 6058 "test-new/nrimp10s-77.imp"
FLOAT(OPND1, D << 4);
#line 6058 "test-new/nrimp10s-77.imp"
L_05A3:;
// 6059 SHORTEN(OPND1) %WHILE D<OPND1_PTYPE>>4
#line 6059 "test-new/nrimp10s-77.imp"
L_05A4:;
#line 6059 "test-new/nrimp10s-77.imp"
if (D >= (unsigned int)OPND1->PTYPE >> 4) goto L_05A5;
#line 6059 "test-new/nrimp10s-77.imp"
SHORTEN(OPND1);
#line 6059 "test-new/nrimp10s-77.imp"
goto L_05A4;
#line 6059 "test-new/nrimp10s-77.imp"
L_05A5:;
// 6060 LENGTHEN(OPND1) %WHILE D>OPND1_PTYPE>>4
#line 6060 "test-new/nrimp10s-77.imp"
L_05A6:;
#line 6060 "test-new/nrimp10s-77.imp"
if (D <= (unsigned int)OPND1->PTYPE >> 4) goto L_05A7;
#line 6060 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND1);
#line 6060 "test-new/nrimp10s-77.imp"
goto L_05A6;
#line 6060 "test-new/nrimp10s-77.imp"
L_05A7:;
// 6061 %IF CONSTFORM=0 %OR 2<=OPND1_FLAG#3 %THEN LOAD(OPND1,REG,2)
#line 6061 "test-new/nrimp10s-77.imp"
if (CONSTFORM == 0) goto L_05A8;
#line 6061 "test-new/nrimp10s-77.imp"
{
// Double-sided test on OPND1->FLAG (Part I)
#line 6061 "test-new/nrimp10s-77.imp"
int tmp;
#line 6061 "test-new/nrimp10s-77.imp"
if (2 > (tmp = OPND1->FLAG)) goto L_05A9;
// Double-sided test on OPND1->FLAG (Part II)
#line 6061 "test-new/nrimp10s-77.imp"
if (tmp == 3) goto L_05A9;
#line 6061 "test-new/nrimp10s-77.imp"
}
#line 6061 "test-new/nrimp10s-77.imp"
L_05A8:;
#line 6061 "test-new/nrimp10s-77.imp"
LOAD(OPND1, REG, 2);
#line 6061 "test-new/nrimp10s-77.imp"
L_05A9:;
// 6062 %FINISH
#line 6062 "test-new/nrimp10s-77.imp"
L_05A1:;
// 6063 EXPOPND=OPND1; ! SET RESULT RECORD
#line 6063 "test-new/nrimp10s-77.imp"
EXPOPND = *OPND1;
// 6064 PTYPE=OPND1_PTYPE
#line 6064 "test-new/nrimp10s-77.imp"
PTYPE = OPND1->PTYPE;
// 6065 TYPE=PTYPE&7; PREC=PTYPE>>4
#line 6065 "test-new/nrimp10s-77.imp"
TYPE = PTYPE & 7;
#line 6065 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)PTYPE >> 4;
// 6066 %IF TYPE=2 %AND MODE&7=1 %THEN FAULT(24,0)
#line 6066 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_05AA;
#line 6066 "test-new/nrimp10s-77.imp"
if (MODE & 7 != 1) goto L_05AA;
#line 6066 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 6066 "test-new/nrimp10s-77.imp"
L_05AA:;
// 6067 %IF OPND1_FLAG=9 %THEN REGISTER(OPND1_XB>>4)=0
#line 6067 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 9) goto L_05AB;
#line 6067 "test-new/nrimp10s-77.imp"
REGISTER[(unsigned int)OPND1->XB >> 4] = 0;
#line 6067 "test-new/nrimp10s-77.imp"
L_05AB:;
// 6068 P=SAVEP
#line 6068 "test-new/nrimp10s-77.imp"
P = SAVEP;
// 6069 %RETURN
#line 6069 "test-new/nrimp10s-77.imp"
return;
// 6070 !
// 6071 %ROUTINE CHOOSE(%INTEGERNAME CHOICE)
#line 6071 "test-new/nrimp10s-77.imp"
void CHOOSE(int *CHOICE) {
// 6072 %RECORD (RD) %NAME OPND1,OPND2{(RD)
#line 6072 "test-new/nrimp10s-77.imp"
struct RD *OPND1;
#line 6072 "test-new/nrimp10s-77.imp"
struct RD *OPND2;
// 6073 OPND1==RECORD(OPERAND(1))
#line 6073 "test-new/nrimp10s-77.imp"
OPND1 = (struct RD *)_imp_RECORD(OPERAND[0]);
// 6074 OPND2==RECORD(OPERAND(2))
#line 6074 "test-new/nrimp10s-77.imp"
OPND2 = (struct RD *)_imp_RECORD(OPERAND[1]);
// 6075 CHOICE=1
#line 6075 "test-new/nrimp10s-77.imp"
*CHOICE = 1;
// 6076 %RETURN %IF JJ=21 %AND EVALREG=BREG;! NO REVERSE SUBTRACT B
#line 6076 "test-new/nrimp10s-77.imp"
if (JJ != 21) goto L_05AC;
#line 6076 "test-new/nrimp10s-77.imp"
if (EVALREG != 7) goto L_05AC;
#line 6076 "test-new/nrimp10s-77.imp"
return;
#line 6076 "test-new/nrimp10s-77.imp"
L_05AC:;
// 6077 CHOICE=2 %IF OPCODE&16_FF00FF00=0 %OR (OPCODE&16_FF00FF#0 %AND (OPND2_FLAG=9 %OR(OPND2_FLAG=2 %AND GRUSE(EVALREG)=9 %AND GRINF1(EVALREG)=OPND2_XTRA>0)))
#line 6077 "test-new/nrimp10s-77.imp"
if (OPCODE & -16711936 == 0) goto L_05AD;
#line 6077 "test-new/nrimp10s-77.imp"
if (OPCODE & 16711935 == 0) goto L_05AE;
#line 6077 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG == 9) goto L_05AD;
#line 6077 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG != 2) goto L_05AE;
#line 6077 "test-new/nrimp10s-77.imp"
if (GRUSE[EVALREG] != 9) goto L_05AE;
#line 6077 "test-new/nrimp10s-77.imp"
{
// Double-sided test on OPND2->XTRA (Part I)
#line 6077 "test-new/nrimp10s-77.imp"
int tmp;
#line 6077 "test-new/nrimp10s-77.imp"
if (GRINF1[EVALREG] != (tmp = OPND2->XTRA)) goto L_05AE;
// Double-sided test on OPND2->XTRA (Part II)
#line 6077 "test-new/nrimp10s-77.imp"
if (tmp <= 0) goto L_05AE;
#line 6077 "test-new/nrimp10s-77.imp"
}
#line 6077 "test-new/nrimp10s-77.imp"
L_05AD:;
#line 6077 "test-new/nrimp10s-77.imp"
*CHOICE = 2;
#line 6077 "test-new/nrimp10s-77.imp"
L_05AE:;
// 6078 %END
#line 6078 "test-new/nrimp10s-77.imp"
return;
#line 6078 "test-new/nrimp10s-77.imp"
} /* end of CHOOSE */
// 6079 %ROUTINE LOAD(%RECORD (RD) %NAME OPND,%INTEGER REG,MODE)
#line 6079 "test-new/nrimp10s-77.imp"
void LOAD(struct RD * OPND, int REG, int MODE) {
// 6080 !***********************************************************************
// 6081 !* LOAD OPERAND OPND AS DIRECTED BY MODE TO REGISTER REG *
// 6082 !* MODE=0 LEAVE IN STORE IF POSSIBLE *
// 6083 !* MODE=1 LEAVE IN STORE IF SUITABLE FOR RX INSTRUCTIONS *
// 6084 !* MODE=2 LOAD TO REGISTER REGARDLESS *
// 6085 !***********************************************************************
// 6086 %INTEGER K,KK
#line 6086 "test-new/nrimp10s-77.imp"
int K;
#line 6086 "test-new/nrimp10s-77.imp"
int KK;
// 6087 {%RECORDSPEC OPND(RD)
// 6088 %SWITCH SW(0:9)
#line 6088 "test-new/nrimp10s-77.imp"
int SW_index;
#line 6088 "test-new/nrimp10s-77.imp"
int SW_line;
#line 6088 "test-new/nrimp10s-77.imp"
char *SW_file;
#line 6088 "test-new/nrimp10s-77.imp"
static const void *SW[10] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing};
// 6089 K=OPND_FLAG
#line 6089 "test-new/nrimp10s-77.imp"
K = OPND->FLAG;
// 6090 %RETURN %UNLESS MODE=2 %OR K=2 %OR(K<=3 %AND MODE=1)
#line 6090 "test-new/nrimp10s-77.imp"
if (MODE == 2) goto L_05AF;
#line 6090 "test-new/nrimp10s-77.imp"
if (K == 2) goto L_05AF;
#line 6090 "test-new/nrimp10s-77.imp"
if (K > 3) goto L_05B0;
#line 6090 "test-new/nrimp10s-77.imp"
if (MODE == 1) goto L_05AF;
#line 6090 "test-new/nrimp10s-77.imp"
L_05B0:;
#line 6090 "test-new/nrimp10s-77.imp"
return;
#line 6090 "test-new/nrimp10s-77.imp"
L_05AF:;
// 6091 PTYPE=OPND_PTYPE
#line 6091 "test-new/nrimp10s-77.imp"
PTYPE = OPND->PTYPE;
// 6092 TYPE=PTYPE&15
#line 6092 "test-new/nrimp10s-77.imp"
TYPE = PTYPE & 15;
// 6093 PREC=PTYPE>>4
#line 6093 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)PTYPE >> 4;
// 6094 %IF K<0 %OR K>9 %THEN ABORT
#line 6094 "test-new/nrimp10s-77.imp"
if (K < 0) goto L_05B1;
#line 6094 "test-new/nrimp10s-77.imp"
if (K <= 9) goto L_05B2;
#line 6094 "test-new/nrimp10s-77.imp"
L_05B1:;
#line 6094 "test-new/nrimp10s-77.imp"
ABORT();
#line 6094 "test-new/nrimp10s-77.imp"
L_05B2:;
// 6095 ->SW(K)
#line 6095 "test-new/nrimp10s-77.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = K;
goto case_SW_dispatch;
// 6096 SW(0):LITCONST: ! CONSTANT < 18 BITS
#line 6096 "test-new/nrimp10s-77.imp"
case_SW_0:;
#line 6096 "test-new/nrimp10s-77.imp"
U_1042:;
// 6097 AREA=0; ACCESS=0
#line 6097 "test-new/nrimp10s-77.imp"
AREA = 0;
#line 6097 "test-new/nrimp10s-77.imp"
ACCESS = 0;
// 6098 %IF PREC<=5 %THEN DISP=OPND_D %ELSE %START
#line 6098 "test-new/nrimp10s-77.imp"
if (PREC > 5) goto L_05B4;
#line 6098 "test-new/nrimp10s-77.imp"
DISP = OPND->D;
#line 6098 "test-new/nrimp10s-77.imp"
goto L_05B5;
#line 6098 "test-new/nrimp10s-77.imp"
L_05B4:;
// 6099 DISP=OPND_XTRA
#line 6099 "test-new/nrimp10s-77.imp"
DISP = OPND->XTRA;
// 6100 ABORT %UNLESS (DISP>=0 %AND OPND_D=0) %OR (DISP<0 %AND OPND_D=-1)
#line 6100 "test-new/nrimp10s-77.imp"
if (DISP < 0) goto L_05B6;
#line 6100 "test-new/nrimp10s-77.imp"
if (OPND->D == 0) goto L_05B7;
#line 6100 "test-new/nrimp10s-77.imp"
L_05B6:;
#line 6100 "test-new/nrimp10s-77.imp"
if (DISP >= 0) goto L_05B8;
#line 6100 "test-new/nrimp10s-77.imp"
if (OPND->D == -1) goto L_05B7;
#line 6100 "test-new/nrimp10s-77.imp"
L_05B8:;
#line 6100 "test-new/nrimp10s-77.imp"
ABORT();
#line 6100 "test-new/nrimp10s-77.imp"
L_05B7:;
// 6101 %FINISH
#line 6101 "test-new/nrimp10s-77.imp"
L_05B5:;
// 6102 %IF MODE=2 %THEN %START; ! FETCH TO REG
#line 6102 "test-new/nrimp10s-77.imp"
if (MODE != 2) goto L_05B9;
// 6103 %IF GRUSE(REG)&255=5=PREC %AND GRINF1(REG)=DISP %START
#line 6103 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 5 (Part I)
#line 6103 "test-new/nrimp10s-77.imp"
int tmp;
#line 6103 "test-new/nrimp10s-77.imp"
if (GRUSE[REG] & 255 != (tmp = 5)) goto L_05BA;
// Double-sided test on 5 (Part II)
#line 6103 "test-new/nrimp10s-77.imp"
if (tmp != PREC) goto L_05BA;
#line 6103 "test-new/nrimp10s-77.imp"
}
#line 6103 "test-new/nrimp10s-77.imp"
if (GRINF1[REG] != DISP) goto L_05BA;
// 6104 %IF REGISTER(REG)#0 %THEN BOOT OUT(REG)
#line 6104 "test-new/nrimp10s-77.imp"
if (REGISTER[REG] == 0) goto L_05BB;
#line 6104 "test-new/nrimp10s-77.imp"
BOOTOUT(REG);
#line 6104 "test-new/nrimp10s-77.imp"
L_05BB:;
// 6105 %FINISHELSE GET IN ACC(REG,BYTES(PREC)>>2,ACCESS,AREA,DISP)
#line 6105 "test-new/nrimp10s-77.imp"
goto L_05BC;
#line 6105 "test-new/nrimp10s-77.imp"
L_05BA:;
#line 6105 "test-new/nrimp10s-77.imp"
GETINACC(REG, (unsigned int)BYTES[PREC] >> 2, ACCESS, AREA, DISP);
#line 6105 "test-new/nrimp10s-77.imp"
L_05BC:;
// 6106 %IF PREC<=5 %THEN GRUSE(REG)=5 %AND GRINF1(REG)=DISP
#line 6106 "test-new/nrimp10s-77.imp"
if (PREC > 5) goto L_05BD;
#line 6106 "test-new/nrimp10s-77.imp"
GRUSE[REG] = 5;
#line 6106 "test-new/nrimp10s-77.imp"
GRINF1[REG] = DISP;
#line 6106 "test-new/nrimp10s-77.imp"
L_05BD:;
// 6107 ->LDED
#line 6107 "test-new/nrimp10s-77.imp"
goto U_1043;
// 6108 %FINISH
#line 6108 "test-new/nrimp10s-77.imp"
L_05B9:;
// 6109 %IF PREC=3 %THEN OPND_PTYPE=16_51; ! CONSTBYTEINTEGERS AGAIN
#line 6109 "test-new/nrimp10s-77.imp"
if (PREC != 3) goto L_05BE;
#line 6109 "test-new/nrimp10s-77.imp"
OPND->PTYPE = 81;
#line 6109 "test-new/nrimp10s-77.imp"
L_05BE:;
// 6110 OPND_FLAG=7; OPND_XB=AREA<<4!ACCESS
#line 6110 "test-new/nrimp10s-77.imp"
OPND->FLAG = 7;
#line 6110 "test-new/nrimp10s-77.imp"
OPND->XB = AREA << 4 | ACCESS;
// 6111 OPND_D=DISP
#line 6111 "test-new/nrimp10s-77.imp"
OPND->D = DISP;
// 6112 %RETURN
#line 6112 "test-new/nrimp10s-77.imp"
return;
// 6113 SW(1): ! LONG CONSTANT
#line 6113 "test-new/nrimp10s-77.imp"
case_SW_1:;
// 6114 %IF OPND_D=0=OPND_XTRA %AND PREC<=6 %THEN ->LITCONST
#line 6114 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 6114 "test-new/nrimp10s-77.imp"
int tmp;
#line 6114 "test-new/nrimp10s-77.imp"
if (OPND->D != (tmp = 0)) goto L_05BF;
// Double-sided test on 0 (Part II)
#line 6114 "test-new/nrimp10s-77.imp"
if (tmp != OPND->XTRA) goto L_05BF;
#line 6114 "test-new/nrimp10s-77.imp"
}
#line 6114 "test-new/nrimp10s-77.imp"
if (PREC > 6) goto L_05BF;
#line 6114 "test-new/nrimp10s-77.imp"
goto U_1042;
#line 6114 "test-new/nrimp10s-77.imp"
L_05BF:;
// 6115 SW(3): ! 128 BIT CONSTANT
#line 6115 "test-new/nrimp10s-77.imp"
case_SW_3:;
// 6116 %IF PREC=7 %THEN KK=OPND_XTRA %ELSE KK=ADDR(OPND_D)
#line 6116 "test-new/nrimp10s-77.imp"
if (PREC != 7) goto L_05C0;
#line 6116 "test-new/nrimp10s-77.imp"
KK = OPND->XTRA;
#line 6116 "test-new/nrimp10s-77.imp"
goto L_05C1;
#line 6116 "test-new/nrimp10s-77.imp"
L_05C0:;
#line 6116 "test-new/nrimp10s-77.imp"
KK = _imp_ADDR(/*?*/ &OPND->D);
#line 6116 "test-new/nrimp10s-77.imp"
L_05C1:;
// 6117 STORE CONST(DISP,BYTES(PREC),KK)
#line 6117 "test-new/nrimp10s-77.imp"
STORECONST(/*?*/ &DISP, BYTES[PREC], KK);
// 6118 %IF MODE#2 %THEN %START
#line 6118 "test-new/nrimp10s-77.imp"
if (MODE == 2) goto L_05C2;
// 6119 OPND_FLAG=7; OPND_XB=PC<<4
#line 6119 "test-new/nrimp10s-77.imp"
OPND->FLAG = 7;
#line 6119 "test-new/nrimp10s-77.imp"
OPND->XB = 4 << 4;
// 6120 OPND_D=DISP; %RETURN
#line 6120 "test-new/nrimp10s-77.imp"
OPND->D = DISP;
#line 6120 "test-new/nrimp10s-77.imp"
return;
// 6121 %FINISH
#line 6121 "test-new/nrimp10s-77.imp"
L_05C2:;
// 6122 %IF GRUSE(REG)&255=6 %AND GRINF1(REG)=DISP %THEN %START
#line 6122 "test-new/nrimp10s-77.imp"
if (GRUSE[REG] & 255 != 6) goto L_05C3;
#line 6122 "test-new/nrimp10s-77.imp"
if (GRINF1[REG] != DISP) goto L_05C3;
// 6123 %IF REGISTER(REG)#0 %THEN BOOT OUT (REG)
#line 6123 "test-new/nrimp10s-77.imp"
if (REGISTER[REG] == 0) goto L_05C4;
#line 6123 "test-new/nrimp10s-77.imp"
BOOTOUT(REG);
#line 6123 "test-new/nrimp10s-77.imp"
L_05C4:;
// 6124 %FINISH %ELSE GET IN ACC(REG,BYTES(PREC)>>2,0,PC,DISP)
#line 6124 "test-new/nrimp10s-77.imp"
goto L_05C5;
#line 6124 "test-new/nrimp10s-77.imp"
L_05C3:;
#line 6124 "test-new/nrimp10s-77.imp"
GETINACC(REG, (unsigned int)BYTES[PREC] >> 2, 0, 4, DISP);
#line 6124 "test-new/nrimp10s-77.imp"
L_05C5:;
// 6125 GRUSE(REG)=6; GRINF1(REG)=DISP
#line 6125 "test-new/nrimp10s-77.imp"
GRUSE[REG] = 6;
#line 6125 "test-new/nrimp10s-77.imp"
GRINF1[REG] = DISP;
// 6126 ->LDED
#line 6126 "test-new/nrimp10s-77.imp"
goto U_1043;
// 6127 SW(2): ! NAME
#line 6127 "test-new/nrimp10s-77.imp"
case_SW_2:;
// 6128 P=OPND_D
#line 6128 "test-new/nrimp10s-77.imp"
P = OPND->D;
// 6129 -> LOAD %IF MODE=2 %OR OPND_XB#0;! COMPLEX NAMES MUST BE LOADED
#line 6129 "test-new/nrimp10s-77.imp"
if (MODE == 2) goto L_05C6;
#line 6129 "test-new/nrimp10s-77.imp"
if (OPND->XB == 0) goto L_05C7;
#line 6129 "test-new/nrimp10s-77.imp"
L_05C6:;
#line 6129 "test-new/nrimp10s-77.imp"
goto U_1044;
#line 6129 "test-new/nrimp10s-77.imp"
L_05C7:;
// 6130 CNAME(5,REG)
#line 6130 "test-new/nrimp10s-77.imp"
CNAME(5, REG);
// 6131 ->LDED %IF NEST>=0
#line 6131 "test-new/nrimp10s-77.imp"
if (NEST < 0) goto L_05C8;
#line 6131 "test-new/nrimp10s-77.imp"
goto U_1043;
#line 6131 "test-new/nrimp10s-77.imp"
L_05C8:;
// 6132 AREA=-1
#line 6132 "test-new/nrimp10s-77.imp"
AREA = -1;
// 6133 AREA=AREA CODE
#line 6133 "test-new/nrimp10s-77.imp"
AREA = AREACODE();
// 6134 OPND_PTYPE<-PTYPE
#line 6134 "test-new/nrimp10s-77.imp"
OPND->PTYPE = (int)(PTYPE);
// 6135 OPND_FLAG=7
#line 6135 "test-new/nrimp10s-77.imp"
OPND->FLAG = 7;
// 6136 OPND_XB=AREA<<4!ACCESS
#line 6136 "test-new/nrimp10s-77.imp"
OPND->XB = AREA << 4 | ACCESS;
// 6137 OPND_D=DISP; %RETURN
#line 6137 "test-new/nrimp10s-77.imp"
OPND->D = DISP;
#line 6137 "test-new/nrimp10s-77.imp"
return;
// 6138 LOAD: CNAME(2,REG)
#line 6138 "test-new/nrimp10s-77.imp"
U_1044:;
#line 6138 "test-new/nrimp10s-77.imp"
CNAME(2, REG);
// 6139 LDED: REGISTER(REG)=1; ! CLAIM THE REGISTER
#line 6139 "test-new/nrimp10s-77.imp"
U_1043:;
#line 6139 "test-new/nrimp10s-77.imp"
REGISTER[REG] = 1;
// 6140 OLINK(REG)=ADDR(OPND)
#line 6140 "test-new/nrimp10s-77.imp"
OLINK[REG] = _imp_ADDR(OPND);
// 6141 %IF PREC<5 %THEN OPND_PTYPE=OPND_PTYPE&15!16_50
#line 6141 "test-new/nrimp10s-77.imp"
if (PREC >= 5) goto L_05C9;
#line 6141 "test-new/nrimp10s-77.imp"
OPND->PTYPE = OPND->PTYPE & 15 | 80;
#line 6141 "test-new/nrimp10s-77.imp"
L_05C9:;
// 6142 OPND_FLAG=9; OPND_D=0; OPND_XB=REG<<4
#line 6142 "test-new/nrimp10s-77.imp"
OPND->FLAG = 9;
#line 6142 "test-new/nrimp10s-77.imp"
OPND->D = 0;
#line 6142 "test-new/nrimp10s-77.imp"
OPND->XB = REG << 4;
// 6143 %IF REG=BREG %AND REGISTER(ACCR)&1#0 %THEN REGISTER(BREG)=2
#line 6143 "test-new/nrimp10s-77.imp"
if (REG != 7) goto L_05CA;
#line 6143 "test-new/nrimp10s-77.imp"
if (REGISTER[0] & 1 == 0) goto L_05CA;
#line 6143 "test-new/nrimp10s-77.imp"
REGISTER[7] = 2;
#line 6143 "test-new/nrimp10s-77.imp"
L_05CA:;
// 6144 %RETURN
#line 6144 "test-new/nrimp10s-77.imp"
return;
// 6145 SW(4): ! CONDITIONAL EXPRESSION
#line 6145 "test-new/nrimp10s-77.imp"
case_SW_4:;
// 6146 SW(5): ! UNASSIGNED
#line 6146 "test-new/nrimp10s-77.imp"
case_SW_5:;
// 6147 SW(6): ! UNASSIGNED
#line 6147 "test-new/nrimp10s-77.imp"
case_SW_6:;
// 6148 ABORT
#line 6148 "test-new/nrimp10s-77.imp"
ABORT();
// 6149 SW(7): ! I-R IN A STACK FRAME
#line 6149 "test-new/nrimp10s-77.imp"
case_SW_7:;
// 6150 AREA=OPND_XB>>4
#line 6150 "test-new/nrimp10s-77.imp"
AREA = (unsigned int)OPND->XB >> 4;
// 6151 ACCESS=OPND_XB&15
#line 6151 "test-new/nrimp10s-77.imp"
ACCESS = OPND->XB & 15;
// 6152 DISP=OPND_D
#line 6152 "test-new/nrimp10s-77.imp"
DISP = OPND->D;
// 6153 PICKUP: GET IN ACC(REG,BYTES(PREC)>>2,ACCESS,AREA,DISP)
#line 6153 "test-new/nrimp10s-77.imp"
U_1045:;
#line 6153 "test-new/nrimp10s-77.imp"
GETINACC(REG, (unsigned int)BYTES[PREC] >> 2, ACCESS, AREA, DISP);
// 6154 ->LDED
#line 6154 "test-new/nrimp10s-77.imp"
goto U_1043;
// 6155 SW(8): ! I-R THAT HAS BEEN STACKED
#line 6155 "test-new/nrimp10s-77.imp"
case_SW_8:;
// 6156 AREA=TOS; ACCESS=0; DISP=0; ->PICK UP
#line 6156 "test-new/nrimp10s-77.imp"
AREA = 6;
#line 6156 "test-new/nrimp10s-77.imp"
ACCESS = 0;
#line 6156 "test-new/nrimp10s-77.imp"
DISP = 0;
#line 6156 "test-new/nrimp10s-77.imp"
goto U_1045;
// 6157 SW(9): ! I-R IN A REGISTER
#line 6157 "test-new/nrimp10s-77.imp"
case_SW_9:;
// 6158 %IF OPND_XB>>4=REG %THEN -> LDED
#line 6158 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND->XB >> 4 != REG) goto L_05CB;
#line 6158 "test-new/nrimp10s-77.imp"
goto U_1043;
#line 6158 "test-new/nrimp10s-77.imp"
L_05CB:;
// 6159 %IF REG#ACCR %THEN %START
#line 6159 "test-new/nrimp10s-77.imp"
if (REG == 0) goto L_05CC;
// 6160 BOOT OUT(BREG) %UNLESS REGISTER(BREG)=0
#line 6160 "test-new/nrimp10s-77.imp"
if (REGISTER[7] == 0) goto L_05CD;
#line 6160 "test-new/nrimp10s-77.imp"
BOOTOUT(7);
#line 6160 "test-new/nrimp10s-77.imp"
L_05CD:;
// 6161 PF1(ST,0,BREG,0)
#line 6161 "test-new/nrimp10s-77.imp"
PF1(72, 0, 7, 0);
// 6162 %FINISH %ELSE GET IN ACC(ACCR,1,0,BREG,0)
#line 6162 "test-new/nrimp10s-77.imp"
goto L_05CE;
#line 6162 "test-new/nrimp10s-77.imp"
L_05CC:;
#line 6162 "test-new/nrimp10s-77.imp"
GETINACC(0, 1, 0, 7, 0);
#line 6162 "test-new/nrimp10s-77.imp"
L_05CE:;
// 6163 REGISTER(OPND_XB>>4)=0
#line 6163 "test-new/nrimp10s-77.imp"
REGISTER[(unsigned int)OPND->XB >> 4] = 0;
// 6164 OPND_XB=REG<<4; GRUSE(REG)=0
#line 6164 "test-new/nrimp10s-77.imp"
OPND->XB = REG << 4;
#line 6164 "test-new/nrimp10s-77.imp"
GRUSE[REG] = 0;
// 6165 REGISTER(REG)=1; OLINK(REG)=ADDR(OPND)
#line 6165 "test-new/nrimp10s-77.imp"
REGISTER[REG] = 1;
#line 6165 "test-new/nrimp10s-77.imp"
OLINK[REG] = _imp_ADDR(OPND);
// 6166 %END
#line 6166 "test-new/nrimp10s-77.imp"
return;
#line 6166 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 6166 "test-new/nrimp10s-77.imp"
if (SW_index < 0 || SW_index > 9)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 6166 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 0];
#line 6166 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 6166 "test-new/nrimp10s-77.imp"
} /* end of LOAD */
// 6167 %ROUTINE PUT
#line 6167 "test-new/nrimp10s-77.imp"
void PUT(void) {
// 6168 !***********************************************************************
// 6169 !* THIS ROUTINE PLANTS CODE TO PERFORM THE BASIC *
// 6170 !* OPERATION DEFINED BY OPND1,OPND2 & OPCODE *
// 6171 !***********************************************************************
// 6172 %INTEGER CODE,OCODE
#line 6172 "test-new/nrimp10s-77.imp"
int CODE;
#line 6172 "test-new/nrimp10s-77.imp"
int OCODE;
// 6173 CODE=OPCODE
#line 6173 "test-new/nrimp10s-77.imp"
CODE = OPCODE;
// 6174 %IF COMM=1 %THEN CODE=CODE>>8
#line 6174 "test-new/nrimp10s-77.imp"
if (COMM != 1) goto L_05CF;
#line 6174 "test-new/nrimp10s-77.imp"
CODE = (unsigned int)CODE >> 8;
#line 6174 "test-new/nrimp10s-77.imp"
L_05CF:;
// 6175 CODE=CODE&255; OCODE=CODE
#line 6175 "test-new/nrimp10s-77.imp"
CODE = CODE & 255;
#line 6175 "test-new/nrimp10s-77.imp"
OCODE = CODE;
// 6176 %IF EVALREG=BREG %THEN CODE=CODE-16_C0
#line 6176 "test-new/nrimp10s-77.imp"
if (EVALREG != 7) goto L_05D0;
#line 6176 "test-new/nrimp10s-77.imp"
CODE = CODE - 192;
#line 6176 "test-new/nrimp10s-77.imp"
L_05D0:;
// 6177 ABORT %UNLESS OPND1_FLAG=9
#line 6177 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG == 9) goto L_05D1;
#line 6177 "test-new/nrimp10s-77.imp"
ABORT();
#line 6177 "test-new/nrimp10s-77.imp"
L_05D1:;
// 6178 PSORLF1(CODE,OPND2_XB&15,OPND2_XB>>4,OPND2_D)
#line 6178 "test-new/nrimp10s-77.imp"
PSORLF1(CODE, OPND2->XB & 15, (unsigned int)OPND2->XB >> 4, OPND2->D);
// 6179 %IF OCODE=IAD %AND GRUSE(EVALREG)=9 %AND OPND2_XB=0 %AND OPND2_D<4095 %AND GRINF1(EVALREG)>>16=0 %THEN %START
#line 6179 "test-new/nrimp10s-77.imp"
if (OCODE != 224) goto L_05D2;
#line 6179 "test-new/nrimp10s-77.imp"
if (GRUSE[EVALREG] != 9) goto L_05D2;
#line 6179 "test-new/nrimp10s-77.imp"
if (OPND2->XB != 0) goto L_05D2;
#line 6179 "test-new/nrimp10s-77.imp"
if (OPND2->D >= 4095) goto L_05D2;
#line 6179 "test-new/nrimp10s-77.imp"
if ((unsigned int)GRINF1[EVALREG] >> 16 != 0) goto L_05D2;
// 6180 GRUSE(EVALREG)=10
#line 6180 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 10;
// 6181 GRINF1(EVALREG)=GRINF1(EVALREG)&16_FFFF!OPND2_D<<16
#line 6181 "test-new/nrimp10s-77.imp"
GRINF1[EVALREG] = GRINF1[EVALREG] & 65535 | OPND2->D << 16;
// 6182 %FINISH %ELSE %START
#line 6182 "test-new/nrimp10s-77.imp"
goto L_05D3;
#line 6182 "test-new/nrimp10s-77.imp"
L_05D2:;
// 6183 GRUSE(EVALREG)=0 %UNLESS 31<=JJ<=32
#line 6183 "test-new/nrimp10s-77.imp"
{
// Double-sided test on JJ (Part I)
#line 6183 "test-new/nrimp10s-77.imp"
int tmp;
#line 6183 "test-new/nrimp10s-77.imp"
if (31 > (tmp = JJ)) goto L_05D4;
// Double-sided test on JJ (Part II)
#line 6183 "test-new/nrimp10s-77.imp"
if (tmp <= 32) goto L_05D5;
#line 6183 "test-new/nrimp10s-77.imp"
}
#line 6183 "test-new/nrimp10s-77.imp"
L_05D4:;
#line 6183 "test-new/nrimp10s-77.imp"
GRUSE[EVALREG] = 0;
#line 6183 "test-new/nrimp10s-77.imp"
L_05D5:;
// 6184 %FINISH
#line 6184 "test-new/nrimp10s-77.imp"
L_05D3:;
// 6185 OLINK(EVALREG)=OPERAND(COMM)
#line 6185 "test-new/nrimp10s-77.imp"
OLINK[EVALREG] = OPERAND[COMM - 1];
// 6186 %END
#line 6186 "test-new/nrimp10s-77.imp"
return;
#line 6186 "test-new/nrimp10s-77.imp"
} /* end of PUT */
// 6187 %ROUTINE FLOAT(%RECORD(RD)%NAME OPND,%INTEGER OTHERPTYPE)
#line 6187 "test-new/nrimp10s-77.imp"
void FLOAT(struct RD * OPND, int OTHERPTYPE) {
// 6188 !***********************************************************************
// 6189 !* PLANT CODE TO CONERT OPERAND FROM FIXED TO FLOATING *
// 6190 !***********************************************************************
// 6191 {%RECORDSPEC OPND(RD)
// 6192 %IF OPND_FLAG<=1 %THEN %START
#line 6192 "test-new/nrimp10s-77.imp"
if (OPND->FLAG > 1) goto L_05D6;
// 6193 CVALUE=OPND_D
#line 6193 "test-new/nrimp10s-77.imp"
CVALUE = OPND->D;
// 6194 OPND_D=INTEGER(ADDR(CVALUE))
#line 6194 "test-new/nrimp10s-77.imp"
OPND->D = *_imp_INTEGER(_imp_ADDR(/*?*/ &CVALUE));
// 6195 OPND_XTRA=INTEGER(ADDR(CVALUE)+4)
#line 6195 "test-new/nrimp10s-77.imp"
OPND->XTRA = *_imp_INTEGER(_imp_ADDR(/*?*/ &CVALUE) + 4);
// 6196 OPND_FLAG=1
#line 6196 "test-new/nrimp10s-77.imp"
OPND->FLAG = 1;
// 6197 %FINISH %ELSE %START
#line 6197 "test-new/nrimp10s-77.imp"
goto L_05D7;
#line 6197 "test-new/nrimp10s-77.imp"
L_05D6:;
// 6198 LOAD(OPND,ACCR,2)
#line 6198 "test-new/nrimp10s-77.imp"
LOAD(OPND, 0, 2);
// 6199 %IF OTHERPTYPE&16_F0=16_70 %AND OPND_PTYPE&16_F0<=16_50 %THEN PSF1(IMYD,0,1) %AND OPND_PTYPE=OPND_PTYPE&15!16_60
#line 6199 "test-new/nrimp10s-77.imp"
if (OTHERPTYPE & 240 != 112) goto L_05D8;
#line 6199 "test-new/nrimp10s-77.imp"
if (OPND->PTYPE & 240 > 80) goto L_05D8;
#line 6199 "test-new/nrimp10s-77.imp"
PSF1(236, 0, 1);
#line 6199 "test-new/nrimp10s-77.imp"
OPND->PTYPE = OPND->PTYPE & 15 | 96;
#line 6199 "test-new/nrimp10s-77.imp"
L_05D8:;
// 6200 PSF1(FLT,0,0)
#line 6200 "test-new/nrimp10s-77.imp"
PSF1(168, 0, 0);
// 6201 GRUSE(ACCR)=0
#line 6201 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 6202 %FINISH
#line 6202 "test-new/nrimp10s-77.imp"
L_05D7:;
// 6203 OPND_PTYPE=OPND_PTYPE+16_11
#line 6203 "test-new/nrimp10s-77.imp"
OPND->PTYPE = OPND->PTYPE + 17;
// 6204 TYPE=2
#line 6204 "test-new/nrimp10s-77.imp"
TYPE = 2;
// 6205 %END
#line 6205 "test-new/nrimp10s-77.imp"
return;
#line 6205 "test-new/nrimp10s-77.imp"
} /* end of FLOAT */
// 6206 %ROUTINE COERCET(%RECORD(RD)%NAME OPND1,OPND2,%INTEGER MODE)
#line 6206 "test-new/nrimp10s-77.imp"
void COERCET(struct RD * OPND1, struct RD * OPND2, int MODE) {
// 6207 !***********************************************************************
// 6208 !* MODE=1 BOTH OPERANDS INTEGER ELSE ERROR *
// 6209 !* MODE=2 FORCE BOTH OPERAND TO BE OF TYPE REAL *
// 6210 !* MODE=15 BOTH OPERANDS TO BE OF LAGEST TYPE *
// 6211 !***********************************************************************
// 6212 {%RECORDSPEC OPND1(RD)
// 6213 {%RECORDSPEC OPND2(RD)
// 6214 %INTEGER PT1,PT2
#line 6214 "test-new/nrimp10s-77.imp"
int PT1;
#line 6214 "test-new/nrimp10s-77.imp"
int PT2;
// 6215 PT1=OPND1_PTYPE&7
#line 6215 "test-new/nrimp10s-77.imp"
PT1 = OPND1->PTYPE & 7;
// 6216 PT2=OPND2_PTYPE&7
#line 6216 "test-new/nrimp10s-77.imp"
PT2 = OPND2->PTYPE & 7;
// 6217 %IF (MODE=1 %OR MODE=15) %AND PT1=1=PT2 %THEN %RETURN
#line 6217 "test-new/nrimp10s-77.imp"
if (MODE == 1) goto L_05D9;
#line 6217 "test-new/nrimp10s-77.imp"
if (MODE != 15) goto L_05DA;
#line 6217 "test-new/nrimp10s-77.imp"
L_05D9:;
#line 6217 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 1 (Part I)
#line 6217 "test-new/nrimp10s-77.imp"
int tmp;
#line 6217 "test-new/nrimp10s-77.imp"
if (PT1 != (tmp = 1)) goto L_05DA;
// Double-sided test on 1 (Part II)
#line 6217 "test-new/nrimp10s-77.imp"
if (tmp != PT2) goto L_05DA;
#line 6217 "test-new/nrimp10s-77.imp"
}
#line 6217 "test-new/nrimp10s-77.imp"
return;
#line 6217 "test-new/nrimp10s-77.imp"
L_05DA:;
// 6218 %IF MODE=1 %THEN FAULT(24,0) %AND %RETURN
#line 6218 "test-new/nrimp10s-77.imp"
if (MODE != 1) goto L_05DB;
#line 6218 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 6218 "test-new/nrimp10s-77.imp"
return;
#line 6218 "test-new/nrimp10s-77.imp"
L_05DB:;
// 6219 %IF PT1=1 %THEN FLOAT(OPND1,OPND2_PTYPE)
#line 6219 "test-new/nrimp10s-77.imp"
if (PT1 != 1) goto L_05DC;
#line 6219 "test-new/nrimp10s-77.imp"
FLOAT(OPND1, OPND2->PTYPE);
#line 6219 "test-new/nrimp10s-77.imp"
L_05DC:;
// 6220 %IF PT2=1 %THEN FLOAT(OPND2,OPND1_PTYPE)
#line 6220 "test-new/nrimp10s-77.imp"
if (PT2 != 1) goto L_05DD;
#line 6220 "test-new/nrimp10s-77.imp"
FLOAT(OPND2, OPND1->PTYPE);
#line 6220 "test-new/nrimp10s-77.imp"
L_05DD:;
// 6221 %END
#line 6221 "test-new/nrimp10s-77.imp"
return;
#line 6221 "test-new/nrimp10s-77.imp"
} /* end of COERCET */
// 6222 %ROUTINE COERCEP(%RECORD(RD)%NAME OPND1,OPND2)
#line 6222 "test-new/nrimp10s-77.imp"
void COERCEP(struct RD * OPND1, struct RD * OPND2) {
// 6223 !***********************************************************************
// 6224 !* FORCE BOTH OPERAND TO THE SAME PRECISION BEFORE OPRNTN *
// 6225 !***********************************************************************
// 6226 {%RECORDSPEC OPND1(RD)
// 6227 {%RECORDSPEC OPND2(RD)
// 6228 %INTEGER PREC1,PREC2
#line 6228 "test-new/nrimp10s-77.imp"
int PREC1;
#line 6228 "test-new/nrimp10s-77.imp"
int PREC2;
// 6229 PREC1=OPND1_PTYPE>>4
#line 6229 "test-new/nrimp10s-77.imp"
PREC1 = (unsigned int)OPND1->PTYPE >> 4;
// 6230 PREC2=OPND2_PTYPE>>4
#line 6230 "test-new/nrimp10s-77.imp"
PREC2 = (unsigned int)OPND2->PTYPE >> 4;
// 6231 %WHILE PREC1<PREC2 %CYCLE
#line 6231 "test-new/nrimp10s-77.imp"
L_05DE:;
#line 6231 "test-new/nrimp10s-77.imp"
if (PREC1 >= PREC2) goto L_05DF;
// 6232 LENGTHEN(OPND1)
#line 6232 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND1);
// 6233 PREC1=OPND1_PTYPE>>4
#line 6233 "test-new/nrimp10s-77.imp"
PREC1 = (unsigned int)OPND1->PTYPE >> 4;
// 6234 %REPEAT
#line 6234 "test-new/nrimp10s-77.imp"
goto L_05DE;
#line 6234 "test-new/nrimp10s-77.imp"
L_05DF:;
// 6235 !
// 6236 %WHILE PREC2<PREC1 %CYCLE
#line 6236 "test-new/nrimp10s-77.imp"
L_05E0:;
#line 6236 "test-new/nrimp10s-77.imp"
if (PREC2 >= PREC1) goto L_05E1;
// 6237 LENGTHEN(OPND2)
#line 6237 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND2);
// 6238 PREC2=OPND2_PTYPE>>4
#line 6238 "test-new/nrimp10s-77.imp"
PREC2 = (unsigned int)OPND2->PTYPE >> 4;
// 6239 %REPEAT
#line 6239 "test-new/nrimp10s-77.imp"
goto L_05E0;
#line 6239 "test-new/nrimp10s-77.imp"
L_05E1:;
// 6240 %END
#line 6240 "test-new/nrimp10s-77.imp"
return;
#line 6240 "test-new/nrimp10s-77.imp"
} /* end of COERCEP */
// 6241 %ROUTINE LENGTHEN(%RECORD(RD)%NAME OPND)
#line 6241 "test-new/nrimp10s-77.imp"
void LENGTHEN(struct RD * OPND) {
// 6242 !***********************************************************************
// 6243 !* INCREASE OPND PRECISION BY ONE SIZE AT COMPILE TIME IF POSS *
// 6244 !***********************************************************************
// 6245 {%RECORDSPEC OPND(RD)
// 6246 %INTEGER TP,PR
#line 6246 "test-new/nrimp10s-77.imp"
int TP;
#line 6246 "test-new/nrimp10s-77.imp"
int PR;
// 6247 TP=OPND_PTYPE&7
#line 6247 "test-new/nrimp10s-77.imp"
TP = OPND->PTYPE & 7;
// 6248 PR=OPND_PTYPE>>4
#line 6248 "test-new/nrimp10s-77.imp"
PR = (unsigned int)OPND->PTYPE >> 4;
// 6249 %IF OPND_FLAG<=1 %AND PR<=4+TP %START; ! LENGTHEN CONSTANT
#line 6249 "test-new/nrimp10s-77.imp"
if (OPND->FLAG > 1) goto L_05E2;
#line 6249 "test-new/nrimp10s-77.imp"
if (PR > 4 + TP) goto L_05E2;
// 6250 %IF TP=1 %AND OPND_FLAG<=1 %START;! INTEGER CONSTANT
#line 6250 "test-new/nrimp10s-77.imp"
if (TP != 1) goto L_05E3;
#line 6250 "test-new/nrimp10s-77.imp"
if (OPND->FLAG > 1) goto L_05E3;
// 6251 OPND_XTRA=OPND_D
#line 6251 "test-new/nrimp10s-77.imp"
OPND->XTRA = OPND->D;
// 6252 %IF OPND_XTRA<0 %THEN OPND_D=-1 %ELSE OPND_D=0
#line 6252 "test-new/nrimp10s-77.imp"
if (OPND->XTRA >= 0) goto L_05E4;
#line 6252 "test-new/nrimp10s-77.imp"
OPND->D = -1;
#line 6252 "test-new/nrimp10s-77.imp"
goto L_05E5;
#line 6252 "test-new/nrimp10s-77.imp"
L_05E4:;
#line 6252 "test-new/nrimp10s-77.imp"
OPND->D = 0;
#line 6252 "test-new/nrimp10s-77.imp"
L_05E5:;
// 6253 %FINISH %ELSE %START
#line 6253 "test-new/nrimp10s-77.imp"
goto L_05E6;
#line 6253 "test-new/nrimp10s-77.imp"
L_05E3:;
// 6254 %IF PR=6 %THEN %START
#line 6254 "test-new/nrimp10s-77.imp"
if (PR != 6) goto L_05E7;
// 6255 TOAR8(R,LONGREAL(ADDR(OPND_D)))
#line 6255 "test-new/nrimp10s-77.imp"
TOAR8(R, *_imp_LONGREAL(_imp_ADDR(/*?*/ &OPND->D)));
// 6256 TOAR8(R+8,0)
#line 6256 "test-new/nrimp10s-77.imp"
TOAR8(R + 8, 0);
// 6257 OPND_XTRA=ADDR(A(R))
#line 6257 "test-new/nrimp10s-77.imp"
OPND->XTRA = _imp_ADDR(/*?*/ &A[R]);
// 6258 OPND_FLAG=3
#line 6258 "test-new/nrimp10s-77.imp"
OPND->FLAG = 3;
// 6259 R=R+16
#line 6259 "test-new/nrimp10s-77.imp"
R = R + 16;
// 6260 %FINISH %ELSE OPND_XTRA=0
#line 6260 "test-new/nrimp10s-77.imp"
goto L_05E8;
#line 6260 "test-new/nrimp10s-77.imp"
L_05E7:;
#line 6260 "test-new/nrimp10s-77.imp"
OPND->XTRA = 0;
#line 6260 "test-new/nrimp10s-77.imp"
L_05E8:;
// 6261 %FINISH
#line 6261 "test-new/nrimp10s-77.imp"
L_05E6:;
// 6262 %FINISH %ELSE %START; ! CODE PLANTING REQRD
#line 6262 "test-new/nrimp10s-77.imp"
goto L_05E9;
#line 6262 "test-new/nrimp10s-77.imp"
L_05E2:;
// 6263 LOAD(OPND,ACCR,2)
#line 6263 "test-new/nrimp10s-77.imp"
LOAD(OPND, 0, 2);
// 6264 %IF TP=1 %THEN PSF1(IMYD,0,1) %ELSE PF1(RMYD,0,PC,SPECIAL CONSTS(1));! REAL ONE=16_41000000
#line 6264 "test-new/nrimp10s-77.imp"
if (TP != 1) goto L_05EA;
#line 6264 "test-new/nrimp10s-77.imp"
PSF1(236, 0, 1);
#line 6264 "test-new/nrimp10s-77.imp"
goto L_05EB;
#line 6264 "test-new/nrimp10s-77.imp"
L_05EA:;
#line 6264 "test-new/nrimp10s-77.imp"
PF1(252, 0, 4, SPECIALCONSTS(1));
#line 6264 "test-new/nrimp10s-77.imp"
L_05EB:;
// 6265 GRUSE(ACCR)=0
#line 6265 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 6266 %FINISH
#line 6266 "test-new/nrimp10s-77.imp"
L_05E9:;
// 6267 OPND_PTYPE=(PR+1)<<4+TP
#line 6267 "test-new/nrimp10s-77.imp"
OPND->PTYPE = (PR + 1 << 4) + TP;
// 6268 %END
#line 6268 "test-new/nrimp10s-77.imp"
return;
#line 6268 "test-new/nrimp10s-77.imp"
} /* end of LENGTHEN */
// 6269 %ROUTINE SHORTEN(%RECORD(RD)%NAME OPND)
#line 6269 "test-new/nrimp10s-77.imp"
void SHORTEN(struct RD * OPND) {
// 6270 !***********************************************************************
// 6271 !* PLANT CODE TO REDUCE ACC SIZE *
// 6272 !***********************************************************************
// 6273 {%RECORDSPEC OPND(RD)
// 6274 %INTEGER TY,PR,F,I,J
#line 6274 "test-new/nrimp10s-77.imp"
int TY;
#line 6274 "test-new/nrimp10s-77.imp"
int PR;
#line 6274 "test-new/nrimp10s-77.imp"
int F;
#line 6274 "test-new/nrimp10s-77.imp"
int I;
#line 6274 "test-new/nrimp10s-77.imp"
int J;
// 6275 TY=OPND_PTYPE&7
#line 6275 "test-new/nrimp10s-77.imp"
TY = OPND->PTYPE & 7;
// 6276 PR=OPND_PTYPE>>4
#line 6276 "test-new/nrimp10s-77.imp"
PR = (unsigned int)OPND->PTYPE >> 4;
// 6277 F=OPND_FLAG
#line 6277 "test-new/nrimp10s-77.imp"
F = OPND->FLAG;
// 6278 %IF F=3 %START; ! LONGLONGREAL CONSTS
#line 6278 "test-new/nrimp10s-77.imp"
if (F != 3) goto L_05EC;
// 6279 %CYCLE I=0,1,3
#line 6279 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, 3 %cycle
#line 6279 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 3;
#line 6279 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, 3");
_control = I = _initial - _increment;
#line 6279 "test-new/nrimp10s-77.imp"
L_05ED:
#line 6279 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 6279 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_05EE;
#line 6279 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 6280 BYTEINTEGER(ADDR(J)+I)=BYTEINTEGER(OPND_XTRA+4+I)
#line 6280 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &J) + I) = *_imp_BYTEINTEGER(OPND->XTRA + 4 + I);
// 6281 %REPEAT
#line 6281 "test-new/nrimp10s-77.imp"
goto L_05ED;
#line 6281 "test-new/nrimp10s-77.imp"
}
#line 6281 "test-new/nrimp10s-77.imp"
L_05EE:;
// 6282 OPND_XTRA=J
#line 6282 "test-new/nrimp10s-77.imp"
OPND->XTRA = J;
// 6283 OPND_FLAG=1; ! CONST NOW IN _D & _XTRA
#line 6283 "test-new/nrimp10s-77.imp"
OPND->FLAG = 1;
// 6284 ->WAYOUT
#line 6284 "test-new/nrimp10s-77.imp"
goto U_1042;
// 6285 %FINISH
#line 6285 "test-new/nrimp10s-77.imp"
L_05EC:;
// 6286 %IF F<=1 %START
#line 6286 "test-new/nrimp10s-77.imp"
if (F > 1) goto L_05F0;
// 6287 %IF TY=2 %THEN ->WAYOUT
#line 6287 "test-new/nrimp10s-77.imp"
if (TY != 2) goto L_05F1;
#line 6287 "test-new/nrimp10s-77.imp"
goto U_1042;
#line 6287 "test-new/nrimp10s-77.imp"
L_05F1:;
// 6288 %IF (OPND_D=0 %AND OPND_XTRA>=0) %OR (OPND_D=-1 %AND OPND_XTRA<0) %THEN OPND_D=OPND_XTRA %AND ->WAYOUT
#line 6288 "test-new/nrimp10s-77.imp"
if (OPND->D != 0) goto L_05F2;
#line 6288 "test-new/nrimp10s-77.imp"
if (OPND->XTRA >= 0) goto L_05EF;
#line 6288 "test-new/nrimp10s-77.imp"
L_05F2:;
#line 6288 "test-new/nrimp10s-77.imp"
if (OPND->D != -1) goto L_05F3;
#line 6288 "test-new/nrimp10s-77.imp"
if (OPND->XTRA >= 0) goto L_05F3;
#line 6288 "test-new/nrimp10s-77.imp"
L_05EF:;
#line 6288 "test-new/nrimp10s-77.imp"
OPND->D = OPND->XTRA;
#line 6288 "test-new/nrimp10s-77.imp"
goto U_1042;
#line 6288 "test-new/nrimp10s-77.imp"
L_05F3:;
// 6289 %FINISH
#line 6289 "test-new/nrimp10s-77.imp"
L_05F0:;
// 6290 LOAD(OPND,ACCR,2)
#line 6290 "test-new/nrimp10s-77.imp"
LOAD(OPND, 0, 2);
// 6291 %IF PR=7 %THEN %START; ! SHORTEN QUAD
#line 6291 "test-new/nrimp10s-77.imp"
if (PR != 7) goto L_05F4;
// 6292 PF1(RDDV,0,PC,SPECIAL CONSTS(1))
#line 6292 "test-new/nrimp10s-77.imp"
PF1(190, 0, 4, SPECIALCONSTS(1));
// 6293 %FINISH %ELSE %START
#line 6293 "test-new/nrimp10s-77.imp"
goto L_05F5;
#line 6293 "test-new/nrimp10s-77.imp"
L_05F4:;
// 6294 %IF TYPE=1=PARMARR %THEN PSF1(ISH,0,32)
#line 6294 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 1 (Part I)
#line 6294 "test-new/nrimp10s-77.imp"
int tmp;
#line 6294 "test-new/nrimp10s-77.imp"
if (TYPE != (tmp = 1)) goto L_05F6;
// Double-sided test on 1 (Part II)
#line 6294 "test-new/nrimp10s-77.imp"
if (tmp != PARMARR) goto L_05F6;
#line 6294 "test-new/nrimp10s-77.imp"
}
#line 6294 "test-new/nrimp10s-77.imp"
PSF1(232, 0, 32);
#line 6294 "test-new/nrimp10s-77.imp"
L_05F6:;
// 6295 PSF1(USH,0,-32) %IF PARMARR=1 %OR TYPE#1
#line 6295 "test-new/nrimp10s-77.imp"
if (PARMARR == 1) goto L_05F7;
#line 6295 "test-new/nrimp10s-77.imp"
if (TYPE == 1) goto L_05F8;
#line 6295 "test-new/nrimp10s-77.imp"
L_05F7:;
#line 6295 "test-new/nrimp10s-77.imp"
PSF1(200, 0, -32);
#line 6295 "test-new/nrimp10s-77.imp"
L_05F8:;
// 6296 %IF REGISTER(BREG)=0 %THEN PF1(STUH,0,BREG,0) %AND GRUSE(BREG)=0 %ELSE PSF1(MPSR,0,17);! ACS TO 1 WORD
#line 6296 "test-new/nrimp10s-77.imp"
if (REGISTER[7] != 0) goto L_05F9;
#line 6296 "test-new/nrimp10s-77.imp"
PF1(74, 0, 7, 0);
#line 6296 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
#line 6296 "test-new/nrimp10s-77.imp"
goto L_05FA;
#line 6296 "test-new/nrimp10s-77.imp"
L_05F9:;
#line 6296 "test-new/nrimp10s-77.imp"
PSF1(50, 0, 17);
#line 6296 "test-new/nrimp10s-77.imp"
L_05FA:;
// 6297 %FINISH
#line 6297 "test-new/nrimp10s-77.imp"
L_05F5:;
// 6298 GRUSE(ACCR)=0
#line 6298 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 6299 WAYOUT:
#line 6299 "test-new/nrimp10s-77.imp"
U_1042:;
// 6300 OPND_PTYPE=(PR-1)<<4+TY
#line 6300 "test-new/nrimp10s-77.imp"
OPND->PTYPE = (PR - 1 << 4) + TY;
// 6301 %END
#line 6301 "test-new/nrimp10s-77.imp"
return;
#line 6301 "test-new/nrimp10s-77.imp"
} /* end of SHORTEN */
// 6302 %ROUTINE EXTRACT(%RECORD(RD)%NAME OPND,%LONGINTEGERNAME VAL,{%LONG}%LONGREALNAME RVAL)
#line 6302 "test-new/nrimp10s-77.imp"
void EXTRACT(struct RD * OPND, long int *VAL, double *RVAL) {
// 6303 !***********************************************************************
// 6304 !* EXTRACTS A CONTANT OPERAND RETURNING REAL &INT VALUES *
// 6305 !***********************************************************************
// 6306 {%RECORDSPEC OPND(RD)
// 6307 %INTEGER TYPE,PREC,S,I,AD
#line 6307 "test-new/nrimp10s-77.imp"
int TYPE;
#line 6307 "test-new/nrimp10s-77.imp"
int PREC;
#line 6307 "test-new/nrimp10s-77.imp"
int S;
#line 6307 "test-new/nrimp10s-77.imp"
int I;
#line 6307 "test-new/nrimp10s-77.imp"
int AD;
// 6308 TYPE=OPND_PTYPE; PREC=TYPE>>4
#line 6308 "test-new/nrimp10s-77.imp"
TYPE = OPND->PTYPE;
#line 6308 "test-new/nrimp10s-77.imp"
PREC = (unsigned int)TYPE >> 4;
// 6309 TYPE=TYPE&15
#line 6309 "test-new/nrimp10s-77.imp"
TYPE = TYPE & 15;
// 6310 %IF TYPE=1 %THEN %START
#line 6310 "test-new/nrimp10s-77.imp"
if (TYPE != 1) goto L_05FB;
// 6311 %IF PREC<=5 %THEN VAL=OPND_D %ELSE %START
#line 6311 "test-new/nrimp10s-77.imp"
if (PREC > 5) goto L_05FC;
#line 6311 "test-new/nrimp10s-77.imp"
*VAL = OPND->D;
#line 6311 "test-new/nrimp10s-77.imp"
goto L_05FD;
#line 6311 "test-new/nrimp10s-77.imp"
L_05FC:;
// 6312 INTEGER(ADDR(VAL))=OPND_D
#line 6312 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(VAL)) = OPND->D;
// 6313 INTEGER(ADDR(VAL)+4)=OPND_XTRA
#line 6313 "test-new/nrimp10s-77.imp"
*_imp_INTEGER(_imp_ADDR(VAL) + 4) = OPND->XTRA;
// 6314 %FINISH
#line 6314 "test-new/nrimp10s-77.imp"
L_05FD:;
// 6315 RVAL=VAL
#line 6315 "test-new/nrimp10s-77.imp"
*RVAL = *VAL;
// 6316 %FINISH %ELSE %START
#line 6316 "test-new/nrimp10s-77.imp"
goto L_05FE;
#line 6316 "test-new/nrimp10s-77.imp"
L_05FB:;
// 6317 RVAL=0
#line 6317 "test-new/nrimp10s-77.imp"
*RVAL = 0;
// 6318 %IF PREC=7 %THEN S=15 %AND AD=OPND_XTRA %ELSE S=7 %AND AD=ADDR(OPND_D)
#line 6318 "test-new/nrimp10s-77.imp"
if (PREC != 7) goto L_05FF;
#line 6318 "test-new/nrimp10s-77.imp"
S = 15;
#line 6318 "test-new/nrimp10s-77.imp"
AD = OPND->XTRA;
#line 6318 "test-new/nrimp10s-77.imp"
goto L_0600;
#line 6318 "test-new/nrimp10s-77.imp"
L_05FF:;
#line 6318 "test-new/nrimp10s-77.imp"
S = 7;
#line 6318 "test-new/nrimp10s-77.imp"
AD = _imp_ADDR(/*?*/ &OPND->D);
#line 6318 "test-new/nrimp10s-77.imp"
L_0600:;
// 6319 %CYCLE I=0,1,S
#line 6319 "test-new/nrimp10s-77.imp"
// %for I = 0, 1, S %cycle
#line 6319 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = S;
#line 6319 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 0, 1, S");
_control = I = _initial - _increment;
#line 6319 "test-new/nrimp10s-77.imp"
L_0601:
#line 6319 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 6319 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_0602;
#line 6319 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 6320 BYTEINTEGER(ADDR(RVAL)+I)=BYTEINTEGER(AD+I)
#line 6320 "test-new/nrimp10s-77.imp"
*_imp_BYTEINTEGER(_imp_ADDR(RVAL) + I) = *_imp_BYTEINTEGER(AD + I);
// 6321 %REPEAT
#line 6321 "test-new/nrimp10s-77.imp"
goto L_0601;
#line 6321 "test-new/nrimp10s-77.imp"
}
#line 6321 "test-new/nrimp10s-77.imp"
L_0602:;
// 6322 %FINISH
#line 6322 "test-new/nrimp10s-77.imp"
L_05FE:;
// 6323 %END
#line 6323 "test-new/nrimp10s-77.imp"
return;
#line 6323 "test-new/nrimp10s-77.imp"
} /* end of EXTRACT */
// 6324
// 6325 %ROUTINE VMY1
#line 6325 "test-new/nrimp10s-77.imp"
void VMY1(void) {
// 6326 !***********************************************************************
// 6327 !* DOES VECTOR MULTIPLIES FOR ONE DIMENSION ARRAYS *
// 6328 !***********************************************************************
// 6329 %INTEGER OPNAME,VUSE,DVPOS,DVNAME,X,Y,DTYPE,DPREC,DACC,DPTYPE
#line 6329 "test-new/nrimp10s-77.imp"
int OPNAME;
#line 6329 "test-new/nrimp10s-77.imp"
int VUSE;
#line 6329 "test-new/nrimp10s-77.imp"
int DVPOS;
#line 6329 "test-new/nrimp10s-77.imp"
int DVNAME;
#line 6329 "test-new/nrimp10s-77.imp"
int X;
#line 6329 "test-new/nrimp10s-77.imp"
int Y;
#line 6329 "test-new/nrimp10s-77.imp"
int DTYPE;
#line 6329 "test-new/nrimp10s-77.imp"
int DPREC;
#line 6329 "test-new/nrimp10s-77.imp"
int DACC;
#line 6329 "test-new/nrimp10s-77.imp"
int DPTYPE;
// 6330 DPTYPE=XTRA>>16
#line 6330 "test-new/nrimp10s-77.imp"
DPTYPE = (unsigned int)XTRA >> 16;
// 6331 DVNAME=XTRA&16_FFFF
#line 6331 "test-new/nrimp10s-77.imp"
DVNAME = XTRA & 65535;
// 6332 DVPOS=OPND2_D&16_FFFF
#line 6332 "test-new/nrimp10s-77.imp"
DVPOS = OPND2->D & 65535;
// 6333 %IF DVPOS>0 %AND OPND1_FLAG<=1 %START;! CONST ITEM & DV FOLD IT
#line 6333 "test-new/nrimp10s-77.imp"
if (DVPOS <= 0) goto L_0604;
#line 6333 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG > 1) goto L_0604;
// 6334 X=OPND1_D
#line 6334 "test-new/nrimp10s-77.imp"
X = OPND1->D;
// 6335 X=X-CTABLE_val(DVPOS+3)
#line 6335 "test-new/nrimp10s-77.imp"
X = X - CTABLE->VAL[DVPOS + 3];
// 6336 X=X*CTABLE_val(DVPOS+4)
#line 6336 "test-new/nrimp10s-77.imp"
X = X * CTABLE->VAL[DVPOS + 4];
// 6337 %IF X<0 %OR X>=CTABLE_val(DVPOS+5) %THEN FAULT2(50,X,DVNAME)
#line 6337 "test-new/nrimp10s-77.imp"
if (X < 0) goto L_0603;
#line 6337 "test-new/nrimp10s-77.imp"
if (X < CTABLE->VAL[DVPOS + 5]) goto L_0605;
#line 6337 "test-new/nrimp10s-77.imp"
L_0603:;
#line 6337 "test-new/nrimp10s-77.imp"
FAULT2(50, X, DVNAME);
#line 6337 "test-new/nrimp10s-77.imp"
L_0605:;
// 6338 !
// 6339 ! IF ARRAY BASE HAS BEEN SHIFTED TO ZERO ELEMENT PUT BACK THE LB CORRN
// 6340 ! NOW THE BOUND CHECK HAS BEEN COMPUTED
// 6341 !
// 6342 %IF PARMARR=0=PARMCHK %AND DPTYPE&16_C0F<=3 %THEN X=X+CTABLE_val(DVPOS+3)*CTABLE_val(DVPOS+4)
#line 6342 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 6342 "test-new/nrimp10s-77.imp"
int tmp;
#line 6342 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_0606;
// Double-sided test on 0 (Part II)
#line 6342 "test-new/nrimp10s-77.imp"
if (tmp != PARMCHK) goto L_0606;
#line 6342 "test-new/nrimp10s-77.imp"
}
#line 6342 "test-new/nrimp10s-77.imp"
if (DPTYPE & 3087 > 3) goto L_0606;
#line 6342 "test-new/nrimp10s-77.imp"
X = X + CTABLE->VAL[DVPOS + 3] * CTABLE->VAL[DVPOS + 4];
#line 6342 "test-new/nrimp10s-77.imp"
L_0606:;
// 6343 OPND1_D=X
#line 6343 "test-new/nrimp10s-77.imp"
OPND1->D = X;
// 6344 %RETURN
#line 6344 "test-new/nrimp10s-77.imp"
return;
// 6345 %FINISH
#line 6345 "test-new/nrimp10s-77.imp"
L_0604:;
// 6346 OPNAME=-1
#line 6346 "test-new/nrimp10s-77.imp"
OPNAME = -1;
// 6347 %IF OPND1_FLAG=2 %THEN OPNAME=OPND1_XTRA
#line 6347 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 2) goto L_0607;
#line 6347 "test-new/nrimp10s-77.imp"
OPNAME = OPND1->XTRA;
#line 6347 "test-new/nrimp10s-77.imp"
L_0607:;
// 6348 VUSE=DVNAME!OPNAME<<16
#line 6348 "test-new/nrimp10s-77.imp"
VUSE = DVNAME | OPNAME << 16;
// 6349 %IF OPNAME>=0 %AND GRUSE(BREG)=14 %AND GRINF1(BREG)= VUSE %THEN ->DONE
#line 6349 "test-new/nrimp10s-77.imp"
if (OPNAME < 0) goto L_0608;
#line 6349 "test-new/nrimp10s-77.imp"
if (GRUSE[7] != 14) goto L_0608;
#line 6349 "test-new/nrimp10s-77.imp"
if (GRINF1[7] != VUSE) goto L_0608;
#line 6349 "test-new/nrimp10s-77.imp"
goto U_1046;
#line 6349 "test-new/nrimp10s-77.imp"
L_0608:;
// 6350 %IF PARMARR=0=PARMCHK %AND DVPOS>0 %START
#line 6350 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 6350 "test-new/nrimp10s-77.imp"
int tmp;
#line 6350 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_0609;
// Double-sided test on 0 (Part II)
#line 6350 "test-new/nrimp10s-77.imp"
if (tmp != PARMCHK) goto L_0609;
#line 6350 "test-new/nrimp10s-77.imp"
}
#line 6350 "test-new/nrimp10s-77.imp"
if (DVPOS <= 0) goto L_0609;
// 6351 LOAD(OPND1,BREG,2)
#line 6351 "test-new/nrimp10s-77.imp"
LOAD(OPND1, 7, 2);
// 6352 X=CTABLE_val(DVPOS+4)
#line 6352 "test-new/nrimp10s-77.imp"
X = CTABLE->VAL[DVPOS + 4];
// 6353 %IF X#1 %THEN PSF1(MYB,0,X) %AND GRUSE(BREG)=0
#line 6353 "test-new/nrimp10s-77.imp"
if (X == 1) goto L_060A;
#line 6353 "test-new/nrimp10s-77.imp"
PSF1(42, 0, X);
#line 6353 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
#line 6353 "test-new/nrimp10s-77.imp"
L_060A:;
// 6354 Y=X*CTABLE_val(DVPOS+3)
#line 6354 "test-new/nrimp10s-77.imp"
Y = X * CTABLE->VAL[DVPOS + 3];
// 6355 %IF DPTYPE&16_C0F<=3 %THEN %START
#line 6355 "test-new/nrimp10s-77.imp"
if (DPTYPE & 3087 > 3) goto L_060B;
// 6356 %IF X#1 %THEN ->DONE
#line 6356 "test-new/nrimp10s-77.imp"
if (X == 1) goto L_060C;
#line 6356 "test-new/nrimp10s-77.imp"
goto U_1046;
#line 6356 "test-new/nrimp10s-77.imp"
L_060C:;
// 6357 ->OUT
#line 6357 "test-new/nrimp10s-77.imp"
goto U_1047;
// 6358 %FINISH
#line 6358 "test-new/nrimp10s-77.imp"
L_060B:;
// 6359 ! TEST NAM=0 WHEN ZERO ADJSTD
// 6360 %IF Y#0 %THEN PSF1(SBB,0,Y) %AND GRUSE(BREG)=0
#line 6360 "test-new/nrimp10s-77.imp"
if (Y == 0) goto L_060D;
#line 6360 "test-new/nrimp10s-77.imp"
PSF1(34, 0, Y);
#line 6360 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
#line 6360 "test-new/nrimp10s-77.imp"
L_060D:;
// 6361 ->DONE
#line 6361 "test-new/nrimp10s-77.imp"
goto U_1046;
// 6362 %FINISH
#line 6362 "test-new/nrimp10s-77.imp"
L_0609:;
// 6363 %IF PARMARR=0=PARMCHK %AND (DPTYPE&16_300=16_200 %OR DPTYPE&16_C0F<=3 %OR COMPILER#0)%START;! IE ARR=2 OR NAM=0
#line 6363 "test-new/nrimp10s-77.imp"
{
// Double-sided test on 0 (Part I)
#line 6363 "test-new/nrimp10s-77.imp"
int tmp;
#line 6363 "test-new/nrimp10s-77.imp"
if (PARMARR != (tmp = 0)) goto L_060E;
// Double-sided test on 0 (Part II)
#line 6363 "test-new/nrimp10s-77.imp"
if (tmp != PARMCHK) goto L_060E;
#line 6363 "test-new/nrimp10s-77.imp"
}
#line 6363 "test-new/nrimp10s-77.imp"
if (DPTYPE & 768 == 512) goto L_060F;
#line 6363 "test-new/nrimp10s-77.imp"
if (DPTYPE & 3087 <= 3) goto L_060F;
#line 6363 "test-new/nrimp10s-77.imp"
if (COMPILER == 0) goto L_060E;
#line 6363 "test-new/nrimp10s-77.imp"
L_060F:;
// 6364 DTYPE=DPTYPE&15; DPREC=DPTYPE>>4&7
#line 6364 "test-new/nrimp10s-77.imp"
DTYPE = DPTYPE & 15;
#line 6364 "test-new/nrimp10s-77.imp"
DPREC = (unsigned int)DPTYPE >> 4 & 7;
// 6365 LOAD (OPND1,BREG,2) %UNLESS OPND1_FLAG<=1
#line 6365 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG <= 1) goto L_0610;
#line 6365 "test-new/nrimp10s-77.imp"
LOAD(OPND1, 7, 2);
#line 6365 "test-new/nrimp10s-77.imp"
L_0610:;
// 6366 %IF DTYPE>=3 %OR DPREC=4 %THEN %START
#line 6366 "test-new/nrimp10s-77.imp"
if (DTYPE >= 3) goto L_0611;
#line 6366 "test-new/nrimp10s-77.imp"
if (DPREC != 4) goto L_0612;
#line 6366 "test-new/nrimp10s-77.imp"
L_0611:;
// 6367 DACC=LIST_S3; ! PUT THERE BY CANAME
#line 6367 "test-new/nrimp10s-77.imp"
DACC = LIST->S3;
// 6368 %IF OPND1_FLAG<=1 %THEN OPND1_D=OPND1_D*DACC %AND %RETURN
#line 6368 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG > 1) goto L_0613;
#line 6368 "test-new/nrimp10s-77.imp"
OPND1->D = OPND1->D * DACC;
#line 6368 "test-new/nrimp10s-77.imp"
return;
#line 6368 "test-new/nrimp10s-77.imp"
L_0613:;
// 6369 PSF1(MYB,0,DACC) %UNLESS DACC=1
#line 6369 "test-new/nrimp10s-77.imp"
if (DACC == 1) goto L_0614;
#line 6369 "test-new/nrimp10s-77.imp"
PSF1(42, 0, DACC);
#line 6369 "test-new/nrimp10s-77.imp"
L_0614:;
// 6370 GRUSE(BREG)=0
#line 6370 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 6371 ->DONE
#line 6371 "test-new/nrimp10s-77.imp"
goto U_1046;
// 6372 %FINISH
#line 6372 "test-new/nrimp10s-77.imp"
L_0612:;
// 6373 %IF OPND1_FLAG<=1 %THEN %RETURN
#line 6373 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG > 1) goto L_0615;
#line 6373 "test-new/nrimp10s-77.imp"
return;
#line 6373 "test-new/nrimp10s-77.imp"
L_0615:;
// 6374 LOADREG=BREG; ->OUT
#line 6374 "test-new/nrimp10s-77.imp"
LOADREG = 7;
#line 6374 "test-new/nrimp10s-77.imp"
goto U_1047;
// 6375 %FINISH
#line 6375 "test-new/nrimp10s-77.imp"
L_060E:;
// 6376 %IF OPND1_FLAG=9 %AND OPND1_XB>>4=ACCR %THEN %START
#line 6376 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 9) goto L_0616;
#line 6376 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->XB >> 4 != 0) goto L_0616;
// 6377 PF1(ST,0,TOS,0); ! ACC CANNOT BE USED IN DVM
#line 6377 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 6378 CHANGE RD(ACCR)
#line 6378 "test-new/nrimp10s-77.imp"
CHANGERD(0);
// 6379 REGISTER(ACCR)=0
#line 6379 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 6380 %FINISH
#line 6380 "test-new/nrimp10s-77.imp"
L_0616:;
// 6381 !
// 6382 BASE=OPND2_XTRA>>18; AREA=-1
#line 6382 "test-new/nrimp10s-77.imp"
BASE = (unsigned int)OPND2->XTRA >> 18;
#line 6382 "test-new/nrimp10s-77.imp"
AREA = -1;
// 6383 GET IN ACC(DR,2,0,AREA CODE,OPND2_XTRA&16_1FFFF+8)
#line 6383 "test-new/nrimp10s-77.imp"
GETINACC(1, 2, 0, AREACODE(), (OPND2->XTRA & 131071) + 8);
// 6384 !
// 6385 LOAD(OPND1,EVALREG,0)
#line 6385 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 0);
// 6386 %IF OPND1_PTYPE>>4>=6 %THEN FAULT(24,0)
#line 6386 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->PTYPE >> 4 < 6) goto L_0617;
#line 6386 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 6386 "test-new/nrimp10s-77.imp"
L_0617:;
// 6387 %IF REGISTER(BREG)>=1 %AND (OPND1_FLAG#9 %OR OPND1_XB>>4#BREG) %THEN %START
#line 6387 "test-new/nrimp10s-77.imp"
if (REGISTER[7] < 1) goto L_0618;
#line 6387 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 9) goto L_0619;
#line 6387 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->XB >> 4 == 7) goto L_0618;
#line 6387 "test-new/nrimp10s-77.imp"
L_0619:;
// 6388 OPND==RECORD(OLINK(BREG))
#line 6388 "test-new/nrimp10s-77.imp"
OPND = (struct RD *)_imp_RECORD(OLINK[7]);
// 6389 OPND_D=0
#line 6389 "test-new/nrimp10s-77.imp"
OPND->D = 0;
// 6390 REGISTER(BREG)=2
#line 6390 "test-new/nrimp10s-77.imp"
REGISTER[7] = 2;
// 6391 BOOT OUT(BREG)
#line 6391 "test-new/nrimp10s-77.imp"
BOOTOUT(7);
// 6392 %FINISH
#line 6392 "test-new/nrimp10s-77.imp"
L_0618:;
// 6393 AREA=OPND1_XB>>4; ACCESS=OPND1_XB&15
#line 6393 "test-new/nrimp10s-77.imp"
AREA = (unsigned int)OPND1->XB >> 4;
#line 6393 "test-new/nrimp10s-77.imp"
ACCESS = OPND1->XB & 15;
// 6394 PSORLF1(OPCODE>>8,ACCESS,AREA,OPND1_D)
#line 6394 "test-new/nrimp10s-77.imp"
PSORLF1((unsigned int)OPCODE >> 8, ACCESS, AREA, OPND1->D);
// 6395 GRUSE(BREG)=0
#line 6395 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 6396 DONE:
#line 6396 "test-new/nrimp10s-77.imp"
U_1046:;
// 6397 %IF OPNAME>=0 %THEN %START
#line 6397 "test-new/nrimp10s-77.imp"
if (OPNAME < 0) goto L_061A;
// 6398 GRUSE(BREG)=14
#line 6398 "test-new/nrimp10s-77.imp"
GRUSE[7] = 14;
// 6399 GRINF1(BREG)=VUSE
#line 6399 "test-new/nrimp10s-77.imp"
GRINF1[7] = VUSE;
// 6400 GRINF2(BREG)=0
#line 6400 "test-new/nrimp10s-77.imp"
GRINF2[7] = 0;
// 6401 %FINISH
#line 6401 "test-new/nrimp10s-77.imp"
L_061A:;
// 6402 OUT:
#line 6402 "test-new/nrimp10s-77.imp"
U_1047:;
// 6403 LOADREG=BREG
#line 6403 "test-new/nrimp10s-77.imp"
LOADREG = 7;
// 6404 REGISTER(LOADREG)=1
#line 6404 "test-new/nrimp10s-77.imp"
REGISTER[LOADREG] = 1;
// 6405 OPND1_FLAG=9; OPND1_XB=LOADREG<<4
#line 6405 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 9;
#line 6405 "test-new/nrimp10s-77.imp"
OPND1->XB = LOADREG << 4;
// 6406 %END
#line 6406 "test-new/nrimp10s-77.imp"
return;
#line 6406 "test-new/nrimp10s-77.imp"
} /* end of VMY1 */
// 6407 %ROUTINE VMY
#line 6407 "test-new/nrimp10s-77.imp"
void VMY(void) {
// 6408 !***********************************************************************
// 6409 !* DOES ALL VECTOR MULTIPLIES EXCEPT ONE DIMENSION *
// 6410 !***********************************************************************
// 6411 %IF OPND1_FLAG=9 %AND OPND1_XB>>4=ACCR %THEN %START
#line 6411 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 9) goto L_061B;
#line 6411 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->XB >> 4 != 0) goto L_061B;
// 6412 PF1(ST,0,TOS,0); ! ACC CANNOT BE USED IN DVM
#line 6412 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 6413 CHANGE RD(ACCR)
#line 6413 "test-new/nrimp10s-77.imp"
CHANGERD(0);
// 6414 REGISTER(ACCR)=0
#line 6414 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 6415 %FINISH
#line 6415 "test-new/nrimp10s-77.imp"
L_061B:;
// 6416 !
// 6417 %IF C=D %THEN %START; ! TOP DIMENSION LOAD DV DES
#line 6417 "test-new/nrimp10s-77.imp"
if (C != D) goto L_061C;
// 6418 BASE=OPND2_XTRA>>18; AREA=-1
#line 6418 "test-new/nrimp10s-77.imp"
BASE = (unsigned int)OPND2->XTRA >> 18;
#line 6418 "test-new/nrimp10s-77.imp"
AREA = -1;
// 6419 GET IN ACC(DR,2,0,AREA CODE,OPND2_XTRA&16_1FFFF+8)
#line 6419 "test-new/nrimp10s-77.imp"
GETINACC(1, 2, 0, AREACODE(), (OPND2->XTRA & 131071) + 8);
// 6420 %FINISH
#line 6420 "test-new/nrimp10s-77.imp"
L_061C:;
// 6421 !
// 6422 LOAD(OPND1,EVALREG,0)
#line 6422 "test-new/nrimp10s-77.imp"
LOAD(OPND1, EVALREG, 0);
// 6423 %IF OPND1_PTYPE>>4>=6 %THEN FAULT(24,0)
#line 6423 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->PTYPE >> 4 < 6) goto L_061D;
#line 6423 "test-new/nrimp10s-77.imp"
FAULT(24, 0);
#line 6423 "test-new/nrimp10s-77.imp"
L_061D:;
// 6424 %IF C=D %AND REGISTER(BREG)>=1 %AND (OPND1_FLAG#9 %OR OPND1_XB>>4#BREG) %THEN %START
#line 6424 "test-new/nrimp10s-77.imp"
if (C != D) goto L_061E;
#line 6424 "test-new/nrimp10s-77.imp"
if (REGISTER[7] < 1) goto L_061E;
#line 6424 "test-new/nrimp10s-77.imp"
if (OPND1->FLAG != 9) goto L_061F;
#line 6424 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND1->XB >> 4 == 7) goto L_061E;
#line 6424 "test-new/nrimp10s-77.imp"
L_061F:;
// 6425 OPND==RECORD(OLINK(BREG))
#line 6425 "test-new/nrimp10s-77.imp"
OPND = (struct RD *)_imp_RECORD(OLINK[7]);
// 6426 OPND_D=0
#line 6426 "test-new/nrimp10s-77.imp"
OPND->D = 0;
// 6427 REGISTER(BREG)=2
#line 6427 "test-new/nrimp10s-77.imp"
REGISTER[7] = 2;
// 6428 BOOT OUT(BREG)
#line 6428 "test-new/nrimp10s-77.imp"
BOOTOUT(7);
// 6429 %FINISH
#line 6429 "test-new/nrimp10s-77.imp"
L_061E:;
// 6430 AREA=OPND1_XB>>4; ACCESS=OPND1_XB&15
#line 6430 "test-new/nrimp10s-77.imp"
AREA = (unsigned int)OPND1->XB >> 4;
#line 6430 "test-new/nrimp10s-77.imp"
ACCESS = OPND1->XB & 15;
// 6431 PSORLF1(OPCODE>>8,ACCESS,AREA,OPND1_D)
#line 6431 "test-new/nrimp10s-77.imp"
PSORLF1((unsigned int)OPCODE >> 8, ACCESS, AREA, OPND1->D);
// 6432 GRUSE(BREG)=0
#line 6432 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 6433 !
// 6434 LOADREG=ACCR
#line 6434 "test-new/nrimp10s-77.imp"
LOADREG = 0;
// 6435 %IF C=D %THEN GET IN ACC(ACCR,1,0,7,0) %ELSE PF1(IAD,0,BREG,0)
#line 6435 "test-new/nrimp10s-77.imp"
if (C != D) goto L_0620;
#line 6435 "test-new/nrimp10s-77.imp"
GETINACC(0, 1, 0, 7, 0);
#line 6435 "test-new/nrimp10s-77.imp"
goto L_0621;
#line 6435 "test-new/nrimp10s-77.imp"
L_0620:;
#line 6435 "test-new/nrimp10s-77.imp"
PF1(224, 0, 7, 0);
#line 6435 "test-new/nrimp10s-77.imp"
L_0621:;
// 6436 %IF C=1 %THEN %START
#line 6436 "test-new/nrimp10s-77.imp"
if (C != 1) goto L_0622;
// 6437 PF1(ST,0,BREG,0)
#line 6437 "test-new/nrimp10s-77.imp"
PF1(72, 0, 7, 0);
// 6438 REGISTER(ACCR)=0
#line 6438 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 6439 LOADREG=BREG
#line 6439 "test-new/nrimp10s-77.imp"
LOADREG = 7;
// 6440 %FINISH
#line 6440 "test-new/nrimp10s-77.imp"
L_0622:;
// 6441 REGISTER(LOADREG)=1
#line 6441 "test-new/nrimp10s-77.imp"
REGISTER[LOADREG] = 1;
// 6442 OPND1_FLAG=9; OPND1_XB=LOADREG<<4
#line 6442 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 9;
#line 6442 "test-new/nrimp10s-77.imp"
OPND1->XB = LOADREG << 4;
// 6443 %END
#line 6443 "test-new/nrimp10s-77.imp"
return;
#line 6443 "test-new/nrimp10s-77.imp"
} /* end of VMY */
// 6444 %ROUTINE CTOP(%INTEGERNAME FLAG)
#line 6444 "test-new/nrimp10s-77.imp"
void CTOP(int *FLAG) {
// 6445 !***********************************************************************
// 6446 !* AN OPERATION HAS BEEN FOUND WHERE BOTH OPERANDS ARE CONSTANTS *
// 6447 !* THIS ROUTINE ATTEMPTS TO INTERPRET THIS OPERATION IF IT *
// 6448 !* CAN BE DONE SAFELY *
// 6449 !* ON EXIT FLAG=0 %IF OPERATION CARRIED OUT *
// 6450 !***********************************************************************
// 6451 %CONSTINTEGER TRUNCMASK=16_01300800
// 6452 %INTEGER K,TYPEP,PRECP,OP,TYPEPP,VAL,SVAL1,SVAL2
#line 6452 "test-new/nrimp10s-77.imp"
int K;
#line 6452 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 6452 "test-new/nrimp10s-77.imp"
int PRECP;
#line 6452 "test-new/nrimp10s-77.imp"
int OP;
#line 6452 "test-new/nrimp10s-77.imp"
int TYPEPP;
#line 6452 "test-new/nrimp10s-77.imp"
int VAL;
#line 6452 "test-new/nrimp10s-77.imp"
int SVAL1;
#line 6452 "test-new/nrimp10s-77.imp"
int SVAL2;
// 6453 %LONGINTEGER VAL1,VAL2
#line 6453 "test-new/nrimp10s-77.imp"
long int VAL1;
#line 6453 "test-new/nrimp10s-77.imp"
long int VAL2;
// 6454 {%LONG}%LONGREAL RVAL1,RVAL2
#line 6454 "test-new/nrimp10s-77.imp"
double RVAL1;
#line 6454 "test-new/nrimp10s-77.imp"
double RVAL2;
// 6455 %SWITCH ISW,RSW(10:32)
#line 6455 "test-new/nrimp10s-77.imp"
int ISW_index;
#line 6455 "test-new/nrimp10s-77.imp"
int ISW_line;
#line 6455 "test-new/nrimp10s-77.imp"
char *ISW_file;
#line 6455 "test-new/nrimp10s-77.imp"
static const void *ISW[23] = {
&&case_ISW_10, &&case_ISW_11, &&case_ISW_12, &&case_ISW_13, &&case_ISW_14,
&&case_ISW_missing, &&case_ISW_missing, &&case_ISW_missing, &&case_ISW_missing, &&case_ISW_missing,
&&case_ISW_20, &&case_ISW_21, &&case_ISW_22, &&case_ISW_23, &&case_ISW_24,
&&case_ISW_25, &&case_ISW_26, &&case_ISW_27, &&case_ISW_28, &&case_ISW_29,
&&case_ISW_30, &&case_ISW_31, &&case_ISW_32};
#line 6455 "test-new/nrimp10s-77.imp"
int RSW_index;
#line 6455 "test-new/nrimp10s-77.imp"
int RSW_line;
#line 6455 "test-new/nrimp10s-77.imp"
char *RSW_file;
#line 6455 "test-new/nrimp10s-77.imp"
static const void *RSW[23] = {
&&case_RSW_missing, &&case_RSW_11, &&case_RSW_12, &&case_RSW_13, &&case_RSW_14,
&&case_RSW_missing, &&case_RSW_missing, &&case_RSW_missing, &&case_RSW_missing, &&case_RSW_missing,
&&case_RSW_20, &&case_RSW_21, &&case_RSW_22, &&case_RSW_23, &&case_RSW_24,
&&case_RSW_25, &&case_RSW_26, &&case_RSW_27, &&case_RSW_28, &&case_RSW_29,
&&case_RSW_missing, &&case_RSW_31, &&case_RSW_32};
// 6456 %ON %EVENT 1,2 %START
#line 6456 "test-new/nrimp10s-77.imp"
if (!_imp_on_event(1, 2)) goto L_0623;
// 6457 %RETURN
#line 6457 "test-new/nrimp10s-77.imp"
return;
// 6458 %FINISH
#line 6458 "test-new/nrimp10s-77.imp"
L_0623:;
// 6459 TYPEP=TYPE; PRECP=PTYPE>>4&15; OP=FLAG
#line 6459 "test-new/nrimp10s-77.imp"
TYPEP = TYPE;
#line 6459 "test-new/nrimp10s-77.imp"
PRECP = (unsigned int)PTYPE >> 4 & 15;
#line 6459 "test-new/nrimp10s-77.imp"
OP = *FLAG;
// 6460 EXTRACT(OPND1,VAL1,RVAL1)
#line 6460 "test-new/nrimp10s-77.imp"
EXTRACT(OPND1, /*?*/ &VAL1, /*?*/ &RVAL1);
// 6461 EXTRACT(OPND2,VAL2,RVAL2)
#line 6461 "test-new/nrimp10s-77.imp"
EXTRACT(OPND2, /*?*/ &VAL2, /*?*/ &RVAL2);
// 6462 SVAL1<-VAL1; SVAL2<-VAL2
#line 6462 "test-new/nrimp10s-77.imp"
SVAL1 = (int)(VAL1);
#line 6462 "test-new/nrimp10s-77.imp"
SVAL2 = (int)(VAL2);
// 6463 %IF TYPEP=1 %AND OP=37 %THEN ->ISW37
#line 6463 "test-new/nrimp10s-77.imp"
if (TYPEP != 1) goto L_0624;
#line 6463 "test-new/nrimp10s-77.imp"
if (OP != 37) goto L_0624;
#line 6463 "test-new/nrimp10s-77.imp"
goto U_1048;
#line 6463 "test-new/nrimp10s-77.imp"
L_0624:;
// 6464 %RETURN %IF OP>32
#line 6464 "test-new/nrimp10s-77.imp"
if (OP <= 32) goto L_0625;
#line 6464 "test-new/nrimp10s-77.imp"
return;
#line 6464 "test-new/nrimp10s-77.imp"
L_0625:;
// 6465 %IF TYPEP=2 %THEN ->RSW(OP) %ELSE ->ISW(OP)
#line 6465 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_0626;
#line 6465 "test-new/nrimp10s-77.imp"
RSW_line = __LINE__;
RSW_file = __FILE__;
RSW_index = OP;
goto case_RSW_dispatch;
#line 6465 "test-new/nrimp10s-77.imp"
L_0626:;
#line 6465 "test-new/nrimp10s-77.imp"
ISW_line = __LINE__;
ISW_file = __FILE__;
ISW_index = OP;
goto case_ISW_dispatch;
// 6466 ISW(10): ! \
#line 6466 "test-new/nrimp10s-77.imp"
case_ISW_10:;
// 6467 VAL1=\VAL1
#line 6467 "test-new/nrimp10s-77.imp"
VAL1 = (~VAL1);
// 6468 INTEND:
#line 6468 "test-new/nrimp10s-77.imp"
U_1049:;
// 6469 %IF PRECP=6 %THEN %START
#line 6469 "test-new/nrimp10s-77.imp"
if (PRECP != 6) goto L_0629;
// 6470 OPND1_D<-VAL1>>32
#line 6470 "test-new/nrimp10s-77.imp"
OPND1->D = (int)((unsigned int)VAL1 >> 32);
// 6471 OPND1_XTRA<-VAL1
#line 6471 "test-new/nrimp10s-77.imp"
OPND1->XTRA = (int)(VAL1);
// 6472 FLAG=0
#line 6472 "test-new/nrimp10s-77.imp"
*FLAG = 0;
// 6473 %FINISH %ELSE %START
#line 6473 "test-new/nrimp10s-77.imp"
goto L_062A;
#line 6473 "test-new/nrimp10s-77.imp"
L_0629:;
// 6474 VAL<-VAL1
#line 6474 "test-new/nrimp10s-77.imp"
VAL = (int)(VAL1);
// 6475 %IF VAL=VAL1 %OR 1<<OP&TRUNCMASK=0 %THEN FLAG=0 %AND OPND1_D=VAL;! NO ARITH OFLOW CONDITION
#line 6475 "test-new/nrimp10s-77.imp"
if (VAL == VAL1) goto L_062B;
#line 6475 "test-new/nrimp10s-77.imp"
if (1 << OP & 19924992 != 0) goto L_062C;
#line 6475 "test-new/nrimp10s-77.imp"
L_062B:;
#line 6475 "test-new/nrimp10s-77.imp"
*FLAG = 0;
#line 6475 "test-new/nrimp10s-77.imp"
OPND1->D = VAL;
#line 6475 "test-new/nrimp10s-77.imp"
L_062C:;
// 6476 %FINISH
#line 6476 "test-new/nrimp10s-77.imp"
L_062A:;
// 6477 %IF FLAG=0 %START
#line 6477 "test-new/nrimp10s-77.imp"
if (*FLAG != 0) goto L_062D;
// 6478 OPND1_PTYPE=PRECP<<4!1
#line 6478 "test-new/nrimp10s-77.imp"
OPND1->PTYPE = PRECP << 4 | 1;
// 6479 %IF 16_FFFE0000<=VAL1<=16_1FFFF %THEN OPND1_FLAG=0 %ELSE OPND1_FLAG=1
#line 6479 "test-new/nrimp10s-77.imp"
{
// Double-sided test on VAL1 (Part I)
#line 6479 "test-new/nrimp10s-77.imp"
long long int tmp;
#line 6479 "test-new/nrimp10s-77.imp"
if (-131072 > (tmp = VAL1)) goto L_062E;
// Double-sided test on VAL1 (Part II)
#line 6479 "test-new/nrimp10s-77.imp"
if (tmp > 131071) goto L_062E;
#line 6479 "test-new/nrimp10s-77.imp"
}
#line 6479 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 0;
#line 6479 "test-new/nrimp10s-77.imp"
goto L_062F;
#line 6479 "test-new/nrimp10s-77.imp"
L_062E:;
#line 6479 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 1;
#line 6479 "test-new/nrimp10s-77.imp"
L_062F:;
// 6480 %FINISH
#line 6480 "test-new/nrimp10s-77.imp"
L_062D:;
// 6481 %RETURN
#line 6481 "test-new/nrimp10s-77.imp"
return;
// 6482 ISW(11): ! INTEGER NEGATE
#line 6482 "test-new/nrimp10s-77.imp"
case_ISW_11:;
// 6483 VAL1=-VAL1; -> INT END
#line 6483 "test-new/nrimp10s-77.imp"
VAL1 = -VAL1;
#line 6483 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6484 ISW(13): ! INTEGER ABS
#line 6484 "test-new/nrimp10s-77.imp"
case_ISW_13:;
// 6485 VAL1=IMOD(VAL1); -> INT END
#line 6485 "test-new/nrimp10s-77.imp"
VAL1 = IMOD(VAL1);
#line 6485 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6486 ISW(12): ! INTEGER FLOAT
#line 6486 "test-new/nrimp10s-77.imp"
case_ISW_12:;
// 6487 RVAL1=VAL1; PRECP=5+XTRA
#line 6487 "test-new/nrimp10s-77.imp"
RVAL1 = VAL1;
#line 6487 "test-new/nrimp10s-77.imp"
PRECP = 5 + XTRA;
// 6488 ->REAL END
#line 6488 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6489 RSW(14): ! STRETCH REAL
#line 6489 "test-new/nrimp10s-77.imp"
case_RSW_14:;
// 6490 PRECP=PRECP+1
#line 6490 "test-new/nrimp10s-77.imp"
PRECP = PRECP + 1;
// 6491 REAL END:OPND1_FLAG=1
#line 6491 "test-new/nrimp10s-77.imp"
U_104A:;
#line 6491 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 1;
// 6492 OPND1_D=INTEGER(ADDR(RVAL1))
#line 6492 "test-new/nrimp10s-77.imp"
OPND1->D = *_imp_INTEGER(_imp_ADDR(/*?*/ &RVAL1));
// 6493 OPND1_XTRA=INTEGER(ADDR(RVAL1)+4)
#line 6493 "test-new/nrimp10s-77.imp"
OPND1->XTRA = *_imp_INTEGER(_imp_ADDR(/*?*/ &RVAL1) + 4);
// 6494 %IF PRECP=7 %THEN %START
#line 6494 "test-new/nrimp10s-77.imp"
if (PRECP != 7) goto L_0630;
// 6495 OPND1_FLAG=3
#line 6495 "test-new/nrimp10s-77.imp"
OPND1->FLAG = 3;
// 6496 OPND1_XTRA=ADDR(A(R))
#line 6496 "test-new/nrimp10s-77.imp"
OPND1->XTRA = _imp_ADDR(/*?*/ &A[R]);
// 6497 %CYCLE K=0,1,15
#line 6497 "test-new/nrimp10s-77.imp"
// %for K = 0, 1, 15 %cycle
#line 6497 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 0, _increment = 1, _final = 15;
#line 6497 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle K = 0, 1, 15");
_control = K = _initial - _increment;
#line 6497 "test-new/nrimp10s-77.imp"
L_0631:
#line 6497 "test-new/nrimp10s-77.imp"
if (K != _control) _imp_signal(4, 2, 0, "Corrupt control variable K");
#line 6497 "test-new/nrimp10s-77.imp"
if (K == _final) goto L_0632;
#line 6497 "test-new/nrimp10s-77.imp"
_control += _increment;
K += _increment;
// 6498 A(R)=BYTEINTEGER(ADDR(RVAL1)+K)
#line 6498 "test-new/nrimp10s-77.imp"
A[R] = *_imp_BYTEINTEGER(_imp_ADDR(/*?*/ &RVAL1) + K);
// 6499 R=R+1
#line 6499 "test-new/nrimp10s-77.imp"
R = R + 1;
// 6500 %REPEAT
#line 6500 "test-new/nrimp10s-77.imp"
goto L_0631;
#line 6500 "test-new/nrimp10s-77.imp"
}
#line 6500 "test-new/nrimp10s-77.imp"
L_0632:;
// 6501 %FINISH
#line 6501 "test-new/nrimp10s-77.imp"
L_0630:;
// 6502 FLAG=0; OPND1_PTYPE=16*PRECP+2
#line 6502 "test-new/nrimp10s-77.imp"
*FLAG = 0;
#line 6502 "test-new/nrimp10s-77.imp"
OPND1->PTYPE = 16 * PRECP + 2;
// 6503 %RETURN
#line 6503 "test-new/nrimp10s-77.imp"
return;
// 6504 ISW(14): ! STRETCH INTEGER
#line 6504 "test-new/nrimp10s-77.imp"
case_ISW_14:;
// 6505 RSW(12): ! FLOAT REAL
#line 6505 "test-new/nrimp10s-77.imp"
case_RSW_12:;
// 6506 ABORT
#line 6506 "test-new/nrimp10s-77.imp"
ABORT();
// 6507 ISW(20): ! ADD
#line 6507 "test-new/nrimp10s-77.imp"
case_ISW_20:;
// 6508 VAL1=VAL1+VAL2; -> INT END
#line 6508 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 + VAL2;
#line 6508 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6509 ISW(21): ! MINUS
#line 6509 "test-new/nrimp10s-77.imp"
case_ISW_21:;
// 6510 VAL1=VAL1-VAL2; -> INT END
#line 6510 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 - VAL2;
#line 6510 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6511 ISW(22): ! EXCLUSIVE OR
#line 6511 "test-new/nrimp10s-77.imp"
case_ISW_22:;
// 6512 VAL1=VAL1!!VAL2; -> INT END
#line 6512 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 ^ VAL2;
#line 6512 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6513 ISW(23): ! OR
#line 6513 "test-new/nrimp10s-77.imp"
case_ISW_23:;
// 6514 VAL1=VAL1!VAL2; -> INT END
#line 6514 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 | VAL2;
#line 6514 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6515 ISW(24): ! MULT
#line 6515 "test-new/nrimp10s-77.imp"
case_ISW_24:;
// 6516 VAL1=VAL1*VAL2; -> INT END
#line 6516 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 * VAL2;
#line 6516 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6517 ISW(26): %RETURN; ! / DIVISION
#line 6517 "test-new/nrimp10s-77.imp"
case_ISW_26:;
#line 6517 "test-new/nrimp10s-77.imp"
return;
// 6518 ISW(25): %RETURN %IF VAL2=0; ! // DIVISION
#line 6518 "test-new/nrimp10s-77.imp"
case_ISW_25:;
#line 6518 "test-new/nrimp10s-77.imp"
if (VAL2 != 0) goto L_0634;
#line 6518 "test-new/nrimp10s-77.imp"
return;
#line 6518 "test-new/nrimp10s-77.imp"
L_0634:;
// 6519 VAL1=VAL1//VAL2; -> INT END
#line 6519 "test-new/nrimp10s-77.imp"
VAL1 = ((long)VAL1 / (long)VAL2);
#line 6519 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6520 ISW(27): ! AND
#line 6520 "test-new/nrimp10s-77.imp"
case_ISW_27:;
// 6521 VAL1=VAL1&VAL2; -> INT END
#line 6521 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 & VAL2;
#line 6521 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6522 ISW(29): ! SLL
#line 6522 "test-new/nrimp10s-77.imp"
case_ISW_29:;
// 6523 %IF PRECP=6 %THEN VAL1=VAL1<<SVAL2 %ELSE VAL1=SVAL1<<SVAL2
#line 6523 "test-new/nrimp10s-77.imp"
if (PRECP != 6) goto L_0635;
#line 6523 "test-new/nrimp10s-77.imp"
VAL1 = VAL1 << SVAL2;
#line 6523 "test-new/nrimp10s-77.imp"
goto L_0636;
#line 6523 "test-new/nrimp10s-77.imp"
L_0635:;
#line 6523 "test-new/nrimp10s-77.imp"
VAL1 = SVAL1 << SVAL2;
#line 6523 "test-new/nrimp10s-77.imp"
L_0636:;
// 6524 ->INT END
#line 6524 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6525 ISW(28): ! SRL
#line 6525 "test-new/nrimp10s-77.imp"
case_ISW_28:;
// 6526 %IF PRECP=6 %THEN VAL1=VAL1>>SVAL2 %ELSE VAL1=SVAL1>>SVAL2
#line 6526 "test-new/nrimp10s-77.imp"
if (PRECP != 6) goto L_0637;
#line 6526 "test-new/nrimp10s-77.imp"
VAL1 = (unsigned int)VAL1 >> SVAL2;
#line 6526 "test-new/nrimp10s-77.imp"
goto L_0638;
#line 6526 "test-new/nrimp10s-77.imp"
L_0637:;
#line 6526 "test-new/nrimp10s-77.imp"
VAL1 = (unsigned int)SVAL1 >> SVAL2;
#line 6526 "test-new/nrimp10s-77.imp"
L_0638:;
// 6527 ->INT END
#line 6527 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6528
// 6529 ISW(31):ISW(32): ! COMPARISONS
#line 6529 "test-new/nrimp10s-77.imp"
case_ISW_31:;
#line 6529 "test-new/nrimp10s-77.imp"
case_ISW_32:;
// 6530 RSW(31):RSW(32): ! REAL COMPARISONS
#line 6530 "test-new/nrimp10s-77.imp"
case_RSW_31:;
#line 6530 "test-new/nrimp10s-77.imp"
case_RSW_32:;
// 6531 BFFLAG=COMM-1
#line 6531 "test-new/nrimp10s-77.imp"
BFFLAG = COMM - 1;
// 6532 MASK=FCOMP(XTRA+7*BFFLAG)
#line 6532 "test-new/nrimp10s-77.imp"
MASK = FCOMP[XTRA + 7 * BFFLAG - 1];
// 6533 COMM=2; FLAG=0
#line 6533 "test-new/nrimp10s-77.imp"
COMM = 2;
#line 6533 "test-new/nrimp10s-77.imp"
*FLAG = 0;
// 6534 %IF TYPE=2 %THEN ->RCOMP
#line 6534 "test-new/nrimp10s-77.imp"
if (TYPE != 2) goto L_0639;
#line 6534 "test-new/nrimp10s-77.imp"
goto U_104B;
#line 6534 "test-new/nrimp10s-77.imp"
L_0639:;
// 6535 %IF (MASK&8#0 %AND VAL1=VAL2) %OR (MASK&4#0 %AND VAL1<VAL2) %OR (MASK&2#0 %AND VAL1>VAL2) %THEN MASK=15 %ELSE MASK=0
#line 6535 "test-new/nrimp10s-77.imp"
if (MASK & 8 == 0) goto L_063A;
#line 6535 "test-new/nrimp10s-77.imp"
if (VAL1 == VAL2) goto L_063B;
#line 6535 "test-new/nrimp10s-77.imp"
L_063A:;
#line 6535 "test-new/nrimp10s-77.imp"
if (MASK & 4 == 0) goto L_063C;
#line 6535 "test-new/nrimp10s-77.imp"
if (VAL1 < VAL2) goto L_063B;
#line 6535 "test-new/nrimp10s-77.imp"
L_063C:;
#line 6535 "test-new/nrimp10s-77.imp"
if (MASK & 2 == 0) goto L_063D;
#line 6535 "test-new/nrimp10s-77.imp"
if (VAL1 <= VAL2) goto L_063D;
#line 6535 "test-new/nrimp10s-77.imp"
L_063B:;
#line 6535 "test-new/nrimp10s-77.imp"
MASK = 15;
#line 6535 "test-new/nrimp10s-77.imp"
goto L_063E;
#line 6535 "test-new/nrimp10s-77.imp"
L_063D:;
#line 6535 "test-new/nrimp10s-77.imp"
MASK = 0;
#line 6535 "test-new/nrimp10s-77.imp"
L_063E:;
// 6536 %RETURN
#line 6536 "test-new/nrimp10s-77.imp"
return;
// 6537 RCOMP:
#line 6537 "test-new/nrimp10s-77.imp"
U_104B:;
// 6538 %IF (MASK&8#0 %AND RVAL1=RVAL2) %OR (MASK&4#0 %AND RVAL1<RVAL2) %OR (MASK&2#0 %AND RVAL1>RVAL2) %THEN MASK=15 %ELSE MASK=0
#line 6538 "test-new/nrimp10s-77.imp"
if (MASK & 8 == 0) goto L_063F;
#line 6538 "test-new/nrimp10s-77.imp"
if (RVAL1 == RVAL2) goto L_0640;
#line 6538 "test-new/nrimp10s-77.imp"
L_063F:;
#line 6538 "test-new/nrimp10s-77.imp"
if (MASK & 4 == 0) goto L_0641;
#line 6538 "test-new/nrimp10s-77.imp"
if (RVAL1 < RVAL2) goto L_0640;
#line 6538 "test-new/nrimp10s-77.imp"
L_0641:;
#line 6538 "test-new/nrimp10s-77.imp"
if (MASK & 2 == 0) goto L_0642;
#line 6538 "test-new/nrimp10s-77.imp"
if (RVAL1 <= RVAL2) goto L_0642;
#line 6538 "test-new/nrimp10s-77.imp"
L_0640:;
#line 6538 "test-new/nrimp10s-77.imp"
MASK = 15;
#line 6538 "test-new/nrimp10s-77.imp"
goto L_0643;
#line 6538 "test-new/nrimp10s-77.imp"
L_0642:;
#line 6538 "test-new/nrimp10s-77.imp"
MASK = 0;
#line 6538 "test-new/nrimp10s-77.imp"
L_0643:;
// 6539 %RETURN
#line 6539 "test-new/nrimp10s-77.imp"
return;
// 6540 RSW(11): ! NEGATE
#line 6540 "test-new/nrimp10s-77.imp"
case_RSW_11:;
// 6541 RVAL1=-RVAL1; -> REAL END
#line 6541 "test-new/nrimp10s-77.imp"
RVAL1 = -RVAL1;
#line 6541 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6542 RSW(13): ! ABS
#line 6542 "test-new/nrimp10s-77.imp"
case_RSW_13:;
// 6543 RVAL1=MOD(RVAL1); -> REAL END
#line 6543 "test-new/nrimp10s-77.imp"
RVAL1 = MOD(RVAL1);
#line 6543 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6544 RSW(20): ! ADD
#line 6544 "test-new/nrimp10s-77.imp"
case_RSW_20:;
// 6545 RVAL1=RVAL1+RVAL2; -> REAL END
#line 6545 "test-new/nrimp10s-77.imp"
RVAL1 = RVAL1 + RVAL2;
#line 6545 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6546 RSW(21): ! SUBTRACT
#line 6546 "test-new/nrimp10s-77.imp"
case_RSW_21:;
// 6547 RVAL1=RVAL1-RVAL2; -> REAL END
#line 6547 "test-new/nrimp10s-77.imp"
RVAL1 = RVAL1 - RVAL2;
#line 6547 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6548 RSW(24): ! MULT
#line 6548 "test-new/nrimp10s-77.imp"
case_RSW_24:;
// 6549 RVAL1=RVAL1*RVAL2; -> REAL END
#line 6549 "test-new/nrimp10s-77.imp"
RVAL1 = RVAL1 * RVAL2;
#line 6549 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6550 RSW(26): ! DIVISION
#line 6550 "test-new/nrimp10s-77.imp"
case_RSW_26:;
// 6551 %RETURN %IF RVAL2=0; ! AVOID DIV BY ZERO
#line 6551 "test-new/nrimp10s-77.imp"
if (RVAL2 != 0) goto L_0644;
#line 6551 "test-new/nrimp10s-77.imp"
return;
#line 6551 "test-new/nrimp10s-77.imp"
L_0644:;
// 6552 RVAL1=RVAL1/RVAL2; -> REAL END
#line 6552 "test-new/nrimp10s-77.imp"
RVAL1 = (double)(RVAL1 / RVAL2);
#line 6552 "test-new/nrimp10s-77.imp"
goto U_104A;
// 6553 ISW(30): ! '**' WITH 2 INTEGER OPERANDS
#line 6553 "test-new/nrimp10s-77.imp"
case_ISW_30:;
// 6554 ISW37: ! '****' WITH 2 INTEGER OPERAND
#line 6554 "test-new/nrimp10s-77.imp"
U_1048:;
// 6555 %RETURN %UNLESS 0<=VAL2<=63
#line 6555 "test-new/nrimp10s-77.imp"
{
// Double-sided test on VAL2 (Part I)
#line 6555 "test-new/nrimp10s-77.imp"
long long int tmp;
#line 6555 "test-new/nrimp10s-77.imp"
if (0 > (tmp = VAL2)) goto L_0645;
// Double-sided test on VAL2 (Part II)
#line 6555 "test-new/nrimp10s-77.imp"
if (tmp <= 63) goto L_0646;
#line 6555 "test-new/nrimp10s-77.imp"
}
#line 6555 "test-new/nrimp10s-77.imp"
L_0645:;
#line 6555 "test-new/nrimp10s-77.imp"
return;
#line 6555 "test-new/nrimp10s-77.imp"
L_0646:;
// 6556 VAL2=1
#line 6556 "test-new/nrimp10s-77.imp"
VAL2 = 1;
// 6557 %WHILE SVAL2>0 %CYCLE
#line 6557 "test-new/nrimp10s-77.imp"
L_0647:;
#line 6557 "test-new/nrimp10s-77.imp"
if (SVAL2 <= 0) goto L_0648;
// 6558 VAL2=VAL2*VAL1
#line 6558 "test-new/nrimp10s-77.imp"
VAL2 = VAL2 * VAL1;
// 6559 SVAL2=SVAL2-1
#line 6559 "test-new/nrimp10s-77.imp"
SVAL2 = SVAL2 - 1;
// 6560 %RETURN %IF VAL2#INTEGER(ADDR(VAL2)+4)
#line 6560 "test-new/nrimp10s-77.imp"
if (VAL2 == *_imp_INTEGER(_imp_ADDR(/*?*/ &VAL2) + 4)) goto L_0649;
#line 6560 "test-new/nrimp10s-77.imp"
return;
#line 6560 "test-new/nrimp10s-77.imp"
L_0649:;
// 6561 %REPEAT
#line 6561 "test-new/nrimp10s-77.imp"
goto L_0647;
#line 6561 "test-new/nrimp10s-77.imp"
L_0648:;
// 6562 VAL1=VAL2; ->INT END
#line 6562 "test-new/nrimp10s-77.imp"
VAL1 = VAL2;
#line 6562 "test-new/nrimp10s-77.imp"
goto U_1049;
// 6563 RSW(22):RSW(23):
#line 6563 "test-new/nrimp10s-77.imp"
case_RSW_22:;
#line 6563 "test-new/nrimp10s-77.imp"
case_RSW_23:;
// 6564 RSW(25):RSW(27):RSW(28):RSW(29):
#line 6564 "test-new/nrimp10s-77.imp"
case_RSW_25:;
#line 6564 "test-new/nrimp10s-77.imp"
case_RSW_27:;
#line 6564 "test-new/nrimp10s-77.imp"
case_RSW_28:;
#line 6564 "test-new/nrimp10s-77.imp"
case_RSW_29:;
// 6565 %END
#line 6565 "test-new/nrimp10s-77.imp"
return;
#line 6565 "test-new/nrimp10s-77.imp"
case_ISW_dispatch:
#line 6565 "test-new/nrimp10s-77.imp"
if (ISW_index < 10 || ISW_index > 32)
_imp_signalf(6, 3, ISW_index, "->ISW(%d) out of bounds at %s line %d", ISW_index, ISW_file, ISW_line);
#line 6565 "test-new/nrimp10s-77.imp"
goto *ISW[ISW_index - 10];
#line 6565 "test-new/nrimp10s-77.imp"
case_ISW_missing:
_imp_signalf(8, 2, ISW_index, "switch jump to undefined label ISW(%d): at %s line %d", ISW_index, ISW_file,
ISW_line);
#line 6565 "test-new/nrimp10s-77.imp"
case_RSW_dispatch:
#line 6565 "test-new/nrimp10s-77.imp"
if (RSW_index < 10 || RSW_index > 32)
_imp_signalf(6, 3, RSW_index, "->RSW(%d) out of bounds at %s line %d", RSW_index, RSW_file, RSW_line);
#line 6565 "test-new/nrimp10s-77.imp"
goto *RSW[RSW_index - 10];
#line 6565 "test-new/nrimp10s-77.imp"
case_RSW_missing:
_imp_signalf(8, 2, RSW_index, "switch jump to undefined label RSW(%d): at %s line %d", RSW_index, RSW_file,
RSW_line);
#line 6565 "test-new/nrimp10s-77.imp"
} /* end of CTOP */
// ?TYPEPP unused
// 6566 %ROUTINE REXP
#line 6566 "test-new/nrimp10s-77.imp"
void REXP(void) {
// 6567 !***********************************************************************
// 6568 !* CALLS A PERM ROUTINE TO PERFORM REAL**REAL *
// 6569 !***********************************************************************
// 6570 %INTEGER I,PR
#line 6570 "test-new/nrimp10s-77.imp"
int I;
#line 6570 "test-new/nrimp10s-77.imp"
int PR;
// 6571 %RECORD(RD)%NAME OPND{(RD)
#line 6571 "test-new/nrimp10s-77.imp"
struct RD *OPND;
// 6572 %IF REGISTER(BREG)>0 %THEN BOOT OUT(BREG)
#line 6572 "test-new/nrimp10s-77.imp"
if (REGISTER[7] <= 0) goto L_064A;
#line 6572 "test-new/nrimp10s-77.imp"
BOOTOUT(7);
#line 6572 "test-new/nrimp10s-77.imp"
L_064A:;
// 6573 %CYCLE I=1,1,2
#line 6573 "test-new/nrimp10s-77.imp"
// %for I = 1, 1, 2 %cycle
#line 6573 "test-new/nrimp10s-77.imp"
{
int _control, _initial = 1, _increment = 1, _final = 2;
#line 6573 "test-new/nrimp10s-77.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle I = 1, 1, 2");
_control = I = _initial - _increment;
#line 6573 "test-new/nrimp10s-77.imp"
L_064B:
#line 6573 "test-new/nrimp10s-77.imp"
if (I != _control) _imp_signal(4, 2, 0, "Corrupt control variable I");
#line 6573 "test-new/nrimp10s-77.imp"
if (I == _final) goto L_064C;
#line 6573 "test-new/nrimp10s-77.imp"
_control += _increment;
I += _increment;
// 6574 OPND==RECORD(OPERAND(I))
#line 6574 "test-new/nrimp10s-77.imp"
OPND = (struct RD *)_imp_RECORD(OPERAND[I - 1]);
// 6575 LOAD(OPND,ACCR,2) %UNLESS I=1 %AND OPND_FLAG=8
#line 6575 "test-new/nrimp10s-77.imp"
if (I != 1) goto L_0633;
#line 6575 "test-new/nrimp10s-77.imp"
if (OPND->FLAG == 8) goto L_064E;
#line 6575 "test-new/nrimp10s-77.imp"
L_0633:;
#line 6575 "test-new/nrimp10s-77.imp"
LOAD(OPND, 0, 2);
#line 6575 "test-new/nrimp10s-77.imp"
L_064E:;
// 6576 PR=OPND_PTYPE>>4
#line 6576 "test-new/nrimp10s-77.imp"
PR = (unsigned int)OPND->PTYPE >> 4;
// 6577 %IF PR<6 %THEN LENGTHEN(OPND)
#line 6577 "test-new/nrimp10s-77.imp"
if (PR >= 6) goto L_064F;
#line 6577 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND);
#line 6577 "test-new/nrimp10s-77.imp"
L_064F:;
// 6578 %IF PR>6 %THEN SHORTEN(OPND)
#line 6578 "test-new/nrimp10s-77.imp"
if (PR <= 6) goto L_0650;
#line 6578 "test-new/nrimp10s-77.imp"
SHORTEN(OPND);
#line 6578 "test-new/nrimp10s-77.imp"
L_0650:;
// 6579 %REPEAT
#line 6579 "test-new/nrimp10s-77.imp"
goto L_064B;
#line 6579 "test-new/nrimp10s-77.imp"
}
#line 6579 "test-new/nrimp10s-77.imp"
L_064C:;
// 6580 PPJ(0,17)
#line 6580 "test-new/nrimp10s-77.imp"
PPJ(0, 17);
// 6581 %END
#line 6581 "test-new/nrimp10s-77.imp"
return;
#line 6581 "test-new/nrimp10s-77.imp"
} /* end of REXP */
// 6582 %ROUTINE STARSTAR
#line 6582 "test-new/nrimp10s-77.imp"
void STARSTAR(void) {
// 6583 !***********************************************************************
// 6584 !* PLANT IN-LINE CODE FOR EXPONENTIATION *
// 6585 !* IMP ALLOWS EXPONENTS IN INTEGER EXPRESSIONS FROM 0-63 AND *
// 6586 !* IN REAL EXPRESSIONS FROM-255 TO +255 *
// 6587 !***********************************************************************
// 6588 %INTEGER TYPEP,PRECP,WORK,C,EXPWORK,VALUE
#line 6588 "test-new/nrimp10s-77.imp"
int TYPEP;
#line 6588 "test-new/nrimp10s-77.imp"
int PRECP;
#line 6588 "test-new/nrimp10s-77.imp"
int WORK;
#line 6588 "test-new/nrimp10s-77.imp"
int C;
#line 6588 "test-new/nrimp10s-77.imp"
int EXPWORK;
#line 6588 "test-new/nrimp10s-77.imp"
int VALUE;
// 6589 PTYPE=OPND1_PTYPE; ! INSPECT THE OPERAND
#line 6589 "test-new/nrimp10s-77.imp"
PTYPE = OPND1->PTYPE;
// 6590 UNPACK
#line 6590 "test-new/nrimp10s-77.imp"
UNPACK();
// 6591 TYPEP=TYPE; PRECP=PREC
#line 6591 "test-new/nrimp10s-77.imp"
TYPEP = TYPE;
#line 6591 "test-new/nrimp10s-77.imp"
PRECP = PREC;
// 6592 %IF TYPEP=2 %THEN OPCODE=16_FA %ELSE OPCODE=16_EA
#line 6592 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_0651;
#line 6592 "test-new/nrimp10s-77.imp"
OPCODE = 250;
#line 6592 "test-new/nrimp10s-77.imp"
goto L_0652;
#line 6592 "test-new/nrimp10s-77.imp"
L_0651:;
#line 6592 "test-new/nrimp10s-77.imp"
OPCODE = 234;
#line 6592 "test-new/nrimp10s-77.imp"
L_0652:;
// 6593 VALUE=0
#line 6593 "test-new/nrimp10s-77.imp"
VALUE = 0;
// 6594 %IF OPND2_FLAG=0 %AND 1<=OPND2_D<=63*TYPE %THEN VALUE=OPND2_D; ! EXPONENT IS #0 AND CONSTANT
#line 6594 "test-new/nrimp10s-77.imp"
if (OPND2->FLAG != 0) goto L_0653;
#line 6594 "test-new/nrimp10s-77.imp"
{
// Double-sided test on OPND2->D (Part I)
#line 6594 "test-new/nrimp10s-77.imp"
int tmp;
#line 6594 "test-new/nrimp10s-77.imp"
if (1 > (tmp = OPND2->D)) goto L_0653;
// Double-sided test on OPND2->D (Part II)
#line 6594 "test-new/nrimp10s-77.imp"
if (tmp > 63 * TYPE) goto L_0653;
#line 6594 "test-new/nrimp10s-77.imp"
}
#line 6594 "test-new/nrimp10s-77.imp"
VALUE = OPND2->D;
#line 6594 "test-new/nrimp10s-77.imp"
L_0653:;
// 6595 LOAD(OPND1,ACCR,2); ! FETCH OPERAND TO ACC
#line 6595 "test-new/nrimp10s-77.imp"
LOAD(OPND1, 0, 2);
// 6596 %IF TYPEP=2 %AND PRECP=5 %THEN LENGTHEN(OPND1) %AND PRECP=6
#line 6596 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_0654;
#line 6596 "test-new/nrimp10s-77.imp"
if (PRECP != 5) goto L_0654;
#line 6596 "test-new/nrimp10s-77.imp"
LENGTHEN(OPND1);
#line 6596 "test-new/nrimp10s-77.imp"
PRECP = 6;
#line 6596 "test-new/nrimp10s-77.imp"
L_0654:;
// 6597 !
// 6598 ! OPTIMISE **2 **3 AND **4
// 6599 !
// 6600 %IF 2<=VALUE<=4 %THEN %START
#line 6600 "test-new/nrimp10s-77.imp"
{
// Double-sided test on VALUE (Part I)
#line 6600 "test-new/nrimp10s-77.imp"
int tmp;
#line 6600 "test-new/nrimp10s-77.imp"
if (2 > (tmp = VALUE)) goto L_0655;
// Double-sided test on VALUE (Part II)
#line 6600 "test-new/nrimp10s-77.imp"
if (tmp > 4) goto L_0655;
#line 6600 "test-new/nrimp10s-77.imp"
}
// 6601 PF1(ST,0,TOS,0)
#line 6601 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
// 6602 %IF VALUE=3 %THEN PF1(ST,0,TOS,0)
#line 6602 "test-new/nrimp10s-77.imp"
if (VALUE != 3) goto L_0656;
#line 6602 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
#line 6602 "test-new/nrimp10s-77.imp"
L_0656:;
// 6603 PF1(OPCODE,0,TOS,0)
#line 6603 "test-new/nrimp10s-77.imp"
PF1(OPCODE, 0, 6, 0);
// 6604 %IF VALUE=4 %THEN PF1(ST,0,TOS,0)
#line 6604 "test-new/nrimp10s-77.imp"
if (VALUE != 4) goto L_0657;
#line 6604 "test-new/nrimp10s-77.imp"
PF1(72, 0, 6, 0);
#line 6604 "test-new/nrimp10s-77.imp"
L_0657:;
// 6605 %IF VALUE>2 %THEN PF1(OPCODE,0,TOS,0)
#line 6605 "test-new/nrimp10s-77.imp"
if (VALUE <= 2) goto L_0658;
#line 6605 "test-new/nrimp10s-77.imp"
PF1(OPCODE, 0, 6, 0);
#line 6605 "test-new/nrimp10s-77.imp"
L_0658:;
// 6606 GRUSE(ACCR)=0
#line 6606 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 6607 %RETURN
#line 6607 "test-new/nrimp10s-77.imp"
return;
// 6608 %FINISH
#line 6608 "test-new/nrimp10s-77.imp"
L_0655:;
// 6609 !
// 6610 ! OTHERWISE STORE OPERAND IN 'WORK' AND GET HOLD OF EXPONENT
// 6611 !
// 6612 GET WSP(WORK,BYTES(PRECP)>>2)
#line 6612 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &WORK, (unsigned int)BYTES[PRECP] >> 2);
// 6613 %IF TYPEP=2 %THEN GET WSP(EXPWORK,1)
#line 6613 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_0659;
#line 6613 "test-new/nrimp10s-77.imp"
GETWSP(/*?*/ &EXPWORK, 1);
#line 6613 "test-new/nrimp10s-77.imp"
L_0659:;
// 6614 PSF1(ST,1,WORK)
#line 6614 "test-new/nrimp10s-77.imp"
PSF1(72, 1, WORK);
// 6615 REGISTER(ACCR)=0
#line 6615 "test-new/nrimp10s-77.imp"
REGISTER[0] = 0;
// 6616 PLABEL=PLABEL-1; ! LABEL FOR JUMPING OUT
#line 6616 "test-new/nrimp10s-77.imp"
PLABEL = PLABEL - 1;
// 6617 %IF OPND2_PTYPE>>4=6 %THEN SHORTEN(OPND2);! LONG EXPONENT
#line 6617 "test-new/nrimp10s-77.imp"
if ((unsigned int)OPND2->PTYPE >> 4 != 6) goto L_065A;
#line 6617 "test-new/nrimp10s-77.imp"
SHORTEN(OPND2);
#line 6617 "test-new/nrimp10s-77.imp"
L_065A:;
// 6618 LOAD(OPND2,BREG,2); ! EXPONENT TO ANY REGISTER
#line 6618 "test-new/nrimp10s-77.imp"
LOAD(OPND2, 7, 2);
// 6619 %IF TYPEP=2 %THEN PSF1(STB,1,EXPWORK)
#line 6619 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_065B;
#line 6619 "test-new/nrimp10s-77.imp"
PSF1(90, 1, EXPWORK);
#line 6619 "test-new/nrimp10s-77.imp"
L_065B:;
// 6620 !
// 6621 ! GET '1' INTO ACC IN APPROPIATE FORM
// 6622 !
// 6623 GET IN ACC(ACCR,BYTES(PRECP+1-TYPEP)>>2,0,0,1)
#line 6623 "test-new/nrimp10s-77.imp"
GETINACC(0, (unsigned int)BYTES[PRECP + 1 - TYPEP] >> 2, 0, 0, 1);
// 6624 %IF TYPEP=2 %THEN PSF1(FLT,0,0)
#line 6624 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_065C;
#line 6624 "test-new/nrimp10s-77.imp"
PSF1(168, 0, 0);
#line 6624 "test-new/nrimp10s-77.imp"
L_065C:;
// 6625 !
// 6626 ! IF EXPONENT NOT KNOWN AT COMPILE TIME TO BE +VE CONSTANT MUST
// 6627 ! ALLOW FOR ZERO :- XX**0=1 FOR ALL XX
// 6628 ! ALSO ALLOW FOR X**(-N) WHICH IS 1/(X**N) FOR ALL X & N
// 6629 !
// 6630 %IF VALUE=0 %THEN %START; ! NOT +VE CONSTANT
#line 6630 "test-new/nrimp10s-77.imp"
if (VALUE != 0) goto L_065D;
// 6631 ENTER JUMP(28,PLABEL,B'11'); ! J(B=0) END OF EXP ROUTINE
#line 6631 "test-new/nrimp10s-77.imp"
ENTERJUMP(28, PLABEL, 3);
// 6632 %IF TYPEP=2 %THEN %START
#line 6632 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_065E;
// 6633 PF3(JAT,13,0,4); ! J*+4 IF B>0
#line 6633 "test-new/nrimp10s-77.imp"
PF3(4, 13, 0, 4);
// 6634 PSF1(SLB,0,0)
#line 6634 "test-new/nrimp10s-77.imp"
PSF1(82, 0, 0);
// 6635 PF1(SBB,0,TOS,0)
#line 6635 "test-new/nrimp10s-77.imp"
PF1(34, 0, 6, 0);
// 6636 %FINISH
#line 6636 "test-new/nrimp10s-77.imp"
L_065E:;
// 6637 !
// 6638 ! IN CHECKING MODE PLANT CODE TO CHECK RANGE OF EXPONENT
// 6639 !
// 6640 %IF PARMOPT=1 %THEN %START
#line 6640 "test-new/nrimp10s-77.imp"
if (PARMOPT != 1) goto L_065F;
// 6641 %IF TYPEP=1 %THEN PPJ(30,7);! JUMP B<0
#line 6641 "test-new/nrimp10s-77.imp"
if (TYPEP != 1) goto L_0660;
#line 6641 "test-new/nrimp10s-77.imp"
PPJ(30, 7);
#line 6641 "test-new/nrimp10s-77.imp"
L_0660:;
// 6642 PSF1(CPB,0,64*TYPEP*TYPEP-1)
#line 6642 "test-new/nrimp10s-77.imp"
PSF1(38, 0, 64 * TYPEP * TYPEP - 1);
// 6643 PPJ(2,7)
#line 6643 "test-new/nrimp10s-77.imp"
PPJ(2, 7);
// 6644 %FINISH
#line 6644 "test-new/nrimp10s-77.imp"
L_065F:;
// 6645 %FINISH
#line 6645 "test-new/nrimp10s-77.imp"
L_065D:;
// 6646 C=CA
#line 6646 "test-new/nrimp10s-77.imp"
C = CA;
// 6647 PSF1(OPCODE,1,WORK)
#line 6647 "test-new/nrimp10s-77.imp"
PSF1(OPCODE, 1, WORK);
// 6648 PSF1(DEBJ,0,(C-CA)//2)
#line 6648 "test-new/nrimp10s-77.imp"
PSF1(36, 0, ((long)(C - CA) / (long)2));
// 6649 !
// 6650 ! FOR REAL EXPONENTS CHECK IF NEGATIVE AND EVALUATE INVERSE
// 6651 !
// 6652 %IF VALUE=0 %AND TYPEP=2 %THEN %START
#line 6652 "test-new/nrimp10s-77.imp"
if (VALUE != 0) goto L_0661;
#line 6652 "test-new/nrimp10s-77.imp"
if (TYPEP != 2) goto L_0661;
// 6653 PSF1(LB,1,EXPWORK); ! LB ON ORIGINAL EXPONENT
#line 6653 "test-new/nrimp10s-77.imp"
PSF1(122, 1, EXPWORK);
// 6654 ENTER JUMP(46,PLABEL,B'11');! BP END OF EXP ROUTINE
#line 6654 "test-new/nrimp10s-77.imp"
ENTERJUMP(46, PLABEL, 3);
// 6655 %IF PRECP<7 %THEN PF1(RRDV,0,PC,SPECIAL CONSTS(1))%ELSESTART
#line 6655 "test-new/nrimp10s-77.imp"
if (PRECP >= 7) goto L_0662;
#line 6655 "test-new/nrimp10s-77.imp"
PF1(188, 0, 4, SPECIALCONSTS(1));
#line 6655 "test-new/nrimp10s-77.imp"
goto L_0663;
#line 6655 "test-new/nrimp10s-77.imp"
L_0662:;
// 6656 PSF1(SLSD,0,1); PSF1(FLT,0,0)
#line 6656 "test-new/nrimp10s-77.imp"
PSF1(68, 0, 1);
#line 6656 "test-new/nrimp10s-77.imp"
PSF1(168, 0, 0);
// 6657 PF1(RDV,0,TOS,0)
#line 6657 "test-new/nrimp10s-77.imp"
PF1(186, 0, 6, 0);
// 6658 %FINISH
#line 6658 "test-new/nrimp10s-77.imp"
L_0663:;
// 6659 %FINISH
#line 6659 "test-new/nrimp10s-77.imp"
L_0661:;
// 6660 !
// 6661 ! ALL OVER. REAL RESULTS ARE IN FR WORK. INT RESULTS IN GR WORK+1
// 6662 ! FREE AND FORGET ANY OTHER REGISTERS
// 6663 !
// 6664 TYPE=TYPEP; PREC=PRECP
#line 6664 "test-new/nrimp10s-77.imp"
TYPE = TYPEP;
#line 6664 "test-new/nrimp10s-77.imp"
PREC = PRECP;
// 6665 REGISTER(BREG)=0
#line 6665 "test-new/nrimp10s-77.imp"
REGISTER[7] = 0;
// 6666 GRUSE(ACCR)=0
#line 6666 "test-new/nrimp10s-77.imp"
GRUSE[0] = 0;
// 6667 GRUSE(BREG)=0
#line 6667 "test-new/nrimp10s-77.imp"
GRUSE[7] = 0;
// 6668 REGISTER(ACCR)=1
#line 6668 "test-new/nrimp10s-77.imp"
REGISTER[0] = 1;
// 6669 OPND1_PTYPE=16*PREC+TYPE
#line 6669 "test-new/nrimp10s-77.imp"
OPND1->PTYPE = 16 * PREC + TYPE;
// 6670 OPND1_XB=0; OPND1_D=ACCR
#line 6670 "test-new/nrimp10s-77.imp"
OPND1->XB = 0;
#line 6670 "test-new/nrimp10s-77.imp"
OPND1->D = 0;
// 6671 C=ENTER LAB(PLABEL,B'11'); ! LABEL AT END OF EXP ROUTINE
#line 6671 "test-new/nrimp10s-77.imp"
C = ENTERLAB(PLABEL, 3);
// 6672 %END
#line 6672 "test-new/nrimp10s-77.imp"
return;
#line 6672 "test-new/nrimp10s-77.imp"
} /* end of STARSTAR */
// 6673 %END; ! OF ROUTINE EXPOP
#line 6673 "test-new/nrimp10s-77.imp"
return;
#line 6673 "test-new/nrimp10s-77.imp"
case_SW_dispatch:
#line 6673 "test-new/nrimp10s-77.imp"
if (SW_index < 10 || SW_index > 37)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 6673 "test-new/nrimp10s-77.imp"
goto *SW[SW_index - 10];
#line 6673 "test-new/nrimp10s-77.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file,
SW_line);
#line 6673 "test-new/nrimp10s-77.imp"
} /* end of EXPOP */
// 6674 %ROUTINE REDUCE ENV(%INTEGERNAME HEAD)
#line 6674 "test-new/nrimp10s-77.imp"
void REDUCEENV(int *HEAD) {
// 6675 !***********************************************************************
// 6676 !* HEAD HAS AN ENVIRONMENT - THIS ROUTINE REMOVES ANYTHING *
// 6677 !* INCOMPATIBLE WITH THE CURRENT REGISTER STATE *
// 6678 !***********************************************************************
// 6679 %INTEGER NEWHEAD,I,J,K,REG,USE
#line 6679 "test-new/nrimp10s-77.imp"
int NEWHEAD;
#line 6679 "test-new/nrimp10s-77.imp"
int I;
#line 6679 "test-new/nrimp10s-77.imp"
int J;
#line 6679 "test-new/nrimp10s-77.imp"
int K;
#line 6679 "test-new/nrimp10s-77.imp"
int REG;
#line 6679 "test-new/nrimp10s-77.imp"
int USE;
// 6680 NEWHEAD=0
#line 6680 "test-new/nrimp10s-77.imp"
NEWHEAD = 0;
// 6681 %WHILE HEAD#0 %CYCLE
#line 6681 "test-new/nrimp10s-77.imp"
L_0664:;
#line 6681 "test-new/nrimp10s-77.imp"
if (*HEAD == 0) goto L_0665;
// 6682 POP(HEAD,I,J,K)
#line 6682 "test-new/nrimp10s-77.imp"
POP(HEAD, /*?*/ &I, /*?*/ &J, /*?*/ &K);
// 6683 REG=K>>8; USE=K&255
#line 6683 "test-new/nrimp10s-77.imp"
REG = (unsigned int)K >> 8;
#line 6683 "test-new/nrimp10s-77.imp"
USE = K & 255;
// 6684 %IF USE=GRUSE(REG)&255 %AND I=GRINF1(REG) %THEN PUSH(NEWHEAD,I,J,K)
#line 6684 "test-new/nrimp10s-77.imp"
if (USE != GRUSE[REG] & 255) goto L_0666;
#line 6684 "test-new/nrimp10s-77.imp"
if (I != GRINF1[REG]) goto L_0666;
#line 6684 "test-new/nrimp10s-77.imp"
PUSH(/*?*/ &NEWHEAD, I, J, K);
#line 6684 "test-new/nrimp10s-77.imp"
L_0666:;
// 6685 %REPEAT
#line 6685 "test-new/nrimp10s-77.imp"
goto L_0664;
#line 6685 "test-new/nrimp10s-77.imp"
L_0665:;
// 6686 HEAD=NEWHEAD
#line 6686 "test-new/nrimp10s-77.imp"
*HEAD = NEWHEAD;
// 6687 %END
#line 6687 "test-new/nrimp10s-77.imp"
return;
#line 6687 "test-new/nrimp10s-77.imp"
} /* end of REDUCEENV */
// 6688 %INTEGERFN CCOND(%INTEGER CTO,IU,FARLAB)
#line 6688 "test-new/nrimp10s-77.imp"
int CCOND(int CTO, int IU, int FARLAB) {
#line 6688 "test-new/nrimp10s-77.imp"
auto void WRITECONDLIST(void);
#line 6688 "test-new/nrimp10s-77.imp"
auto void SKIPSC(int REVERSED);
#line 6688 "test-new/nrimp10s-77.imp"
auto void SKIPCOND(int REVERSED);
#line 6688 "test-new/nrimp10s-77.imp"
auto int CCOMP(void);
#line 6688 "test-new/nrimp10s-77.imp"
auto void JUMP(int MASK, int LAB, int FLAGS);
#line 6688 "test-new/nrimp10s-77.imp"
auto void LABUNUSED(int LAB);
#line 6688 "test-new/nrimp10s-77.imp"
auto void OMITTO(int LAB);
// 6689 !***********************************************************************
// 6690 !* COMPILES <IU><SC><RESTOFCOND>%THEN<UI1>%ELSE<UI2> *
// 6691 !* CTO=0 JUMP TO FARLAB MUST BE PLANTED IF COND UNCONDITIONAL *
// 6692 !* CTO#0 JUMP MAY BE OMITTED *
// 6693 !* IU=1 FOR %IF =2 FOR UNLESS. FARLAB TO GO ON UI2 *
// 6694 !* THE ROUTINE MAKES FOUR PASSES THROUGH THE CONDITION *
// 6695 !* PASS 1 ANALYSES THE STRUCTURE AND DECIDES TO BRANCH ON TRUE *
// 6696 !* (TF=2) OR ON FALSE (TF=1) FOR EACH COMPARISON *
// 6697 !* PASS 2 WORKS OUT WHERE THE BRANCHES OF PASS 1 SHOULD GO TO *
// 6698 !* PASS 3 ASSIGNS LABEL NUMBERS *
// 6699 !* PASS 4 EVALUATES COMPARISIONS AND PLANTS THE CODE *
// 6700 !* *
// 6701 !* ON ENTRY P POINTS TO <SC> IN<HOLE><SC><RESTOFCOND> *
// 6702 !* RESULT=0 CONDITION COMPILED *
// 6703 !* RESULT=1 UNCONDITIONALLY TO 1ST ALTERNATIVE *
// 6704 !* RESULT=2 UNCONDITIONALLY TO 2ND ALTERNATIVE(FARLAB) *
// 6705 !***********************************************************************
// 6706 %ROUTINESPEC WRITE CONDLIST
// 6707 %ROUTINESPEC SKIP SC(%INTEGER REVERSED)
// 6708 %ROUTINESPEC SKIP COND(%INTEGER REVERSED)
// 6709 %INTEGERFNSPEC CCOMP
// 6710 %%ROUTINESPEC JUMP(%INTEGER MASK,LAB,FLAGS)
// 6711 %ROUTINESPEC LAB UNUSED(%INTEGER LAB)
// 6712 %ROUTINESPEC OMIT TO(%INTEGER LAB)
// 6713 !
// 6714 ! FCOMP HAS BC MASKS FOR EACH STRING COMPARATOR.
// 6715 ! THE FIRST 7 ARE TO BRANCH IF TRUE WITH NORMAL COMPARISON
// 6716 ! THE SECOND SEVEN ARE TO BRANCH IF TRUE WITH BACKWARDS COMPARISON
// 6717 !
// 6718 %CONSTBYTEINTEGERARRAY FCOMP(1:21)=8,13,5,7,10,2,7,
#line 6718 "test-new/nrimp10s-77.imp"
const unsigned char FCOMP[21] = {8, 13, 5, 7, 10, 2, 7, 8, 10, 2, 7, 13, 5, 7, 27, 0, 0, 43, 0, 0, 43};
// 6719+ 8,10,2,7,13,5,7,
// 6720+ 27,0,0,43,0,0,43;
// 6721 !
// 6722 %INTEGER PIN,PP,II,L,CPTR,CMAX,LL,BITMASK,LA
#line 6722 "test-new/nrimp10s-77.imp"
int PIN;
#line 6722 "test-new/nrimp10s-77.imp"
int PP;
#line 6722 "test-new/nrimp10s-77.imp"
int II;
#line 6722 "test-new/nrimp10s-77.imp"
int L;
#line 6722 "test-new/nrimp10s-77.imp"
int CPTR;
#line 6722 "test-new/nrimp10s-77.imp"
int CMAX;
#line 6722 "test-new/nrimp10s-77.imp"
int LL;
#line 6722 "test-new/nrimp10s-77.imp"
int BITMASK;
#line 6722 "test-new/nrimp10s-77.imp"
int LA;
// 6723 %RECORDFORMAT CF(%BYTEINTEGER TF,CMP1,CMP2,LABU,LVL,JMP,REV,SP,%INTEGER LABNO,SP1,SP2)
#line 6723 "test-new/nrimp10s-77.imp"
struct CF {
union {
struct {
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char TF;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char CMP1;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char CMP2;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char LABU;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char LVL;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char JMP;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char REV;
#line 6723 "test-new/nrimp10s-77.imp"
unsigned char SP;
#line 6723 "test-new/nrimp10s-77.imp"
int LABNO;
#line 6723 "test-new/nrimp10s-77.imp"
int SP1;
#line 6723 "test-new/nrimp10s-77.imp"
int SP2;
#line 6723 "test-new/nrimp10s-77.imp"
};
};
};
// 6724 %RECORD(CF)%ARRAY CLIST(1:30){(CF)
#line 6724 "test-new/nrimp10s-77.imp"
struct CF CLIST[30];
// 6725 %RECORD(CF)%NAME C1,C2{(CF)
#line 6725 "test-new/nrimp10s-77.imp"
struct CF *C1;
#line 6725 "test-new/nrimp10s-77.imp"
struct CF *C2;
// 6726 !
// 6727 ! PASS 1. ANALYSES THE CONDITION
// 6728 !
// 6729 PIN=P; ! SAVE INITIAL AR POINTER
#line 6729 "test-new/nrimp10s-77.imp"
PIN = P;
// 6730 CPTR=1; L=3; ! LEVEL=3 TO ALLOW 2 LOWER
#line 6730 "test-new/nrimp10s-77.imp"
CPTR = 1;
#line 6730 "test-new/nrimp10s-77.imp"
L = 3;
// 6731 C1==CLIST(CPTR); ! SET UP RECORD FOR FIRST CMPARSN
#line 6731 "test-new/nrimp10s-77.imp"
C1 = (struct CF *)/*?*/ &CLIST[CPTR - 1];
// 6732 C1=0
#line 6732 "test-new/nrimp10s-77.imp"
*C1 = (struct CF){0};
// 6733 SKIP SC(0); ! SKIP THE 1ST CMPARSN
#line 6733 "test-new/nrimp10s-77.imp"
SKIPSC(0);
// 6734 SKIP COND(0); ! AND ANY %AND/%OR CLAUSES
#line 6734 "test-new/nrimp10s-77.imp"
SKIPCOND(0);
// 6735 C1_LVL=2; ! LEVEL =-1 FOR %IF/%THEN ENTRY
#line 6735 "test-new/nrimp10s-77.imp"
C1-