#include <imp_perms.h>

extern void SELECTINPUT(int STREAM);
extern void SELECTOUTPUT(int STREAM);
extern void NEWLINE(void);
extern void SPACE(void);
extern void SKIPSYMBOL(void);
extern void READSTRING(_imp_string *S);
extern void NEWLINES(int N);
extern void SPACES(int N);
extern int NEXTSYMBOL(void);
extern void PRINTSYMBOL(int SYMBOL);
extern void READSYMBOL(void **SYMBOL);
extern void READ(void **NUMBER);
extern void WRITE(int VALUE, int PLACES);
extern void NEWPAGE(void);
extern int ADDR(void **VARIABLE);
extern double ARCSIN(double X);
extern int INT(double X);
extern int INTPT(double X);
extern double FRACPT(double X);
extern void PRINT(double NUMBER, int BEFORE, int AFTER);
extern void PRINTFL(double NUMBER, int PLACES);
extern float *REAL(int VARADDR);
extern int *INTEGER(int VARADDR);
extern double MOD(double X);
extern double ARCCOS(double X);
extern double SQRT(double X);
extern double LOG(double X);
extern double SIN(double X);
extern double COS(double X);
extern double TAN(double X);
extern double EXP(double X);
extern void CLOSESTREAM(int STREAM);
extern char *BYTEINTEGER(int VARADDR);
extern int EVENTINF(void);
extern double RADIUS(double X, double Y);
extern double ARCTAN(double X, double Y);
extern char *LENGTH(_imp_string *S);
extern void PRINTSTRING(_imp_string STR);
extern int NL(void);
extern double *LONGREAL(int VARADDR);
extern void PRINTCH(int CHARACTER);
extern void READCH(void **CHARACTER);
extern _imp_string *STRING(int VARADDR);
extern void READITEM(_imp_string *ITEM);
extern _imp_string NEXTITEM(void);
extern char *CHARNO(_imp_string *STR, int CHARREQD);
extern _imp_string TOSTRING(int CH);
extern _imp_string SUBSTRING(_imp_string STR, int FIRST, int LAST);
// externalrecord(*)mapspecRECORD(integerRECADDR)

// externalarraymapspecARRAY(integerA1ADDR,arraynameFORMAT)

extern int SIZEOF(void **X);
extern int IMOD(int VALUE);
extern double PI(void);
extern int EVENTLINE(void);
extern long int *LONGINTEGER(int ADR);
extern long double *LONGLONGREAL(int ADR);
extern long int LENGTHENI(int VAL);
extern long double LENGTHENR(double VAL);
extern int SHORTENI(long int VAL);
extern double SHORTENR(long double VAL);
extern int NEXTCH(void);
extern unsigned short int *HALFINTEGER(int ADDR);
extern void PPROFILE(void);
extern double FLOAT(int VALUE);
extern long int LINT(long double X);
extern long int LINTPT(long double X);
extern short int *SHORTINTEGER(int N);
extern int TRUNC(double X);
// endoffile

// M'abc'CONSTANTSBELOWUSEDBYINSERT()AREREVERSEDDELIBERATELY

// ITWOULDAPPEAR.IT's not a byte-sex issue, it'SJUSTLAZYCODING.

// NOTE<SQ>ETCINCOMMENTSBELOWISATEMPORARYSTOPGAPUNTIL

// IFIXTHELINERECONSTRUCTION.

//***********************************************************************

//*SOAP80-IMP80FORMATTER*

//*LASTALTERED15/06/83*

//**

//*CREATEDBYE.N.GREGORY,UKC.*

//*ALLSYNTAXDIRECTEDSECTIONSREWRITTENBYP.D.S.,ERCC*

//*USINGIMP80SYNTAXVERSION02.*

//*USERINTERFACEANDPARAMETERSREVISEDBYJ.M.M.,ERCC.*

//**

//***********************************************************************

// WE<SQ>LLNEEDTOSUPPLYSOMELOOKALIKEROUTINESFORTHEVARIOUS

// EMASSYSTEMLIBRARYCALLSBELOW.I<SQ>VECONVERTEDTHEEXTERNALSPECS

// INTOBODIES,BUTHAVEN<SQ>TWRITTENTHEMYET.-GT

extern _imp_string CLIPARAM(void);

void PROMPT(_imp_string *S){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

//***********************************************************************

//**

//*RECORDFORMATS.*

//**

//***********************************************************************

const int MAXOPT = 16;
const int NUMOPT = 3;

//***********************************************************************

//**

//*SYSTEMROUTINES.*

//**

//***********************************************************************

extern _imp_string ITOS(int I);

/*pending name*/

void CONNECT(_imp_string *NAME, int MODE, int HOLE, int PROT, recfm *REC,
             int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

extern void TRIM(_imp_string FILE, int *EFLAG);

void SETFNAME(_imp_string FILE){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

_imp_string NEXTTEMP(void) {
  return "";

  /* End of Begin/Rt/Fn/Map depth=0 */
};

void SENDFILE(_imp_string FILE, _imp_string DEVICE, _imp_string HEADER,
              int COPIES, int FORM, int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

int DEVCODE(_imp_string NAME) {
  return 0;

  /* End of Begin/Rt/Fn/Map depth=0 */
};

void DISCONNECT(_imp_string *FILENAME, int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

_imp_string FAILUREMESSAGE(int TYPE) {
  return "";

  /* End of Begin/Rt/Fn/Map depth=0 */
};

void CHANGEFILESIZE(_imp_string *FILENAME, int FILESIZE, int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

void NEWGEN(_imp_string *FILENAME, _imp_string *NEWFILENAME, int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

void OUTFILE(_imp_string *FILENAME, int SIZE, int HOLE, int PROT, int *CONAD,
             int *EFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

/*pending name*/

void READPROFILE(_imp_string KEY, recfm *INFO, int *VERSION, int *UFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

/*pending name*/

void WRITEPROFILE(_imp_string *KEY, recfm *INFO, int *VERSION, int *UFLAG){

    /* End of Begin/Rt/Fn/Map depth=0 */

};

int _imp_mainep(int _imp_argc, char **_imp_argv) {
  _imp_string S;
  // ARGV[1]

  // externalroutineSOAP80(string(255)S)

  int PTR;
  int DATAEND;
  int INPTR;
  int Z;
  int IN;
  int OBP;
  int EFLAG;
  int WRITEADDRESS;
  int WA0;
  int FILESIZE;
  int CONAD;
  int ERRORS;
  int LINE;
  int ERPTR;
  int STARTLINE;
  int STREAM;
  int FILESIZEPTR;
  int SSALT;
  int STRDELIMITER;
  int STR;
  int SEMICOLON;
  int COLON;
  int MAXPTR;
  int MAXITEM;
  int LEVEL;
  int STOP;
  int INCREM;
  int INLABEL;
  int CHARSIN;
  int ERSAVE;
  int INCONST;
  int BHEADING;
  int INLINE;

  _imp_string OUTF;

  _imp_string WORKFILE;
  _imp_string INFILE;

  _imp_string PERCENTC;

  /*pending name*/

  recfm P;

  /*pending name*/
  /*pending name*/

  recfm REC;
  recfm RR;

  /*pending name*/

  recfm *OUTREC;

  const int CCSIZE = 16384;

  short int OUTBUF[(CCSIZE + 200) - (0) + 1]

      ;

  char SC[(CCSIZE) - (0) + 1]

      ;

  const _imp_string OPTNAME[(MAXOPT) - (1) + 1]

      = "LINE",
      "ICONTIN", "POSCOM", "MOVECOM", "UCKEY", "SEPKEY", "EXPKEY", "LCASNAM",
      "SPACNAM", "SPACASS", "SPACOP", "LCLIST", "IBLOCK", "ISTAT", "SEPLAB",
      "SPCOMMA";

  //! constantstring(255)arrayOPTMESS(0:1,1:MAXOPT)=

  const _imp_string OPTMESS[(33) - (2) + 1]

      = "Line length zero (!!!)",
      "Maximum line length", "Continued lines not indented",
      "Indentation of continued lines", "Right hand comments not positioned",
      "Right hand comment position", "Whole line comments indented normally",
      "Whole line comments moved to POSCOM", "Keywords output in lower case",
      "Keywords output in upper case", "Keywords not split", "Keywords split",
      "%FN, %CONST, %ELSE not expanded",
      "%FN, %CONST, (sometimes) %ELSE expanded",
      "Case of names controlled by UCKEY", "Case of names left alone",
      "Spaces removed from names", "Spaces preserved within names",
      "No spaces round assignment operators",
      "Spaces added round assignment operators", "No spaces round operators",
      "Spaces added round operators", "Constant lists formatted",
      "Constant lists left alone", "Block not indented w.r.t. block heading",
      "Block indented w.r.t. block heading",
      "Statements aligned with declarations",
      "Statements indented w.r.t. declarations",
      "Labels not on lines by themselves", "Labels on lines by themselves",
      "No space character after commas", "Space character after commas";

  const int CHARFILE = 3;
  // CODEFORACHARACTERFILE.

  const int UNDERLINE = 128;

  const int INSTRING = 256;
  const int INCURLY = 512;
  const int BPOINT = 1024;
  const int BPOINT2 = 2048;
  const int TERMINAL = 1;
  const int FILE = 2;
  const int SAMEFILE = 3;
  const int DEVICE = 4;
  const int TRUE = 255;
  // SYNTHETICBOOLEANVALUES.
  const int FALSE = 0;

  const int NL = 10;
  const int DQUOTES = 34;
  const int SQUOTES = 39;
  const int RS = 30;
  // RECORDSEPARATORISUSEDASADELETED(BYc)NL

  const int REM = 0b00000001;

  const int CONSTART = 0b00000010;

  const int QUOTES = 0b00000100;

  const int ENDST = 0b00001000;

  const int NUMBER = 0b00010000;

  const int LETTER = 0b00100000;

  const char CONSTFIRST = 0b01000000;

  const int CONSTCONT = 0b10000000;

  //

  const char ONECASE[(127) - (0) + 1]

      = 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;

  const char CHARTYPE[(255) - (0) + 1]

      = 0b00000001,
      0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000,
      0b00000000, 0b00000000, 0b00000000, 0b00001000,
      [LOW... HIGH] = 0b00000000, 0b00000001, 0b00000100, 0b01000000,
              0b00000000, 0b00000001, 0b00000000, 0b00000100, 0b00000000,
              0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000,
              0b11000000, 0b00000000, [LOW... HIGH] = 0b11010000, 0b00000000,
              0b00001000, 0b01000000, 0b01000000, 0b01000000, 0b00000000,
              0b00000000, 0b00100000, 0b00100010, 0b00100010, 0b00100010,
              0b00100000, 0b00100000, 0b00100000, 0b00100000, 0b00100000,
              0b00100000, 0b00100010, 0b00100000, 0b00100010, 0b00100000,
              0b00100000, 0b00100000, 0b00100000, 0b00100010, 0b00100000,
              0b00100000, 0b00100000, [LOW... HIGH] = 0b00100000, 0b00100010,
              0b00100000, 0b00100000, 0b00000000, 0b00000000, 0b00000000,
              0b00000000, 0b00000000, 0b00000000, 0b00100000, 0b00100010,
              0b00100010, 0b00100010, [LOW... HIGH] = 0b00100000, 0b00100010,
              0b00100000, 0b00100010, [LOW... HIGH] = 0b00100000, 0b00100010,
              [LOW... HIGH] = 0b00100000, 0b00100010,
              [LOW... HIGH] = 0b00100000, 0b00000000, 0b00000001, 0b00000000,
              0b00000000, 0b00000000, [LOW... HIGH] = 0b0, 0b00000001,
              [LOW... HIGH] = 0b0;

  const char KEYCOM[(7) - (0) + 1]

      = '%',
      'C', 'O', 'M', 'M', 'E', 'N', 'T';

  const int FSTABLE[(3) - (1) + 1]

      = 4096,
      16384, 65536;

  //

  // SPECIALDELIMITERSNOTEDBYSOAP80.

  //

  const int OFFILE = 133;
  const int OFPROGRAM = 123;
  const int EQUALS = 38;
  const int COMMA = 10;
  const int IF = 12;
  const int UNLESS = 15;
  const int WHILE = 22;
  const int UNTIL = 28;
  const int ELSE = 227;
  const int THEN = 222;
  const int AND = 158;
  const int OR = 162;
  const int CONST = 204;
  const int CONSTANT = 195;
  const int FN = 96;
  const int FUNCTION = 103;
  //

  // constantstring(1)SNL="

  //"

  _imp_string SNL;
  SNL = TOSTRING(10);
  //

  const _imp_string FAULT[(4) - (1) + 1]

      = "Statement is too long and could not be compiled.",
      "End of file reached before end of program terminator found.",
      "%END found, but could not match it to a start of routine.",
      "Disaster *** Indentation too near line length limit.";

  //

  //

  //

  static void FAIL(int TYPE, int ACTION);
  /*pending name*/

  static void OPT(_imp_string PARM, recfm * P);
  //

  // PRODUCEDBYOLDPSFROMIMPALGS_IMP80PS04ON19/01/83

  const char CLETT[(434) - (0) + 1]

      = 1,
      43, 1, 45, 1, 40, 1, 41, 1, 42, 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, 5, 193, 204, 201, 193, 211, 7, 201, 206, 212, 197, 199,
      197, 210, 4, 210, 197, 193, 204, 4, 204, 207, 206, 199, 4, 194, 217, 212,
      197, 6, 211, 212, 210, 201, 206, 199, 4, 200, 193, 204, 198, 6, 210, 197,
      195, 207, 210, 196, 7, 210, 207, 213, 212, 201, 206, 197, 2, 198, 206, 3,
      205, 193, 208, 8, 198, 213, 206, 195, 212, 201, 207, 206, 4, 206, 193,
      205, 197, 5, 193, 210, 210, 193, 217, 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, 3, 206, 207, 212, 3, 193, 206,
      196, 2, 207, 210, 1, 58, 4, 211, 208, 197, 195, 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, 4, 212,
      200, 197, 206, 4, 197, 204, 211, 197, 1, 95, 6, 211, 217, 211, 212, 197,
      205, 7, 196, 217, 206, 193, 205, 201, 195, 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, 7, 201, 206, 195, 204, 213, 196, 197, 5, 194, 197, 199, 201, 206, 2,
      207, 206, 6, 211, 215, 201, 212, 195, 200, 4, 204, 201, 211, 212, 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, 4, 40, 42,
      41, 58;

  const int SYMBOL[(2167) - (1300) + 1]

      = 1307,
      1303, 0, 1305, 2, 1307, 1000, 1319, 1312, 1001, 1366, 1786, 1315, 1003,
      1020, 1319, 4, 1345, 6, 1329, 1323, 1001, 1014, 1325, 1003, 1329, 4, 1329,
      6, 1336, 1336, 1010, 1028, 1319, 1011, 1359, 1345, 1343, 1010, 1028, 1319,
      1011, 1359, 1345, 8, 1352, 1352, 1010, 1028, 1307, 1011, 1352, 1359, 1357,
      1026, 1307, 999, 1359, 1000, 1366, 1364, 1026, 1319, 999, 1366, 1000,
      1374, 1372, 4, 1345, 1374, 6, 1374, 1000, 1381, 1379, 10, 1345, 999, 1381,
      1000, 1386, 1384, 12, 1386, 15, 1410, 1393, 22, 1010, 1536, 1556, 1011,
      1399, 28, 1010, 1536, 1556, 1011, 1410, 34, 1010, 1001, 38, 1345, 10,
      1345, 10, 1345, 1011, 1416, 1414, 40, 1013, 1416, 1000, 1423, 1421, 10,
      1001, 999, 1423, 1000, 1428, 1426, 46, 1428, 1000, 1436, 1431, 54, 1433,
      46, 1436, 59, 54, 1458, 1439, 46, 1441, 54, 1444, 59, 1428, 1447, 64,
      1423, 1450, 69, 1689, 1453, 76, 1423, 1458, 81, 4, 1848, 6, 1465, 1461,
      88, 1465, 1004, 1436, 1465, 1472, 1468, 96, 1470, 99, 1472, 103, 1488,
      1478, 1436, 1493, 1001, 1416, 1484, 1458, 1488, 1001, 1416, 1501, 1488,
      112, 1001, 1416, 1493, 1491, 112, 1493, 1000, 1501, 1497, 117, 112, 1499,
      112, 1501, 1000, 1511, 1509, 4, 1010, 1472, 1011, 1511, 6, 1511, 1000,
      1520, 1518, 1030, 1010, 1472, 1011, 999, 1520, 1000, 1531, 1524, 123,
      1016, 1526, 133, 1529, 140, 1018, 1531, 1016, 1536, 1534, 147, 1536, 1000,
      1550, 1542, 1345, 1032, 1345, 1550, 1547, 4, 1536, 1556, 6, 1550, 154,
      1536, 1556, 1554, 1037, 1345, 1556, 1000, 1567, 1561, 158, 1536, 1567,
      1565, 162, 1536, 1574, 1567, 1000, 1574, 1572, 158, 1536, 999, 1574, 1000,
      1581, 1579, 162, 1536, 999, 1581, 1000, 1589, 1585, 1033, 1345, 1587, 165,
      1589, 1000, 1595, 1593, 167, 1008, 1595, 1015, 1599, 1598, 167, 1599,
      1608, 1606, 10, 1345, 165, 1345, 1599, 1608, 1000, 1617, 1613, 1493, 1001,
      1416, 1617, 117, 1531, 1617, 1623, 1623, 1001, 1416, 1794, 1623, 1629,
      1627, 10, 1617, 1629, 1000, 1646, 1639, 1493, 1595, 1010, 1001, 1410,
      1802, 1011, 1646, 1646, 117, 1531, 1595, 1001, 1794, 1668, 1657, 1655, 10,
      1010, 1001, 1410, 1802, 1011, 1646, 1657, 1000, 1668, 1660, 172, 1662,
      176, 1664, 185, 1666, 195, 1668, 204, 1679, 1677, 38, 1012, 1028, 1319,
      1359, 1689, 1679, 1679, 1000, 1689, 1687, 10, 1028, 1319, 1359, 1689, 999,
      1689, 1000, 1696, 1694, 4, 1336, 6, 1696, 1000, 1703, 1701, 10, 1329, 999,
      1703, 1000, 1708, 1706, 210, 1708, 1000, 1714, 1712, 10, 1345, 1714, 1000,
      1727, 1725, 10, 1001, 1416, 4, 1345, 165, 1345, 6, 999, 1727, 1000, 1734,
      1732, 28, 1536, 1556, 1734, 1000, 1747, 1737, 1019, 1739, 1006, 1744,
      1381, 1536, 1556, 1006, 1747, 1386, 1006, 1761, 1751, 216, 1034, 1755,
      222, 216, 1034, 1761, 222, 1010, 2008, 1011, 1767, 1767, 1765, 158, 2008,
      1767, 1000, 1773, 1771, 227, 1773, 1773, 1000, 1786, 1777, 216, 1034,
      1784, 1381, 1010, 1536, 1556, 1011, 1747, 1786, 2008, 1794, 1792, 232,
      1001, 1366, 1786, 1794, 1000, 1802, 1802, 4, 1345, 165, 1345, 1599, 6,
      1810, 1808, 38, 1028, 1319, 1359, 1810, 1000, 1819, 1813, 234, 1815, 176,
      1817, 241, 1819, 1000, 1830, 1828, 1001, 38, 1345, 10, 1345, 10, 1345,
      1830, 1000, 1837, 1835, 10, 1855, 999, 1837, 1000, 1848, 1841, 167, 1001,
      1848, 1001, 4, 1855, 1830, 1873, 6, 1855, 1851, 1001, 1855, 1855, 1830,
      1873, 1865, 1859, 1436, 1865, 1865, 4, 1855, 1830, 1873, 6, 1873, 1870,
      1493, 1001, 1416, 1873, 117, 1617, 1881, 1879, 162, 1855, 1830, 999, 1881,
      1000, 1898, 1886, 249, 1002, 1006, 1890, 1022, 1898, 1006, 1896, 254,
      1009, 10, 1009, 1006, 1898, 1031, 1912, 1902, 1023, 1912, 1907, 1024, 260,
      1951, 1956, 1912, 1025, 1005, 10, 1935, 1935, 1917, 263, 1001, 265, 1919,
      1984, 1924, 4, 1984, 1973, 6, 1928, 267, 1984, 6, 1933, 4, 272, 1973, 6,
      1935, 275, 1951, 1940, 263, 1001, 265, 1942, 1984, 1947, 4, 272, 1973, 6,
      1951, 267, 1005, 6, 1956, 1954, 272, 1956, 1005, 1964, 1962, 10, 1005, 10,
      1005, 1964, 1000, 1973, 1968, 0, 1005, 1971, 2, 1005, 1973, 1000, 1979,
      1977, 0, 275, 1979, 1000, 1984, 1982, 38, 1984, 1000, 1999, 1989, 1979,
      1300, 1003, 1992, 1001, 1964, 1997, 4, 1999, 1964, 6, 1999, 277, 2008,
      2002, 281, 2004, 285, 2006, 289, 2008, 292, 2041, 2017, 1010, 1001, 1366,
      1786, 1011, 1581, 1761, 2021, 296, 1001, 1366, 2023, 299, 2027, 306, 1033,
      1345, 2030, 313, 1761, 2032, 321, 2037, 326, 1703, 1329, 1708, 2039, 333,
      2041, 338, 2168, 2048, 1027, 1010, 2008, 1011, 1734, 2050, 1007, 2058,
      1381, 1010, 1536, 1556, 1011, 1747, 1006, 2063, 347, 1035, 1767, 1006,
      2068, 354, 1029, 1819, 1006, 2073, 360, 1036, 1727, 1006, 2078, 1386, 354,
      1029, 1006, 2086, 1004, 1008, 1010, 1436, 1011, 1608, 1006, 2090, 367,
      1520, 1006, 2095, 81, 147, 1837, 1006, 2105, 1010, 1810, 1458, 1011, 1589,
      1001, 1410, 1501, 1006, 2110, 1657, 1436, 1629, 1006, 2114, 371, 1003,
      1038, 2118, 379, 1015, 1006, 2127, 385, 1021, 1703, 1329, 1696, 216, 1034,
      1006, 2138, 388, 1001, 1416, 4, 1345, 165, 1345, 6, 1714, 1006, 2142, 395,
      1006, 1017, 2148, 227, 1035, 1039, 1034, 1006, 2151, 8, 1881, 2154, 400,
      1006, 2158, 415, 1001, 1006, 2162, 422, 1003, 1006, 2166, 1001, 430, 1019,
      2168, 1006;

  const int SS = 2041;

  const int COMMENT = 2;
  // ALTOFP<SS>OFcomment

  const int OWNALT = 12;
  // ALTOFP<SS>FOROWNS

  const int EISSS = 0x00017F00;
  // FLAGDECLARATIVESSALTS

  // MAYCHANGEWITHNEWSYNTAX

  const int OPC[(127) - (0) + 1]

      = 0,
      ' JCC', ' JAT', ' JAF',
      [LOW... HIGH] = 0, ' VAL', ' CYD', 'INCA', 'MODD', 'PRCL', '   J', ' JLK',
              'CALL', ' ADB', ' SBB', 'DEBJ', ' CPB', ' SIG', ' MYB', ' VMY',
              'CPIB', ' LCT', 'MPSR', 'CPSR', 'STCT', 'EXIT', 'ESEX', ' OUT',
              ' ACT', '  SL', 'SLSS', 'SLSD', 'SLSQ', '  ST', 'STUH', 'STXN',
              'IDLE', ' SLD', ' SLB', 'TDEC', 'INCT', ' STD', ' STB', 'STLN',
              'STSF', '   L', ' LSS', ' LSD', ' LSQ', 'RRTC', ' LUH', 'RALN',
              ' ASF', 'LDRL', ' LDA', 'LDTB', ' LDB', '  LD', '  LB', ' LLN',
              ' LXN', ' TCH', 'ANDS', ' ORS', 'NEQS', 'EXPA', ' AND', '  OR',
              ' NEQ', '  PK', ' INS', 'SUPK', ' EXP', 'COMA', ' DDV', 'DRDV',
              'DMDV', 'SWEQ', 'SWNE', ' CPS', ' TTR', ' FLT', ' IDV', 'IRDV',
              'IMDV', ' MVL', '  MV', 'CHOV', ' COM', ' FIX', ' RDV', 'RRDV',
              'RDVD', ' UAD', ' USB', 'URSB', ' UCP', ' USH', ' ROT', ' SHS',
              ' SHZ', ' DAD', ' DSB', 'DRSB', ' DCP', ' DSH', ' DMY', 'DMYD',
              'CBIN', ' IAD', ' ISB', 'IRSB', ' ICP', ' ISH', ' IMY', 'IMYD',
              'CDEC', ' RAD', ' RSB', 'RRSB', ' RCP', ' RSC', ' RMY', 'RMYD',
              ' PUT';

  void CNPTF(void) {
    //***********************************************************************

    //*CREATENEWPAGETOFILE:-THISISCALLEDWHENTHEOUTPUTFILE*

    //*ISFULLANDMUSTBEEXTENDEDTOANEWPAGE.*

    //***********************************************************************

    if (FILESIZEPTR < 3) {
      FILESIZEPTR = FILESIZEPTR + 1;
      FILESIZE = FSTABLE[(FILESIZEPTR) - (1)];
    } else
      FILESIZE = FILESIZE + FSTABLE[(3) - (1)];
    CHANGEFILESIZE(WORKFILE, FILESIZE, EFLAG);
    if (EFLAG == 261) {
      // V.M.HOLEISTOOSMALLFORTHENEWFILESIZE.

      DISCONNECT(WORKFILE, EFLAG);
      if (EFLAG != 0) FAIL(EFLAG, 5);
      CHANGEFILESIZE(WORKFILE, FILESIZE, EFLAG);
      if (EFLAG == 0) {
        WRITEADDRESS = WRITEADDRESS - CONAD;
        CONNECT(WORKFILE, 3, 0, 0, RR, EFLAG);
        if (EFLAG != 0) FAIL(EFLAG, 5);
        CONAD = RR;
        WRITEADDRESS = WRITEADDRESS + CONAD;
        OUTREC = ;
      }
    }

    if (EFLAG != 0) FAIL(EFLAG, 5);
    // UPDATEFILESIZEINHEADER.
    OUTREC = FILESIZE;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void TRANSFER(int FROM, int TO) {
    //***********************************************************************

    //*TRANSFERCOPIESTHECONTENTSOFOUTBUFFROMFROMTOTOINTOTHE*

    //*OUTPUTFILEORCHANNEL.*

    //***********************************************************************

    int I;
    int CH;
    int LAST;

    if (STREAM != TERMINAL) {
      LAST = TO - FROM + 1 + WRITEADDRESS - CONAD;
      if (LAST > FILESIZE) CNPTF();
      OUTREC = LAST;
    }

    for (I = FROM; I != TO; I += 1) {
      CH = OUTBUF[(I) - (0)] & 0x7F;
      if (CH & 127 == RS) continue;
      if (CH == NL()) {
        CHARSIN = 0;
        LINE = LINE + 1;
        if (!(STREAM == TERMINAL)) {
          while (WRITEADDRESS > WA0 && BYTEINTEGER(WRITEADDRESS - 1) == ' ')
            WRITEADDRESS = WRITEADDRESS - 1;
        }

      } else
        CHARSIN = CHARSIN + 1;
      if (STREAM == TERMINAL)
        PRINTSYMBOL(CH);
      else {
        BYTEINTEGER(WRITEADDRESS) = CH;
        WRITEADDRESS = WRITEADDRESS + 1;
      }
    }

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void OUTSTRING(_imp_string TEXT) {
    //***********************************************************************

    //*OUTSTRINGCOPIESTEXTTOTHEOUTPUTFILEORCHANNEL.*

    //***********************************************************************

    int I;
    int CH;
    int LAST;

    if (STREAM != TERMINAL) {
      LAST = LENGTH(TEXT) + WRITEADDRESS - CONAD;
      if (LAST > FILESIZE) CNPTF();
      OUTREC = LAST;
    }

    for (I = 1; I != LENGTH(TEXT); I += 1) {
      CH = CHARNO(TEXT, I);
      if (CH == NL()) {
        CHARSIN = 0;
        LINE = LINE + 1;
      } else
        CHARSIN = CHARSIN + 1;
      if (STREAM == TERMINAL)
        PRINTSYMBOL(CH);
      else {
        BYTEINTEGER(WRITEADDRESS) = CH;
        WRITEADDRESS = WRITEADDRESS + 1;
      }
    }

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void DUPL(int CHAR, int TIMES) {
    //***********************************************************************

    //*DUPLCOPIESCHAR,TIMESTIMESTOTHEOUTPUTFILEORCHANNEL.*

    //***********************************************************************

    int I;
    int LAST;

    if (TIMES <= 0) return;
    CHARSIN = CHARSIN + TIMES;
    if (STREAM != TERMINAL) {
      LAST = TIMES + WRITEADDRESS - CONAD;
      if (LAST > FILESIZE) CNPTF();
      OUTREC = LAST;
    }

    for (I = 1; I != TIMES; I += 1) {
      if (STREAM == TERMINAL)
        PRINTSYMBOL(CHAR);
      else {
        BYTEINTEGER(WRITEADDRESS) = CHAR;
        WRITEADDRESS = WRITEADDRESS + 1;
      }
    }

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void INSERT(int CHARS, int LSFLAG, int RSFLAG) {
    //***********************************************************************

    //*THISWILLPLACEUPTOFOURCHARACTERSINTOTHEOUTBUFBUFFERTHIS*

    //*INCLUDESTHEOPTIONOFHAVESPACESAROUNDTHECHARACTERS.*

    //***********************************************************************

    if (LSFLAG == TRUE && TRUE != INCONST) {
      OUTBUF[(OBP) - (0)] = ' ';
      OBP = OBP + 1;
    }
    do {
      OUTBUF[(OBP) - (0)] = CHARS & 0xFF;
      CHARS = CHARS >> 8;
      OBP = OBP + 1;
    } while (!(CHARS == 0));
    if (RSFLAG == TRUE && TRUE != INCONST) {
      OUTBUF[(OBP) - (0)] = ' ';
      OBP = OBP + 1;
    }

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void CLOSEDOWN(int SUCCESS) {
    //***********************************************************************

    //*CLOSEDOWNISCALLEDWHENTHEPROGRAMISTOTERMINATEEXECUTION*

    //*ANDISTOPRINTASUITABLEMESSAGEANDTOCLOSETHEOUTPUTFILE*

    //*IFANY.*

    //***********************************************************************

    if (SUCCESS == TRUE) {
      PRINTSTRING(ITOS(LINE)." lines have been processed".SNL);

    } else {
      PRINTSTRING("Soap80 fails :- ".ITOS(ERRORS));
      if (ERRORS == 1)
        PRINTSTRING(" error.".SNL);
      else
        PRINTSTRING(" errors.".SNL);
    }

    // ISTHEREAFILETOCLOSE?

    if (STREAM != TERMINAL) {
      OUTREC = WRITEADDRESS - CONAD;
      TRIM(WORKFILE, EFLAG);
      DISCONNECT(WORKFILE, EFLAG);
      if (STREAM == SAMEFILE) {
        if (ERRORS > 0)
          PRINTSTRING("Output stored in ".WORKFILE.", since ".INFILE
                          ." contains errors.".SNL);
        else {
          NEWGEN(WORKFILE, OUTF, EFLAG);
          if (EFLAG != 0) {
            PRINTSTRING("Attempt to create ".OUTF." failed because "
                            .FAILUREMESSAGE(EFLAG)
                            .SNL);
            PRINTSTRING("Output stored in ".WORKFILE.".".SNL);
          }
        }

      } else {
        if (STREAM == DEVICE) {
          if (LENGTH(INFILE) > 8) LENGTH(INFILE) = 8;
          SENDFILE(WORKFILE, OUTF, "Soap80: ".INFILE, 1, 0, EFLAG);
          if (EFLAG != 0) FAIL(EFLAG, 5);
        }
      }
    }

    //! PPROFILEREMOVEDGT

    // EXITFROMSOAP80.
    exit(0);

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void PUNCH(void) {
    //***********************************************************************

    //*PUNCHISFORTRANFERRINGTHECONTENTSOFTHEOUTBUFARRAY*

    //*TOTHEOUTPUTFILEORCHANNEL,USINGTRANSFER,OUTSTRINGANDDUPL.*

    //**

    //*PUNCHDECIDESWHERETOBREAKALINEIFITISTOOLONG.*

    //***********************************************************************

    int LST;
    int BK;
    int I;
    int UBP;
    int LBP;
    int BBP;
    int TP;
    int INN;
    int CH;
    int CURLEND;

    INN = IN;
    if (1 << SSALT & EISSS == 0 && P == TRUE) INN = INN + 1;
    if (SSALT != COMMENT && SEMICOLON == FALSE) DUPL(' ', P - CHARSIN);
    if (OUTBUF[(OBP - 1) - (0)] == ';')
      SEMICOLON = TRUE;
    else
      SEMICOLON = FALSE;
    if (SEMICOLON == TRUE && P - 20 < CHARSIN + OBP) {
      SEMICOLON = FALSE;
      OUTBUF[(OBP - 1) - (0)] = NL();
    }
    if (SEMICOLON == TRUE) {
      OUTBUF[(OBP) - (0)] = ' ';
      OBP = OBP + 1;
    }

    if (INCREM == TRUE) {
      INCREM = FALSE;
      // ISINDENTINGVALUETOONEARTHELINELENGTHLIMIT?

      if (P + 20 > P)
        FAIL(4, 2);
      else
        IN = IN + 1;
    }

    LST = 1;

    if (SSALT == COMMENT) {
      // LOOKFORRSINCOMMENT.IFFOUND,OUTPUTASMORETHANONELINE.

      do {
        if (CHARTYPE[(SC[(1) - (0)]) - (0)] & REM == 0 || SEMICOLON == TRUE) {
          // COMMENTDOESNOTSTARTINCOLUMN1.

          if (SEMICOLON | COLON == FALSE && P == FALSE)
            DUPL(' ', P - CHARSIN);
          else
            DUPL(' ', P - CHARSIN);
        }

        I = LST;
        while (I < OBP && OUTBUF[(I) - (0)] & 127 != RS) I = I + 1;
        if (I == OBP) goto FINALPART;
        TRANSFER(LST, I - 1);
        if (OUTBUF[(I - 1) - (0)] & 127 == ',')
          OUTSTRING(SNL);
        else
          OUTSTRING(PERCENTC.SNL);
        while (!(I == OBP || OUTBUF[(I) - (0)] != ' ')) I = I + 1;
        LST = I;
      } while (1);
    }

    do {
      // RHMOSTBREAKPOINT
      UBP = P + LST - CHARSIN - 4;

      LBP = (UBP + LST) / 2;
      BBP = (UBP + 3 * LST) / 4;
      CURLEND = 0;

      // FIRSTCHECKFORNLINSTRINGCONSTORLIST

      for (BK = LST; BK != UBP + 3; BK += 1) {
        if (BK >= OBP) break;
        CH = OUTBUF[(BK) - (0)];
        if (CH & 127 == NL() || CH & 127 == RS && SSALT == OWNALT && P == TRUE)
          goto PRINTPART;
      }
      // 3FOR" %C"
      if (OBP < UBP + 3) break;

      for (BK = UBP; BK != BBP; BK += -1) {
        // CHECKFORPRIMARYBREAKPOINTS

        if (OUTBUF[(BK) - (0)] & BPOINT != 0) {
          while (OUTBUF[(BK + 1) - (0)] == ' ') BK = BK + 1;
          goto PRINTPART;
        }
      }
      for (BK = UBP; BK != BBP; BK += -1) {
        // CHECKFORSECONDARYBREAKPOINT

        if (OUTBUF[(BK) - (0)] & BPOINT2 != 0) {
          while (OUTBUF[(BK + 1) - (0)] == ' ') BK = BK + 1;
          goto PRINTPART;
        }
      }
      for (BK = UBP; BK != BBP; BK += -1) {
        if (OUTBUF[(BK) - (0)] == ',') goto PRINTPART;
      }
      if (OUTBUF[(UBP) - (0)] & INCURLY != 0) {
        // INACURLYCOMMENT

        CURLEND = 1;
        for (BK = UBP; BK != OBP - 2; BK += 1) {
          if (OUTBUF[(BK) - (0)] & INCURLY == 0) {
            CURLEND = 0;
            break;
          }
        }
        // CURLENDINDICATESWHETHERTHECURLYCOMMENTGOESTOTHEENDOFTHELINE.

        for (BK = UBP; BK != BBP; BK += -1) {
          if (OUTBUF[(BK) - (0)] & INCURLY == 0) {
            BK = BK - 1;
            goto PRINTPART;
          }
        }
        // OVERLONGCURLYCOMMENT.
        if (CURLEND == 1) goto FINALPART;

        for (BK = UBP; BK != OBP - 2; BK += 1) {
          if (OUTBUF[(BK) - (0)] & INCURLY == 0) goto PRINTPART;
        }
      }

      for (BK = UBP + 1; BK != LBP; BK += -1) {
        if (OUTBUF[(BK) - (0)] == ' ' &&
            OUTBUF[(BK - 1) - (0)] & UNDERLINE != 0)
          goto PRINTPART;
      }
      if (P == FALSE) {
        // MUSTOMITIFNAMESARESPACED

        for (BK = UBP + 1; BK != LBP; BK += -1) {
          if (OUTBUF[(BK) - (0)] == ' ') goto PRINTPART;
        }
      }

      for (BK = UBP; BK != LBP; BK += -1) {
        if (OUTBUF[(BK) - (0)] == '%') {
          BK = BK - 1;
          goto PRINTPART;
        }
      }
      for (BK = UBP; BK != LBP; BK += -1) {
        if (OUTBUF[(BK) - (0)] == '.' || OUTBUF[(BK) - (0)] == ')')
          goto PRINTPART;
        if (OUTBUF[(BK) - (0)] == '(') {
          BK = BK - 1;
          goto PRINTPART;
        }
      }
      if (OUTBUF[(UBP) - (0)] & INSTRING != 0) {
        // BREAKPOINTISINSIDEASTRING.

        for (BK = UBP; BK != BBP; BK += -1) {
          if (OUTBUF[(BK) - (0)] == ',' || OUTBUF[(BK) - (0)] == '.' ||
              OUTBUF[(BK) - (0)] == '=')
            goto PRINTPART;
        }
        for (I = UBP; I != LST + 3; I += -1) {
          if (OUTBUF[(I) - (0)] == DQUOTES) {
            BK = I - 1;
            goto PRINTPART;
          }
        }
        for (I = BK; I != LST; I += -1) {
          if (OUTBUF[(I) - (0)] == SQUOTES) {
            if (CHARTYPE[(OUTBUF[(I - 1) - (0)]) - (0)] & CONSTART == 0)
              BK = I - 1;
            else
              BK = I - 2;
            goto PRINTPART;
          }
        }
        // BREAKSTRING.

        PRINTSTRING("Line:".ITOS(LINE)." problem:");
        for (I = LST; I != UBP; I += 1) PRINTSYMBOL(OUTBUF[(I) - (0)]);
        PRINTSTRING(SNL);
        TP = UBP - 1;
        TRANSFER(LST, TP);
        OUTSTRING(
            ""
            ".".PERCENTC.SNL);
        DUPL(' ', P + P);
        OUTSTRING(
            ""
            "");
        LST = TP + 1;
        continue;

      } else
        BK = UBP;
      PRINTSTRING("Line:".ITOS(LINE)." problem:");
      for (I = LST; I != UBP; I += 1) PRINTSYMBOL(OUTBUF[(I) - (0)]);
      PRINTSTRING(SNL);
    PRINTPART:
      I = BK;
      while (OUTBUF[(I) - (0)] == ' ' || OUTBUF[(I) - (0)] & 127 == RS)
        I = I - 1;
      TRANSFER(LST, I);
      if (I < LST || OUTBUF[(I) - (0)] & 127 != NL()) {
        // NOTNATURALBREAK

        if (OUTBUF[(I) - (0)] & 127 != ',' && OUTBUF[(BK) - (0)] != RS | 128 &&
            CURLEND == 0)
          OUTSTRING(" ".PERCENTC);
        OUTSTRING(SNL);
        if (INCONST == FALSE) DUPL(' ', P + P);
        if (OUTBUF[(BK + 1) - (0)] & UNDERLINE != 0 &&
            OUTBUF[(BK + 1) - (0)] != RS | 128)
          OUTSTRING("%");
      }

      LST = BK + 1;
    } while (1);
  FINALPART:
    TRANSFER(LST, OBP - 1);
    OBP = 1;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  int NEXTNONSP(int PRINT) {
    // IFPRINTISTRUETHEN' 'OR'%'ORRSARETRANSFERREDTOTHEOUTPUT

    // BUFFERWHENENCOUNTERED.

    int CH;

    do {
      CH = SC[(PTR) - (0)];
      if (CH == '{') {
        if (OBP > 1 && PRINT == FALSE) {
          OUTBUF[(OBP) - (0)] = ' ';
          OBP = OBP + 1;
        }
        OUTBUF[(OBP) - (0)] = '{';
        OBP = OBP + 1;
        PTR = PTR + 1;
        do {
          CH = SC[(PTR) - (0)];
          OUTBUF[(OBP) - (0)] = CH | INCURLY;
          OBP = OBP + 1;
          PTR = PTR + 1;
        } while (!(CH == '}'));
        continue;
      }

      if (!(CH == ' ' || CH == '%' || CH & 127 == RS)) break;
      if (PRINT == TRUE) {
        OUTBUF[(OBP) - (0)] = CH;
        OBP = OBP + 1;
      }
      PTR = PTR + 1;
    } while (1);
    return CH;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  void GETLINE(int INITPTR) {
    //***********************************************************************

    //*GETLINE:-TAKEFROMTHEINPUTFILEANDPROCESSESTHEDATAAND*

    //*ITINTOTHEARRAYSC.*

    //**

    //*THEFOLLOWINGPROCESSINGISDONE:*

    //*1)ALLDELIMITERSHAVE128ADDEDTOEACHCHARACTERINTHEWORD*

    //*2)LINESAREJOINEDTOGTHERIFTHEREISAcOR','ATTHEEND*

    //*OFTHEFIRSTLINE.THENEWLINEPOSITIONISMARKEDBYRS.*

    //***********************************************************************

    const char ITOI[(255) - (0) + 1]

        = [LOW... HIGH] = 32,
                  10, [LOW... HIGH] = 32, 25, 26, [LOW... HIGH] = 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,
                  [LOW... HIGH] = 26, 10, [LOW... HIGH] = 26,
                  [LOW... HIGH] = 26, [LOW... HIGH] = 26, 92, 38,
                  [LOW... HIGH] = 26, 35, [LOW... HIGH] = 26,
                  [LOW... HIGH] = 26, [LOW... HIGH] = 26, 35,
                  [LOW... HIGH] = 26, 94, [LOW... HIGH] = 26;

    short int SCURL[(20) - (1) + 1]

        ;
    short int ECURL[(20) - (1) + 1]

        /*H imp80-switch.h:2307*/

        int INKEYWORD;
    int CHAR;
    int P;
    int NCURL;

    static int STRDELIMITER;

    if (INITPTR == 1) STARTLINE = INPTR;
    PTR = INITPTR;

    do {
      INKEYWORD = FALSE;
      NCURL = 0;
      do {
        if (PTR > CCSIZE) {
          FAIL(1, 1);
          break;
        }
        if (INPTR > DATAEND) FAIL(2, 1);
        CHAR = ITOI[(BYTEINTEGER(INPTR)) - (0)];

        INPTR = INPTR + 1;

        if (CHAR == NL()) {
          INLINE = INLINE + 1;
          SC[(PTR) - (0)] = NL();
          PTR = PTR + 1;
          break;
        }

        if (STR == TRUE) {
          SC[(PTR) - (0)] = CHAR;
          PTR = PTR + 1;
          if (CHAR == STRDELIMITER) STR = FALSE;
          continue;
        }

        if (CHARTYPE[(CHAR) - (0)] & ENDST != 0) {
          SC[(PTR) - (0)] = CHAR;
          PTR = PTR + 1;
          break;
        }

        // DEALWITHCURLYBRACKETCOMMENTSNOTINGSTARTSOASTOPERMIT

        // CONTINUATIONSOFTHEFORM...,.

        // NOTETHATANYMISSINGCLOSINGBRACEISREPLACED.

        if (CHAR == '{') {
          NCURL = NCURL + 1;
          SCURL[(NCURL) - (1)] = PTR;
          SC[(PTR) - (0)] = CHAR;
          PTR = PTR + 1;
          do {
            CHAR = ITOI[(BYTEINTEGER(INPTR)) - (0)];

            if (CHAR == NL())
              CHAR = '}';
            else
              INPTR = INPTR + 1;
            if (CHAR == '}') break;
            SC[(PTR) - (0)] = CHAR;
            PTR = PTR + 1;
          } while (1);
          ECURL[(NCURL) - (1)] = PTR;
        }

        if (INKEYWORD == TRUE) {
          if (CHARTYPE[(CHAR) - (0)] & LETTER == 0)
            INKEYWORD = FALSE;
          else {
            SC[(PTR) - (0)] = ONECASE[(CHAR) - (0)] | UNDERLINE;
            PTR = PTR + 1;
            continue;
          }
        }

        if (CHAR == '%') INKEYWORD = TRUE;

        if (CHAR == SQUOTES || CHAR == DQUOTES) {
          STR = TRUE;
          STRDELIMITER = CHAR;
        }

        SC[(PTR) - (0)] = CHAR;
        PTR = PTR + 1;
      } while (1);

      if (CHAR == NL()) {
        // TRAILINGSPACESCHECK

        while (PTR > 2 && SC[(PTR - 2) - (0)] == ' ') PTR = PTR - 1;
        SC[(PTR - 1) - (0)] = NL();
        if (STR == FALSE) {
          P = PTR - 2;
          while (NCURL > 0 && ECURL[(NCURL) - (1)] == P) {
            // STEPPASTCURLYBRACKET.

            P = SCURL[(NCURL) - (1)] - 1;
            NCURL = NCURL - 1;
            while (P > 0 && SC[(P) - (0)] == ' ') P = P - 1;
          }
          // NOWPPOINTSATCHARACTERDETERMININGCONTINUATION.

          if (P > 0) {
            CHAR = SC[(P) - (0)];
            if (CHAR == ',') {
              SC[(PTR - 1) - (0)] = RS | 128;
              continue;
            }

            if (CHAR == 'C' + UNDERLINE) {
              if (P > 1 && SC[(P - 1) - (0)] == '%') SC[(P - 1) - (0)] = ' ';
              SC[(P) - (0)] = ' ';
              SC[(PTR - 1) - (0)] = RS;
              continue;
            }

            if (CHAR & 127 == RS) {
              SC[(PTR - 1) - (0)] = RS | 128;
              continue;
            }
          }
        }
      }

      break;
    } while (1);
    PTR = INITPTR;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  int COMPARE(int TEST) {
    int I;
    int CH;
    int KEY;
    int J;

    for (I = 1; I != CLETT[(TEST) - (0)]; I += 1) {
      CH = NEXTNONSP(INCONST);
      if (CH != CLETT[(I + TEST) - (0)]) return FALSE;
      PTR = PTR + 1;
    }

    if (TEST == OFFILE || TEST == OFPROGRAM) STOP = TRUE;

    if (TEST == COMMA) {
      INSERT(',', FALSE, P);
      return TRUE;
    }
    if (TEST == EQUALS) {
      if (SSALT == OWNALT) INCONST = P;
      // IFINOWNORCONSTDECLARATIONANDP_LCLISTISSET,THENSET

      // INCONSTTOTRUE.THEEFFECTOFTHISISLEAVETHEDECLARATION

      // UNFORMATTED.INCONSTISNOTSETEARLIERASWEDONOTWISHTHE

      // LEADINGSPACESINTHESTATEMENTTOBEPRESERVED-I.E.THEFIRST

      // LINEOFTHESTATEMENTISINDENTEDWITHTHERESTOFTHEPROGRAM.

      INSERT('=', P, P);
      return TRUE;
    }

    if (P == TRUE) {
      if (TEST == FN) TEST = FUNCTION;
      if (TEST == CONST) TEST = CONSTANT;
    }

    if (OBP == 1 || OUTBUF[(OBP - 1) - (0)] & UNDERLINE == 0 &&
                        OUTBUF[(OBP - 1) - (0)] & 127 != '%')
      KEY = FALSE;
    else
      KEY = TRUE;
    // CURRENTSTATEOFOUTBUF.

    for (I = 1; I != CLETT[(TEST) - (0)]; I += 1) {
      CH = CLETT[(TEST + I) - (0)];
      if (CH < UNDERLINE && KEY == TRUE) {
        OUTBUF[(OBP) - (0)] = ' ';
        OBP = OBP + 1;
        KEY = FALSE;

      } else if (CH > UNDERLINE) {
        if (KEY == FALSE) {
          if (OBP > 1 && '(' != OUTBUF[(OBP - 1) - (0)] &&
              OUTBUF[(OBP - 1) - (0)] != ' ') {
            OUTBUF[(OBP) - (0)] = ' ';
            OBP = OBP + 1;
          }
          OUTBUF[(OBP) - (0)] = '%';
          OBP = OBP + 1;
          KEY = TRUE;

        } else if (I == 1 && P == TRUE) {
          OUTBUF[(OBP) - (0)] = ' ';
          OUTBUF[(OBP + 1) - (0)] = '%';
          OBP = OBP + 2;
        }
      }

      if (CH & UNDERLINE != 0 && P == FALSE && CH != RS | 128) CH = CH | 32;
      OUTBUF[(OBP) - (0)] = CH;
      OBP = OBP + 1;
    }

    if (TEST == OFFILE || TEST == OFPROGRAM && P == TRUE) {
      if (TEST == OFFILE)
        J = 4;
      else
        J = 7;
      OBP = OBP + 2;
      for (I = 1; I != J; I += 1)
        OUTBUF[(OBP - I) - (0)] = OUTBUF[(OBP - I - 2) - (0)];
      OUTBUF[(OBP - J - 2) - (0)] = ' ';
      OUTBUF[(OBP - J - 1) - (0)] = '%';
    }

    if (TEST == IF || TEST == UNLESS || TEST == WHILE || TEST == UNTIL ||
        TEST == ELSE || TEST == THEN)
      OUTBUF[(OBP - 1) - (0)] = CH | BPOINT;
    if (TEST == AND || TEST == OR) OUTBUF[(OBP - 1) - (0)] = CH | BPOINT2;
    return TRUE;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  int CHECK(int POS) {
    int DEFEND;
    int SUBDEFEND;
    int SUBDEFSTART;
    int RES;
    int ITEM;
    int RSPTR;
    int Z;
    int STRDELIMITER;
    int CH;
    int RSOBJ;
    int ALT;
    int I;
    int J;

    static _imp_string FES = "FINISH %ELSE %START";

    static int UCI;

    static int DEPTH = 0;

    /* TO DO: %SWITCH DECLARATION */

    /*Q imp80-switch.h:4161*/
    // BUILT-INPHRASES.

    ALT = 0;
    // DEPTHOFRECURSIONINCHECK.
    DEPTH = DEPTH + 1;

    // INITIALISESSALTIFINTOP-LEVELCALL.
    if (DEPTH == 1) SSALT = 0;

    RSPTR = PTR;
    RSOBJ = OBP;
    DEFEND = SYMBOL[(POS) - (1300)];
    POS = POS + 1;
    while (POS < DEFEND) {
      ALT = ALT + 1;
      if (DEPTH == 1) {
        // OUTERLEVEL-I.E.TRYINGSSALTERNATIVES.

        SSALT = SSALT + 1;
        INCONST = FALSE;
      }

      SUBDEFEND = SYMBOL[(POS) - (1300)];
      POS = POS + 1;
      RES = TRUE;
      SUBDEFSTART = POS;
      while (POS < SUBDEFEND) {
        ITEM = SYMBOL[(POS) - (1300)];
        if (999 <= ITEM && ITEM < 1300) goto BIP[ITEM];
        if (ITEM < 999) RES = COMPARE(ITEM);
        if (ITEM >= 1300) RES = CHECK(ITEM);
        POS = POS + 1;
        goto BYPASS;

      BIP_999:
        // STARFUNCTION.
        POS = SUBDEFSTART;

        RSPTR = PTR;
        RSOBJ = OBP;
        goto BYPASS;

      BIP_1000:
        // ZEROFUNCTION.
        DEPTH = DEPTH - 1;
        return TRUE;

      BIP_1001:
        // NAME

        CH = NEXTNONSP(INCONST);
        J = PTR;
        PTR = PTR + 1;
        I = OBP;
        if (CHARTYPE[(CH) - (0)] & LETTER == 0) {
          RES = FALSE;
          goto INC;
        }
        if (CHARTYPE[(CH) - (0)] & CONSTART != 0 &&
            NEXTNONSP(INCONST | P) == SQUOTES) {
          RES = FALSE;
          goto INC;
        }
        // AVOIDFUNNYSPACINGON1LETTERNAMES
        PTR = J;
        OBP = I;

        // LASTCHAROUT
        J = OUTBUF[(OBP - 1) - (0)];

        if (J > 128 || CHARTYPE[(J) - (0)] & LETTER != 0 || J == ')') {
          OUTBUF[(OBP) - (0)] = ' ';
          OBP = OBP + 1;
        }
        while (CHARTYPE[(CH) - (0)] & (LETTER | NUMBER) != 0) {
          if (CHARTYPE[(CH) - (0)] & LETTER != 0 && P == FALSE) {
            // LETTERCASEINNAMESTOBECONTROLLEDBYP_UCKEY.

            if (P == TRUE)
              CH = CH & (~32);
            else
              CH = CH | 32;
          }

          OUTBUF[(OBP) - (0)] = CH;
          OBP = OBP + 1;
          // POSITIONAFTERLATESTCHARACTEROFNAME.
          J = OBP;

          PTR = PTR + 1;
          CH = NEXTNONSP(INCONST | P);
        }
        // NOWJGIVESPOSNINOUTBUFAFTERLASTCHARACTEROFNAME,ANDOBP

        // GIVESNEXTFREEPOSNINOUTBUF.

        if (P == TRUE && INCONST == FALSE && J < OBP) {
          // THROWAWAYBYTESAFTERNAME,APARTFROMCURLYCOMMENTS.

          I = J;
          do {
            while (I < OBP && OUTBUF[(I) - (0)] & 127 != '{') I = I + 1;
            if (I == OBP) break;
            if (J < I) {
              OUTBUF[(J) - (0)] = ' ';
              do {
                J = J + 1;
                OUTBUF[(J) - (0)] = OUTBUF[(I) - (0)];
                I = I + 1;
              } while (!(OUTBUF[(J) - (0)] & 127 == '}'));

            } else {
              while (!(OUTBUF[(J) - (0)] & 127 == '}')) J = J + 1;
              I = J + 1;
            }

            J = J + 1;
          } while (1);
          OBP = J;
        }

        goto INC;
      BIP_1005:
        // N-NUMBER.

        CH = NEXTNONSP(INCONST);
        if (CHARTYPE[(CH) - (0)] & NUMBER == 0) {
          RES = FALSE;
          goto INC;
        }
      BIP_1002:
        // ICONST.

      BIP_1003:
        // CONST.

        CH = NEXTNONSP(INCONST);
        PTR = PTR + 1;
        if (!(CHARTYPE[(CH) - (0)] & (QUOTES | CONSTFIRST) != 0 ||
              CHARTYPE[(CH) - (0)] & CONSTART != 0 &&
                  NEXTNONSP(INCONST) == SQUOTES)) {
          RES = FALSE;
          goto INC;
        }
        if (OUTBUF[(OBP - 1) - (0)] > 128 ||
            CHARTYPE[(OUTBUF[(OBP - 1) - (0)]) - (0)] & LETTER != 0) {
          OUTBUF[(OBP) - (0)] = ' ';
          OBP = OBP + 1;
        }
        if (CHARTYPE[(CH) - (0)] & CONSTFIRST == 0) {
          if (CHARTYPE[(CH) - (0)] & CONSTART != 0) {
            OUTBUF[(OBP) - (0)] = CH;
            OBP = OBP + 1;
            STRDELIMITER = NEXTNONSP(INCONST);
            PTR = PTR + 1;

          } else
            STRDELIMITER = CH;
          OUTBUF[(OBP) - (0)] = STRDELIMITER;
          OBP = OBP + 1;
          do {
            if (SC[(PTR) - (0)] == STRDELIMITER) {
              OUTBUF[(OBP) - (0)] = STRDELIMITER | INSTRING;
              if (SC[(PTR + 1) - (0)] != STRDELIMITER) break;
              OUTBUF[(OBP + 1) - (0)] = STRDELIMITER | INSTRING;
              OBP = OBP + 2;
              PTR = PTR + 2;

            } else {
              CH = SC[(PTR) - (0)];
              OUTBUF[(OBP) - (0)] = CH | INSTRING;
              OBP = OBP + 1;
              PTR = PTR + 1;
              if (CH == NL()) {
                GETLINE(PTR);
              }
            }

          } while (1);
          PTR = PTR + 1;
          OBP = OBP + 1;

        } else {
          PTR = PTR - 1;
          do {
            do {
              if (CHARTYPE[(CH) - (0)] & CONSTCONT == 0) break;
              OUTBUF[(OBP) - (0)] = CH;
              OBP = OBP + 1;
              PTR = PTR + 1;
              CH = NEXTNONSP(INCONST);
            } while (1);
            if ('_' != CH && CH != '@') break;
            if (CH == '@')
              J = NUMBER;
            else
              J = NUMBER | LETTER;
            // SECONDPARTOF@ANDRADIXCONSTS

            do {
              OUTBUF[(OBP) - (0)] = CH;
              OBP = OBP + 1;
              PTR = PTR + 1;
              CH = NEXTNONSP(INCONST);
            } while (!(CHARTYPE[(CH) - (0)] & J == 0));
          } while (1);
        }

        goto INC;
      // PHRASECHECKEXTENDEDTYPE
      BIP_1004:

        CH = NEXTNONSP(INCONST);
        if (!(CH > UNDERLINE && 0x80000000 >> (CH & 31) & 0x20C83000 != 0))
          RES = FALSE;
        goto INC;
      // INCLUDE
      BIP_1038:

      // S-ENDSTATEMENT.
      BIP_1006:

        CH = NEXTNONSP(INCONST);
        if (CHARTYPE[(CH) - (0)] & ENDST == 0) {
          RES = FALSE;
          goto INC;
        }
        while (OBP > 1 && OUTBUF[(OBP - 1) - (0)] == ' ') OBP = OBP - 1;
        OUTBUF[(OBP) - (0)] = CH;
        OBP = OBP + 1;
        goto INC;
      // TEXT-COMMENTSTRING.
      BIP_1007:

        CH = NEXTNONSP(INCONST);
        if (CHARTYPE[(CH) - (0)] & REM == 0) {
          RES = FALSE;
          goto INC;
        }
        if (CH & UNDERLINE != 0 && OUTBUF[(OBP - 1) - (0)] & UNDERLINE == 0) {
          OUTBUF[(OBP) - (0)] = '%';
          OBP = OBP + 1;
        }
        OUTBUF[(OBP) - (0)] = CH;
        OBP = OBP + 1;
        PTR = PTR + 1;
        if (CH == 'C' + UNDERLINE) {
          if (P == FALSE) OUTBUF[(OBP - 1) - (0)] = CH | 32;
          for (I = 2; I != 7; I += 1) {
            CH = NEXTNONSP(INCONST);
            if (CH != KEYCOM[(I) - (0)] + UNDERLINE) {
              RES = FALSE;
              goto INC;
            }
            if (P == FALSE) CH = CH | 32;
            OUTBUF[(OBP) - (0)] = CH;
            OBP = OBP + 1;
            PTR = PTR + 1;
          }
        }

        STR = FALSE;
        do {
          while (SC[(PTR) - (0)] != NL() && STR == TRUE ||
                 SC[(PTR) - (0)] != ';') {
            CH = SC[(PTR) - (0)];
            if (CH == SQUOTES || CH == DQUOTES) {
              if (STR == FALSE) {
                STRDELIMITER = CH;
                STR = TRUE;
              } else if (CH == STRDELIMITER)
                STR = FALSE;
            }

            if (CH & UNDERLINE != 0 && P == FALSE && CH != RS | 128)
              CH = CH | 32;
            OUTBUF[(OBP) - (0)] = CH;
            OBP = OBP + 1;
            PTR = PTR + 1;
          }
          OUTBUF[(OBP) - (0)] = SC[(PTR) - (0)];
          OBP = OBP + 1;
          PTR = PTR + 1;
          if (OUTBUF[(OBP - 1) - (0)] == NL()) break;
          // SEMI-COLONTERMINATEDINPUT-CARRYONREADING.

          GETLINE(1);
        } while (1);
        STR = FALSE;
        goto INC;
      // N255-TESTSTRINGDECLARATIONLENGTH.
      BIP_1009:

        CH = NEXTNONSP(INCONST);
        if (!('0' <= CH && CH <= '9')) {
          RES = FALSE;
          goto INC;
        }
        Z = 0;
        while ('0' <= CH && CH <= '9') {
          Z = Z * 10 + CH - '0';
          OUTBUF[(OBP) - (0)] = CH;
          OBP = OBP + 1;
          PTR = PTR + 1;
          CH = NEXTNONSP(INCONST);
        }
        if (Z > 255) RES = FALSE;
        goto INC;
      // READLINE?
      BIP_1012:

        CH = NEXTNONSP(INCONST);
        // DEALWITH"FRED(1:10) = <nl> .. init vals .."CONSTRUCTIONS.

        if (CH == NL()) {
          OUTBUF[(OBP) - (0)] = NL();
          OBP = OBP + 1;
          SC[(PTR) - (0)] = RS | 128;
          GETLINE(PTR + 1);
        }

        goto INC;
      // DOWN.
      BIP_1015:

        LEVEL = LEVEL + 1;
        BHEADING = TRUE;
        if (P == TRUE) INCREM = TRUE;
        goto INC;
      // UP.
      BIP_1016:

        LEVEL = LEVEL - 1;
        BHEADING = TRUE;
        if (P == TRUE && IN > 0) IN = IN - 1;
        goto INC;
      // COLON-ISPREVIOUSCHARACTERACOLON':'?
      BIP_1019:

        if (SC[(PTR - 1) - (0)] != ':') {
          RES = FALSE;
          goto INC;
        }
        if (CHARSIN > 0) OUTSTRING(SNL);
        CH = NEXTNONSP(INCONST);
        TRANSFER(1, OBP - 1);
        OBP = 1;
        if (P == TRUE && CH != NL()) OUTSTRING(SNL);
        INLABEL = TRUE;
        goto INC;
      // SETNEM.
      BIP_1022:

        CH = NEXTNONSP(INCONST);
        Z = '    ';
        while (CHARTYPE[(CH) - (0)] & LETTER != 0) {
          Z = Z << 8 | ONECASE[(CH) - (0)];
          OUTBUF[(OBP) - (0)] = CH;
          OBP = OBP + 1;
          PTR = PTR + 1;
          CH = NEXTNONSP(INCONST);
        }

        if (!(CH == '_' && Z != '    ')) {
          RES = FALSE;
          goto INC;
        }
        OUTBUF[(OBP) - (0)] = '_';
        OBP = OBP + 1;
        UCI = Z;
        PTR = PTR + 1;
        goto INC;
      // PRIMFORM
      BIP_1023:

        for (I = 7; I != 127; I += 1) {
          if (OPC[(I) - (0)] == UCI) goto PFND;
        }
        RES = FALSE;
        goto INC;
      // MNEMONICFOUND
      PFND:

        if (8 <= I >> 3 && I >> 3 <= 11 && I & 7 <= 3) RES = FALSE;
        goto INC;
      // SECTFORM.
      BIP_1024:

        for (I = 64; I != 88; I += 8) {
          for (J = 0; J != 3; J += 1) {
            if (OPC[(I + J) - (0)] == UCI) goto INC;
          }
        }
        RES = FALSE;
        goto INC;
      // TERTFORM.
      BIP_1025:

        for (I = 3; I != 1; I += -1) {
          if (OPC[(I) - (0)] == UCI) goto INC;
        }
        RES = FALSE;
        goto INC;
      // OP.
      BIP_1026:

        CH = NEXTNONSP(INCONST);
        PTR = PTR + 1;
        if (!(32 < CH && CH < 127 &&
              0x80000000 >> (CH & 31) & 0x4237000A != 0)) {
          RES = FALSE;
          goto INC;
        }

        if (CH == '&' || CH == '+' || CH == '-') {
          INSERT(CH, P, P);
          goto INC;
        }

        if (CH == '*') {
          if (CH != NEXTNONSP(INCONST)) {
            INSERT('*', P, P);
            goto INC;
          }
          PTR = PTR + 1;
          J = PTR;
          CH = NEXTNONSP(INCONST);
          PTR = PTR + 1;
          if ('*' == CH && CH == NEXTNONSP(INCONST)) {
            INSERT('****', P, P);
            PTR = PTR + 1;
            goto INC;
          }
          INSERT('**', P, P);
          PTR = J;
          goto INC;
        }

        if (CH == '/') {
          if (CH != NEXTNONSP(INCONST)) {
            INSERT('/', P, P);
            goto INC;
          }
          INSERT('//', P, P);
          PTR = PTR + 1;
          goto INC;
        }

        if (CH == '!') {
          if (CH != NEXTNONSP(INCONST)) {
            INSERT('!', P, P);
            goto INC;
          }
          INSERT('!!', P, P);
          PTR = PTR + 1;
          goto INC;
        }

        if (CH == '.') {
          OUTBUF[(OBP) - (0)] = '.';
          OBP = OBP + 1;
          goto INC;
        }
        if (CH == NEXTNONSP(INCONST) && NEXTNONSP(INCONST) == '>') {
          INSERT('>>', P, P);
          PTR = PTR + 1;
          goto INC;
        }

        if (CH == NEXTNONSP(INCONST) && NEXTNONSP(INCONST) == '<') {
          INSERT('<<', P, P);
          PTR = PTR + 1;
          goto INC;
        }

        if (CH == '\\') {
          if (CH != NEXTNONSP(INCONST)) {
            INSERT('\\', P, P);
            goto INC;
          }
          INSERT('\\\\', P, P);
          PTR = PTR + 1;
          goto INC;
        }

        RES = FALSE;
        goto INC;

      // CHUI.
      BIP_1027:

        CH = NEXTNONSP(INCONST);
        if (CHARTYPE[(CH) - (0)] & LETTER == 0 && CH != '-' &&
            X '80000000' >> (CH & 31) & 0x14043000 == 0)
          RES = FALSE;
        goto INC;
      //+<SQ>.
      BIP_1028:

        CH = NEXTNONSP(INCONST);
        if (CH == '+' || CH == '-' || CH == '\\' || CH == 0x7E) {
          INSERT(CH, P, P);
          PTR = PTR + 1;
        }
        goto INC;
      // UCWRONG(UNKNOWNUSERCODEFORMAT-ALLOWITTHROUGH).
      BIP_1031:

        do {
          CH = NEXTNONSP(INCONST);
          OUTBUF[(OBP) - (0)] = CH;
          OBP = OBP + 1;
          if (CHARTYPE[(CH) - (0)] & ENDST != 0) goto INC;
          PTR = PTR + 1;
        } while (1);
      //,<SQ>.
      BIP_1030:

        CH = NEXTNONSP(INCONST);
        if (CH == ')') RES = FALSE;
        if (RES == TRUE) INSERT(',', FALSE, P);
        if (CH == ',') PTR = PTR + 1;
        goto INC;
      // CHCOMP.
      BIP_1032:

      // COMP2
      BIP_1037:

        CH = NEXTNONSP(INCONST);
        PTR = PTR + 1;
        if (!(32 < CH && CH <= 92 &&
              0x80000000 >> (CH & 31) & 0x1004000E != 0)) {
          RES = FALSE;
          goto INC;
        }
        if (CH == '=') {
          if (NEXTNONSP(INCONST) == CH) {
            PTR = PTR + 1;
            INSERT('==', P, P);
            goto INC;
          }
          INSERT('=', P, P);
          goto INC;
        }

        if (CH == '#') {
          if (NEXTNONSP(INCONST) == CH) {
            PTR = PTR + 1;
            INSERT('##', P, P);
            goto INC;
          }
          INSERT('#', P, P);
          goto INC;
        }

        if (CH == '\\' && NEXTNONSP(INCONST) == '=') {
          PTR = PTR + 1;
          if (NEXTNONSP(INCONST) == '=') {
            PTR = PTR + 1;
            INSERT('==\\', P, P);
            goto INC;
          }
          INSERT('=\\', P, P);
          goto INC;
        }

        if (CH == '>') {
          if (NEXTNONSP(INCONST) == '=') {
            PTR = PTR + 1;
            INSERT('=>', P, P);
            goto INC;
          }
          INSERT('>', P, P);
          goto INC;
        }

        if (CH == '<') {
          if (NEXTNONSP(INCONST) == '=') {
            PTR = PTR + 1;
            INSERT('=<', P, P);
            goto INC;
          }
          if (NEXTNONSP(INCONST) == '>') {
            PTR = PTR + 1;
            INSERT('><', P, P);
            goto INC;
          }
          INSERT('<', P, P);
          goto INC;
        }

        if (CH == '-' && NEXTNONSP(INCONST) == '>') {
          PTR = PTR + 1;
          INSERT('>-', P, P);
          goto INC;
        }
        RES = FALSE;
        goto INC;
      // ASSOP.
      BIP_1033:

        CH = NEXTNONSP(INCONST);
        PTR = PTR + 1;
        if (CH == '=') {
          if (NEXTNONSP(INCONST) == '=') {
            PTR = PTR + 1;
            INSERT('==', P, P);
            goto INC;
          }
          INSERT('=', P, P);
          goto INC;
        }

        if (CH == '<' && NEXTNONSP(INCONST) == '-') {
          PTR = PTR + 1;
          INSERT('-<', P, P);
          goto INC;
        }
        if (CH == '-' && NEXTNONSP(INCONST) == '>') {
          PTR = PTR + 1;
          INSERT('>-', P, P);
          goto INC;
        }
        RES = FALSE;
      // BIGHOLE.
      BIP_1008:

        goto INC;
      // HOLE.
      BIP_1010:

      // MARK.
      BIP_1011:

        goto INC;
      // ALIAS.
      BIP_1013:

        CH = NEXTNONSP(INCONST);
        PTR = PTR + 1;
        if (CH != '"') {
          RES = FALSE;
          goto INC;
        }
        OUTBUF[(OBP) - (0)] = ' ';
        OBP = OBP + 1;
        OUTBUF[(OBP) - (0)] = '"';
        OBP = OBP + 1;
        do {
          if (SC[(PTR) - (0)] == '"') {
            OUTBUF[(OBP) - (0)] = '"' | INSTRING;
            if (SC[(PTR + 1) - (0)] != '"') break;
            OUTBUF[(OBP + 1) - (0)] = '"' | INSTRING;
            OBP = OBP + 2;
            PTR = PTR + 2;

          } else {
            CH = SC[(PTR) - (0)];
            OUTBUF[(OBP) - (0)] = CH | INSTRING;
            OBP = OBP + 1;
            PTR = PTR + 1;
            if (CH == NL()) GETLINE(PTR);
          }

        } while (1);
        PTR = PTR + 1;
        OBP = OBP + 1;
        goto INC;
      // DUMMYAPP.
      BIP_1014:

      // LISTON.
      BIP_1017:

      // LISTOFF.
      BIP_1018:

      // NOTECONST.
      BIP_1020:

      // TRACE.
      BIP_1021:

        goto INC;
      // DUMMYSTART
      BIP_1039:

        if (P == TRUE) {
          // EXPANDelseTOfinishelsestart

          OBP = OBP - 4;
          for (I = 1; I != 19; I += 1) {
            J = CHARNO(FES, I);
            if (P == FALSE && J == ' ' || J == '%') continue;
            if (P == FALSE && 'A' <= J && J <= 'Z') J = J | 32;
            OUTBUF[(OBP) - (0)] = J;
            OBP = OBP + 1;
          }
        }

      // NOTECYCLE
      BIP_1029:

      // NOTESTART
      BIP_1034:

        INCREM = TRUE;
        goto INC;
      // NOTEFINISH
      BIP_1035:

      // NOTEREPEAT
      BIP_1036:

        if (IN > 0) IN = IN - 1;
        goto INC;
      INC:
        POS = POS + 1;
      BYPASS:
        if (RES == FALSE) {
          POS = SUBDEFEND;
          OBP = RSOBJ;
          if (PTR > MAXPTR) {
            MAXPTR = PTR;
            MAXITEM = ITEM;
          }
          PTR = RSPTR;
        }
      }
      if (RES == TRUE) {
        DEPTH = DEPTH - 1;
        return TRUE;
      }
    }
    PTR = RSPTR;
    OBP = RSOBJ;
    DEPTH = DEPTH - 1;
    return FALSE;

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  //***********************************************************************

  //**

  //*MAINCALLINGROUTINE.*

  //**

  //***********************************************************************

  // CLIPARAM
  S = "test.imp,.out,SPCOMMA=Y,EXPKEY=Y";

  // PRINTSTRING("preopt".SNL)

  OPT(S, P)
  // CALLOPTIONSETTINGROUTINETOSETPARAMETERS.
  ;

  // PRINTSTRING("preconnect ".INFILE.SNL)

  CONNECT(INFILE, 0, 0, 0, REC, EFLAG)
  // OPENINPUTFILE.
  ;

  // PRINTSTRING("postconnect".SNL)

  if (EFLAG != 0) FAIL(EFLAG, 5);
  if (REC != CHARFILE) {
    SETFNAME(INFILE);
    FAIL(267, 5);
  }
  // STARTOFDATA.
  INPTR = REC + REC;

  // ENDOFDATA.
  DATAEND = REC + REC;

  // SETOUTPUTSTREAM,POSSIBILITIESARE:

  // TERMINAL,FILE,SAMEFILEOROUTPUTDEVICE.

  if (OUTF == ".OUT")
    STREAM = TERMINAL;
  else {
    if (INFILE == OUTF)
      STREAM = SAMEFILE;
    else {
      if (CHARNO(OUTF, 1) == '.') {
        if (DEVCODE(OUTF) <= 0) {
          // INVALIDOUTPUTDEVICE.

          SETFNAME(OUTF);
          FAIL(264, 5);

        } else
          STREAM = DEVICE;

      } else
        STREAM = FILE;
    }
  }

  // CREATETEMPORYOUTPUTFILE?

  if (STREAM == SAMEFILE || STREAM == DEVICE)
    WORKFILE = "T#".NEXTTEMP();
  else
    WORKFILE = OUTF;
  if (STREAM != TERMINAL) {
    FILESIZEPTR = 1;
    FILESIZE = FSTABLE[(FILESIZEPTR) - (1)];
    // PRINTSTRING("outfile: ".WORKFILE.SNL)

    OUTFILE(WORKFILE, FILESIZE, 0, 0, CONAD, EFLAG);
    if (EFLAG != 0) FAIL(EFLAG, 5);
    OUTREC = ;
    WRITEADDRESS = CONAD + OUTREC;
    WA0 = WRITEADDRESS;
    OUTREC = CHARFILE;
    // RESTOFRECORDELEMENTSTOBEFILLINATENDOFINDENTATION.
  }

  OUTBUF[(0) - (0)] = 0;
  SC[(0) - (0)] = 0;
  LEVEL = 0;
  OBP = 1;
  IN = 0;
  INLINE = 1;
  LINE = 0;
  ERRORS = 0;
  ERPTR = 0;
  CHARSIN = 0;
  STR = FALSE;
  STOP = FALSE;
  SEMICOLON = FALSE;
  INCREM = FALSE;
  INLABEL = FALSE;
  ERSAVE = FALSE;
  if (P == TRUE)
    PERCENTC = "%C";
  else
    PERCENTC = "%c";
  do {
    BHEADING = FALSE;
    MAXPTR = 0;
    // ISTHEREMORETOANALYSEINTHISSTATEMENT.

    COLON = INLABEL;
    if (INLABEL == FALSE)
      GETLINE(1);
    else
      INLABEL = FALSE;
    if (CHECK(SS) == FALSE) {
      PRINTSTRING(SNL."Syntax analysis fails on input line ".ITOS(INLINE - 1));
      PRINTSTRING(" (output line ".ITOS(LINE + 1).")".SNL);
      Z = 1;
      while (CHARTYPE[(SC[(Z) - (0)]) - (0)] & ENDST == 0) {
        if (SC[(Z) - (0)] & 127 == RS)
          PRINTSTRING(SNL);
        else
          PRINTSYMBOL(SC[(Z) - (0)] & 127);
        Z = Z + 1;
      }
      if (SC[(Z) - (0)] == ';') PRINTSYMBOL(';');
      PRINTSTRING(SNL);
      SPACES(MAXPTR - 1);
      PRINTSYMBOL('!');
      PRINTSTRING(SNL);
      while (BYTEINTEGER(STARTLINE) == ' ') STARTLINE = STARTLINE + 1;
      if (STREAM != TERMINAL) {
        OBP = 1;
        // LINEFAILED-INPUTLINETOOUTPUTROUTINE.

        Z = BYTEINTEGER(STARTLINE);
        while (CHARTYPE[(Z) - (0)] & ENDST == 0) {
          if (CHARTYPE[(Z) - (0)] & QUOTES != 0) {
            STRDELIMITER = Z;
            OUTBUF[(OBP) - (0)] = STRDELIMITER;
            OBP = OBP + 1;
            STARTLINE = STARTLINE + 1;
            Z = BYTEINTEGER(STARTLINE);
            while (Z != STRDELIMITER) {
              OUTBUF[(OBP) - (0)] = Z;
              OBP = OBP + 1;
              STARTLINE = STARTLINE + 1;
              Z = BYTEINTEGER(STARTLINE);
            }
          }

          OUTBUF[(OBP) - (0)] = Z;
          OBP = OBP + 1;
          STARTLINE = STARTLINE + 1;
          Z = BYTEINTEGER(STARTLINE);
        }
        OUTBUF[(OBP) - (0)] = Z;
        OBP = OBP + 1;
        PUNCH();
      }

      STR = FALSE;
      ERRORS = ERRORS + 1;

    } else {
      if (INLABEL == FALSE) PUNCH();
    }

    if (STOP == TRUE) {
      if (ERRORS == 0)
        CLOSEDOWN(TRUE);
      else
        CLOSEDOWN(FALSE);
    }

  } while (1);
  // DOESNOTCOMETHROUGHHERE

  void FAIL(int TYPE, int ACTION) {
    if (ACTION != 5) {
      if (ACTION & 2 == 0) {
        PRINTSTRING(SNL."*** Error: ");
        ERRORS = ERRORS + 1;
      } else
        PRINTSTRING(SNL."*** Warning: ");
    }

    if (ACTION & 4 == 0) {
      PRINTSTRING(FAULT[(TYPE) - (1)].SNL);
      PRINTSTRING("*** In input line ".ITOS(INLINE)
                      ." (output line ".ITOS(LINE)
                      .")".SNL);

    } else {
      PRINTSTRING("*** Soap80 fails -".FAILUREMESSAGE(TYPE));
      exit(0);
    }

    if (ACTION & 1 == 1) CLOSEDOWN(FALSE);

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  /*pending name*/

  void OPT(_imp_string PARM, recfm * P) {
    //***********************************************************************

    //*THISROUTINEPROCESSESTHEUSEROPTIONLIST*

    //***********************************************************************

    auto void READLINE(void);
    auto void SETLINE(void);
    auto int STOI(_imp_string SNUM);
    auto void ASK(int OPTNO);
    int I;
    int J;
    int TEMP;
    int FLAG;
    int PROFVSN;

    _imp_string LINE;
    _imp_string OPTION;
    _imp_string VALUE;
    _imp_string FILENAME;

    const int PROGVSN = 3;

    /* TO DO: %SWITCH DECLARATION */

    /*Q imp80-switch.h:4161*/

    PROFVSN = 0;
    FLAG = 5;
    // READPROFILE("Soap80key",P,PROFVSN,FLAG)

    if (FLAG > 4) {
      PRINTSTRING(
          "Failed to read file SS#PROFILE.  Defaults options assumed.".SNL);
    }

    goto PROF[PROFVSN];

    // INTHEFOLLOWINGPROFILE-HANDLINGCODE,WEWORKWITHARRAYP_A

    //(ALTERNATIVEFORMAT)RATHERTHANTHEACTUALOPTIONNAMES(P_SEPKEY

    // ETC.).THISISBECAUSETHEP_AOPERATIONSREMAINVALIDEVENIFTHE

    // RECORDFORMATISSUBSEQUENTLYCHANGED.

  PROF_0:
    // CODETOSETUPPROFILEVSN1DATA:

    // THISCONSISTSOF14OPTIONSFOLLOWEDBY21TABVALUES.

    // ORIGINALDEFAULTS

    // P_A(1)=80

    // LINE-LINESAREBROKENINTOTWOIFLENGTHISGREATERTHAN80.

    // P_A(2)=3

    // ICONTIN-CONTINUATIONOFLINEHAVEANADDITIONINDENTATIONOF3.

    // P_A(3)=41

    // POSCOM-POSITIONFORRIGHTHANDCOMMENTS.

    // P_A(4)=TRUE

    // MOVECOM-MAINCOMMENTAREINDENTEDTOPOSCOM.

    // P_A(5)=TRUE

    // UCKEY-KEYWORDSOUTPUTINUPPERCASE.

    // P_A(6)=FALSE

    // SEPKEY-ADJACENTKEYWORDSARECOMPOUNDED.

    // P_A(7)=TRUE

    // LCASNAM-CASEOFNAMESLEFTALONE.

    // P_A(8)=TRUE

    // SPACNAM-SPACESARELEFTWITHINNAMES.

    // P_A(9)=TRUE

    // SPACASS-SPACESAREADDEDROUNDASSIGNMENTOPERATORS.

    // P_A(10)=FALSE

    // SPACOP-SPACESARENOTADDEDROUNDOTHEROPERATORS.

    // P_A(11)=TRUE

    // LCLIST-CONSTLISTSTOBELEFTALONE.

    // P_A(12)=TRUE

    // IBLOCK-BLOCKCONTENTSAREINDENTEDW.R.T.BLOCKHEADING.

    // P_A(13)=FALSE

    // ISTAT-STATEMENTSAREALIGNEDWITHDECLARATIONS.

    // P_A(14)=FALSE

    // SEPLAB-LABELSANDSTATEMENTSMAYOCCUPYTHESAMELINE.

    // GRAHAM<SQ>SPREFERREDDEFAULTS

    // LINE-LINESAREBROKENINTOTWOIFLENGTHISGREATERTHAN80.
    P = 80;

    // ICONTIN-CONTINUATIONOFLINEHAVEANADDITIONINDENTATIONOF3.
    P = 2;

    // POSCOM-POSITIONFORRIGHTHANDCOMMENTS.
    P = 41;

    // MOVECOM-MAINCOMMENTAREINDENTEDTOPOSCOM.
    P = FALSE;

    // UCKEY-KEYWORDSOUTPUTINUPPERCASE.
    P = FALSE;

    // SEPKEY-ADJACENTKEYWORDSARECOMPOUNDED.
    P = TRUE;

    // LCASNAM-CASEOFNAMESLEFTALONE.
    P = FALSE;

    // SPACNAM-SPACESARELEFTWITHINNAMES.
    P = TRUE;

    // SPACASS-SPACESAREADDEDROUNDASSIGNMENTOPERATORS.
    P = TRUE;

    // SPACOP-SPACESARENOTADDEDROUNDOTHEROPERATORS.
    P = FALSE;

    // LCLIST-CONSTLISTSTOBELEFTALONE.
    P = TRUE;

    // IBLOCK-BLOCKCONTENTSAREINDENTEDW.R.T.BLOCKHEADING.
    P = TRUE;

    // ISTAT-STATEMENTSAREALIGNEDWITHDECLARATIONS.
    P = FALSE;

    // SEPLAB-LABELSANDSTATEMENTSMAYOCCUPYTHESAMELINE.
    P = FALSE;

    // SETDEFAULTINDENTATIONVALUES.

    for (I = 0; I != 10; I += 1) P = 3 * I;
    for (I = 11; I != 20; I += 1) P = 5 * I - 20;

  PROF_1:
    // CODETOSETUPPROFILEVSN2DATA:

    // THISCONSISTSOF15OPTIONSFOLLOWEDBY21TABVALUES.

    // MOVETABVALUESDOWNTOMAKEROOM.
    for (I = 36; I != 16; I += -1) P = P;

    PRINTSTRING("**New parameter available: SPCOMMA".SNL);
    PRINTSTRING("      Y : One space character inserted after commas.".SNL);
    PRINTSTRING("      N : No space character inserted after commas (default)."
                    .SNL.SNL);
    // SPCOMMA-DEFAULTFALSE.
    P = FALSE;

  PROF_2:
    // CODETOSETUPPROFILEVSN3DATA:

    // THISCONSISTSOF21TABVALUESFOLLOWEDBY16OPTIONS.

    /* %begin block */

    {
      int I;

      char TAB[(20) - (0) + 1]

          ;

      // COPYTABVALUESOUT.
      for (I = 0; I != 20; I += 1) TAB[(I) - (0)] = P;

      // MOVEOPTIONSDOWN.
      for (I = 1; I != 6; I += 1) P = P;

      // ITEM_A(28)WILLBETHENEWPARAMETER(EXPKEY).

      // MOVEOPTIONSDOWN.
      for (I = 7; I != 15; I += 1) P = P;

      // COPYTABVALUESBACK.
      for (I = 0; I != 20; I += 1) P = TAB[(I) - (0)];

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

    PRINTSTRING("**New parameter available: EXPKEY".SNL);
    PRINTSTRING(
        "      Y : Keywords %FN, %CONST and (sometimes) %ELSE expanded.".SNL);
    PRINTSTRING(
        "      N : %FN, %CONST and %ELSE left alone (default).".SNL.SNL);
    // EXPKEYDEFAULT-FALSE.
    P = FALSE;

    // THEFOLLOWINGTWOLINESSHOULDALWAYSBEJUSTBEFORETHEFINAL'prof'

    // SWITCHLABEL.

    ;

    /* %begin block */

    {
      _imp_string KEY;

      KEY = "Soap80key";
      WRITEPROFILE(KEY, P, , );

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

  PROF_3:

    // SPLITUPPARAMETERSANDCHANGEDEFAULTVALUES.

    if (*BADCOMP *) {
      if (!(*BADCOMP *))
        ;

    } else {
      ;
      ;
      ;
    };
    if (== "")
      ;
    if (== "") return;

    ;
    if (!= '*' && != '?')
      ;
    do {
      if (== "") {
        /* %begin block */

        {
          _imp_string S;

          S = "Soap80: ";
          // NOTAREALIMPPROMPTUNFORTUNATELY
          ;

          /* End of Begin/Rt/Fn/Map depth=4 */
        };

        ;

      } else {
        ;
      }

      if (== "END" || == ".END") return;
      // ENDOFPARAMETERSETTINGS.

      if (== "GO" || == ".GO") return;
      // ENDOFPARAMETERSETTINGS.

      // ABANDONSOAP80.
      if (== "STOP" || == ".STOP") exit(0);

      if (== "SAVE" || == ".SAVE") {
        /* %begin block */

        {
          _imp_string KEY;

          KEY = "Soap80key";
          ;

          /* End of Begin/Rt/Fn/Map depth=4 */
        };

        if (== 1)
          ;

      } else if (== "?") {
        // PRINTOPTIONSSOFAR.

        ;
for ({
          ;
          ;
          ;
          ;
          if (==)
            ;
          else if (==)
            ;
          else
            ;
          if (> 0)
            ;
          ;
}
;
for ({
          ;
          if (!(== 20))
            ;
}
;
;
;
;

      } else {
        if (*BADCOMP * && != "") {
          ;
for ({
            if (!(==)) continue;
            // OPTIONIDENTIFIED.
            ;

            if (== "?") {
              ;
              ;
              ;
              ;
              if (==)
                ;
              else if (==)
                ;
              else
                ;
              if (> 0)
                ;
              ;

            } else {
              if (<=) {
                // NUMERICALVALUE.

                ;
                if (== "LINE" && <30 ||> 160) {
                  ;
                  break;
                }

                if (> 255)
                  ;
                if (== -1)
                  ;
                else
                  ;

              } else
                ;
            }

            break;
}
//CYCLEFOUNDOPTIONNAME.
if ( == 1) continue;


if ( == "TAB") {
            // SETINDENTINGVALUE.

            if (== "?") {
              ;
for ({
                ;
                if (!(== 20))
                  ;
}
;
;
;

            } else {
              ;
              while (<= 20 && != "") {
                ;
                if (== -1) {
                  ;
                  break;
                };
                if (== 0) {
                  ;
                  break;
                }
                if (!= ':') {
                  ;
                  ;

                } else
                  ;
                ;
              }
              // ENDOFINDENTINGVALUE,MAKEUPTHEREST

for ({
                ;
                if (>)
                  ;
}
            }

            continue;

}

;
// KEYWORDNOTRECOGNISED.

        } else {
          ;
        }
      }

    } while (1);
    // return

    void READLINE(void) {
      //***********************************************************************

      //*READLINECREATESALINEFROMTHEINPUTDEVICE,CONVERTINGALL*

      //*LOWERCASECHARACTERSTOUPPERCASE.*

      //***********************************************************************

      int CH;

      do {
        ;
        do {
          ;
          if (CH ==) break;
          if (CH == ' ') continue;
          // CONVERTLOWERTOUPPER.

          ;
        } while (1);
        // RETURNONLYIFTHELINEHASSOMETHINGONIT.

        if (> 0) return;
      } while (1);

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

    void SETLINE(void) {
      //***********************************************************************

      //*SETLINEBREAKSTHEPARAMETERLISTINTOSINGLECOMMANDS.*

      //************************************************************************

      if (!(*BADCOMP *)) {
        // LASTCOMMANDINPARAMETER.

        if (== '*')
          READLINE();
        else
          ;
        ;
      }

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

    void ASK(int I) {
      //***********************************************************************

      //*ASKCHECKSTHATVALUESTARTSWITHYORNAND*

      //*ASSIGNSTRUEORFALSEACCORDINGLYTOP_OPTARR(I).*

      //***********************************************************************

      int S;

      S = ;
      if (S == 'Y')
        ;
      else if (S == 'N')
        ;
      else
        ;

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

    int STOI(_imp_string SNUM) {
      //***********************************************************************

      //*STOIBUILTSUPANINTEGERININUMFROMTHESTRINGSNUM,IN*

      //*DOINGSOCHARACTERSAREDELETEDFROMTHISSTRING.*

      //*ITISANERRORIFTHEFIRSTCHARACTEROFTHESTRINGISNOTA*

      //*NUMBER.THISISSIGNALLEDBYRETURNING-1.*

      //***********************************************************************

      int I;
      int INUM;

      if (!('0' <= && <= '9')) return -1;
      I = 1;
      INUM = 0;
      while ('0' <= && <= '9') {
        INUM = -'0';
        I = I + 1;
        if (I >) break;
      }
      if (I >=)
        SNUM = "";
      else
        SNUM = ;
      return INUM;

      /* End of Begin/Rt/Fn/Map depth=2 */
    };

    /* End of Begin/Rt/Fn/Map depth=1 */
  };

  exit(0);
  /* End of program */
}