#line 1 "<stdin>"

void ICL9CEZRS6IMP() {
  const int RELEASE;
  const int YES;
  const int NO;
  const int PENTIUM;
  const int MIPS;
  const int RS6;
  const int M88K;
  const int VAX;
  const int UNISYS;
  const int EMAS;
  const int IBM;
  const int IBMXA;
  const int WWC;
  const int AMDAHL;
  const int PERQ3;
  const int GOULD;
  const int VNS;
  const int EAMD;
  const int DRS;
  const int PERQ;
  const int PNX;
  const int ACCENT;
  const int ORN;
  const int UNSIGNEDSHORTS;
  const int LINTAVAIL;
  const int LLREALAVAIL;
  const int EMACHINE;
  const int IBMFPFORMAT;
  const int VAXFPFORMAT;
  const int IEEEFPFORMAT;
  const int BYTESWOPPED;
  const int HALFSWOPPED;
  const int WORDSWOPPED;
  const int RISKMC;
  const int HOST;
  const int TARGET;
  const int STANDARDPT;
  const int MINAPT;
  const int MINAPREC;
  const unsigned short int TYPEFLAG[];
  const char PTRSIZE[];
  const char PTRROUNDING[];
  const int SFRAMEMISALIGN;
  const int AHEADPT;
  const int AHEADSIZE;
  const int MINPARAMSIZE;
  const int RTPARAMPT;
  const int RTPARAMSIZE;
  const int ARRAYROUNDING;
  const int ARRAYINRECROUNDING;
  const int STRVALINWA;
  const int STRRESINWA;
  const int RECVALINWA;
  const char RNDING[];
  const char BYTES[];
  const char WORDS[];
  const int DAREA;
  const int DVAREA;
  const int LHSADDRFIRST;
  const int JRNDBODIES;
  const int STACKDOWN;
  const int PARAMSBWARDS;
  const int DISPLAYNEEDED;
  const int DISPLAYROUNDING;
  const int DISPLAYC1;
  const int DISPLAYC0;
  const int RTPARAM1OFFSET;
  const int ALPHA;
  const Imp_String LADATE;
  const int MAXRECSIZE;
  const int NOOFSNS;
  const int LRLPT;
  const int MAXLEVELS;
  const int CONCOP;
  const int SCONST;
  const int LCONST;
  const int DNAME;
  const int ARNAME;
  const int VIAPTR;
  const int INDNAME;
  const int INDIRECT;
  const int LOCALIR;
  const int REFTRIP;
  const int INAREG;
  const int DEVELOPPED;
  const int DEVADDR;
  const int BTREFMASK;
  const int REFERNEEDED;
  const int RTHD;
  const int RDSPY;
  const int RDAREA;
  const int RDPTR;
  const int RTBAD;
  const int RTXIT;
  const int XSTOP;
  const int NOTL;
  const int LNEG;
  const int IFLOAT;
  const int MODULUS;
  const int SHRTN;
  const int LNGTHN;
  const int JAMSHRTN;
  const int NULLT;
  const int PRELOAD;
  const int SSPTR;
  const int RSPTR;
  const int ASPTR;
  const int DARRAY;
  const int SLINE;
  const int STPCK;
  const int FORPRE;
  const int FORPOST;
  const int FORPR2;
  const int PRECL;
  const int RCALL;
  const int RCRFR;
  const int RCRMR;
  const int GETAD;
  const int RTOI1;
  const int RTOI2;
  const int ITOS1;
  const int MNITR;
  const int PPROF;
  const int RTFP;
  const int ONEV1;
  const int ONEV2;
  const int DVSTT;
  const int DVEND;
  const int FOREND;
  const int DMASS;
  const int RTOI3;
  const int UCNOP;
  const int UCB1;
  const int UCB2;
  const int UCB3;
  const int UCW;
  const int UCBW;
  const int UCWW;
  const int UCLW;
  const int UCB2W;
  const int UCNAM;
  const int ADD;
  const int SUB;
  const int NONEQ;
  const int ORL;
  const int MULT;
  const int INTDIV;
  const int REALDIV;
  const int ANDL;
  const int RSHIFT;
  const int LSHIFT;
  const int REXP;
  const int COMP;
  const int DCOMP;
  const int VMY;
  const int COMB;
  const int VASS;
  const int VJASS;
  const int IEXP;
  const int BADJ;
  const int AINDX;
  const int IFETCH;
  const int LASS;
  const int FORCK;
  const int PRECC;
  const int CONCAT;
  const int IOCPC;
  const int PASS1;
  const int PASS2;
  const int PASS3;
  const int PASS4;
  const int PASS5;
  const int PASS6;
  const int BJUMP;
  const int FJUMP;
  const int REMLB;
  const int TLAB;
  const int DCLSW;
  const int SETSW;
  const int GOTOSW;
  const int STRASS1;
  const int STRASS2;
  const int STRJT;
  const int AHASS;
  const int PTRAS;
  const int MAPRES;
  const int FNRES;
  const int SCOMP;
  const int SDCMP;
  const int PRES1;
  const int PRES2;
  const int RESLN;
  const int RESFN;
  const int SIGEV;
  const int RECASS;
  const int AAINC;
  const int AHADJ;
  const int CTGEN;
  const int GETPTR;
  const int SINDX;
  const int ZCOMP;
  const int CLSHIFT;
  const int CASHIFT;
  const int DVBPR;
  const int RSTORE;
  const int MULTX;

  if (1 << HOST & UNSIGNEDSHORTS == 0) {
  } else {
  }

  const int LEAVESTACKED;
  const int LOADOP1;
  const int LOADOP2;
  const int NOTINREG;
  const int USEESTACK;
  const int USEMSTACK;
  const int CONSTANTOP;
  const int COMMUTABLE;
  const int BSTRUCT;
  const int USEDLATE;
  const int ASSLEVEL;
  const int DONTOPT;

  const int SNPT;
  const int UNASSPAT;
  const int LABUSEDBIT;
  const int LABSETBIT;
  const int MAXDICT;
  int I;
  int K;
  int DUMMYFORMAT;
  int P1SIZE;
  int STARSIZE;
  int ASL;
  int ARSIZE;
  int OLDLINE;
  int NEXTP;
  int SNUM;
  int RLEVEL;
  int NMAX;
  int PLABEL;
  int LEVEL;
  int PROFAAD;
  int LASTINST;
  int LINE;
  int N;
  int BFFLAG;
  int RBASE;
  int Q;
  int R;
  int FNAME;
  int STMTS;
  int FILESIZE;
  int BIMSTR;
  int MAXULAB;
  int SFLABEL;
  int NEXTTRIP;
  int *SSTL;
  int *USTPTR;
  int CURLINEAD;
  int NEXTLINEAD;
  int CURRENTSSALT;
  Imp_String MAINEP;
  extern int CAS[];
  extern recfm PARM;
  extern recfm WORKA;
  if (HOST == IBM || HOST == AMDAHL) {
    extern int *COMREG();

  } else if (HOST == GOULD || HOST == M88K) {
    extern int *COMREG();
  } else {
    extern int *COMREG();
  }
  const int BYTESPERKFORSOURCE;

  {
    recfm *SHDR;
    recfm *WHDR;
    WORKA = 0;
    WORKA = COMREG;
    PARM = 0;
    PARM = COMREG;
    PARM = COMREG | MAXDICT;
    PARM = COMREG;
    PARM = COMREG;
    WORKA = COMREG;
    COMREG = 16;
    WHDR = ;
    WORKA = WHDR >> 10;
    if (WORKA <= 0) {
      if (WORKA < -1)
        FILESIZE = ;
      else
        FILESIZE = 64000;
      WORKA = 0;
    } else {
      SHDR = ;
      FILESIZE = SHDR;
    }
    WORKA = 1023;
    if (WORKA > 513) WORKA = 2047;
    if (WORKA > 1000 || PARM & MAXDICT != 0) WORKA = 4095;
    ASL = 3 * WORKA;
    WORKA = ASL;
    ARSIZE = WORKA * (1024 - BYTESPERKFORSOURCE) - 300;
  }

  char **A;
  recfm ASLIST[];
  int TAGS[];
  int WORD[];
  int DVHEADS[];
  recfm LEVELINF[];

  extern void FREE();
  extern int MALLOC();
  extern void INITASL();
  extern void PRINTTRIPS();
  extern void PHEX();
  extern int MORESPACE();
  extern void INSERTATEND();
  extern void INSERTAFTER();
  extern void POP();
  extern void PUSH();
  extern int FIND();
  extern void BINSERT();
  extern void CLEARLIST();
  extern void FILLDTABREFS();
  extern void CXREF();
  extern void IMPABORT();
  extern void PROLOGUE();
  extern void EPILOGUE();
  extern void PDATA();
  extern void PRDATA();
  extern int PINITOWN();
  extern int POWNARRAYHEAD();
  extern void FAULT();
  extern void WARN();
  extern void TRIPOPT();
  extern void MOVEBYTES();
  extern void CTOP();
  if (HOST != TARGET) {
    extern void REFORMATC();
    extern void CHANGESEX();
  }
  extern void GENERATE();
  extern Imp_String PRINTNAME();
  extern void PRINTLIST();
  K = HOST / 10;
  if (K == 0) K = 1;
  K = BYTESPERKFORSOURCE / K;
  A = ;
  {
    extern int PASSONE();
    WORKA = BYTESPERKFORSOURCE * (WORKA - 1);
    char **CC;
    CC = ;
    WORKA = CC;
    WORKA = A;
    WORKA = WORD;
    WORKA = TAGS;
    WORKA = LINE;
    WORKA = N;
    WORKA = RELEASE;
    WORKA = LADATE;
    WORKA = ;
    WORKA = ;
    WORKA = WORKA / 40 - 2;
    if (WORKA > 699) WORKA = 699;
    WORKA = 0;
    WORKA = 1;
    WORKA = ASLIST;
    PLABEL = 24999;
    N = 12;
    MAXULAB = WORKA + 16384;
    LASTINST = 0;
    SFLABEL = 20999;
    RLEVEL = 0;
    NMAX = 0;
    BFFLAG = 0;
    RBASE = 1;
    SSTL = CAS;
    USTPTR = CAS;
    STMTS = 1;
    SNUM = 0;
    BIMSTR = 0;
    WORKA = 1;
    MAINEP = "s#go";
    INITASL(ASLIST, ASL);
    for (I = 0; I < 12; I += 1) {
      CAS = 0;
      DVHEADS = 0;
    }
    DUMMYFORMAT = 0;
    PUSH(DUMMYFORMAT, 0, 0, 0);
    P1SIZE = PASSONE;
    R = P1SIZE;
    WORKA = P1SIZE;
  }
  if (PARM != 0) {
    COMREG = 8;
    COMREG = PARM;
    return;
  }

  {
    recfm *CURRINF;
    int TWSPHEAD;
    int FORCNT;
    int FORDPTH;
    int FORCECNT;
    int INTERNALBLOCKID;
    if (HOST == EMAS || HOST == IBM) {
      recfm TRIPLES[];

    } else {
      recfm **TRIPLES;
      TRIPLES = ;
    }

    int **CTABLE;
    auto void REUSETEMPS();
    auto void GETWSP();
    auto void RETURNWSP();
    auto void COMPILEASTMNT();
    auto void OUTSYM();
    auto void FORCELINE();
    auto void OUTSTRING();
    auto void OUTINT();
    auto int NEWTRIP();
    auto int FROMAR4();
    auto int FROMAR2();
    auto int UCONSTTRIP();
    auto int ULCONSTTRIP();
    auto int UNAMETRIP();
    auto int UTEMPTRIP();
    auto int BRECTRIP();
    auto int URECTRIP();
    auto void KEEPUSECOUNT();
    auto void CSS();

    static char LSPACE[];
    static recfm OPLINE;
    const int BREAKOPLINES;
    OPLINE = 0;
    OPLINE = LSPACE;
    for (I = 0; I < MAXLEVELS; I += 1) {
      LEVELINF = -1;
    }
    CTABLE = ;
    WORKA = CTABLE;
    WORKA = LEVELINF;
    CTABLE = M 'CTAB';
    TWSPHEAD = 0;
    FORCNT = 0;
    FORDPTH = 0;
    FORCECNT = 0;
    INTERNALBLOCKID = 0;
    PROLOGUE(ASLIST);
    LINE = 0;
    NEXTTRIP = 1;
    TRIPLES = 0;
    NEXTP = 1;
    LEVEL = 1;
    STMTS = 0;
    CURRINF = LEVELINF;
    RLEVEL = 0;
    RBASE = 0;
    CURRINF = 0;
    CURRINF = LEVEL;
    CURRINF = -1;
    while (A | A != 0) {
      COMPILEASTMNT();
    }
    OUTSYM();
    OUTSTRING("/* end of automatic translation */");
    OUTSYM();
    FORCELINE();
    LINE = 99999;
    EPILOGUE(STMTS);
    if (PARM != 0) {
      COMREG = 8;
      STMTS = PARM;
    } else {
      COMREG = 0;
    }
    COMREG = STMTS;
    if (HOST == PERQ) {
      asm();
    } else
      goto;
    int INSERTCURLY() {
      int I;
      int J;
      int K;
      int SCOUNT;
      int RES;
      static char SAVE[];
      SCOUNT = 0;
      if (> OPLINE) = OPLINE;
      for (I = ; I < OPLINE - 1; I += 1) {
        SCOUNT = SCOUNT + 1;
        SAVE = OPLINE;
      }
      OPLINE = ;
      if (!= '#') {
        OUTSYM(9);
        OUTSTRING("/*");
      } else {
        OUTSYM('{');
      }
      J = ;
      I = 0;
      do {
        J = J + 1;
        I = I + 1;
        if (== || == '}') {
          if (!= '#') {
            OUTSTRING("*/");
          } else {
            if (== '}') OUTSYM('}');
          }
          RES = I + 1;
          break;
        } else {
          OPLINE = ;
          OPLINE = OPLINE + 1;
        }
      } while (1);
      for (I = 1; I < SCOUNT; I += 1) {
        OPLINE = SAVE;
        OPLINE = OPLINE + 1;
      }
      return RES;
    }
    int LOCATECURLY() {
      int CCOUNT;
      int FIRSTC;
      int I;
      int BCOUNT;
      int COMMAAFTER;
      CCOUNT = 0;
      BCOUNT = 0;
      COMMAAFTER = 0;
      I = ;
      while (!(== '}' || ==)) I = I + 1;
      if (== '}') {
        I = I + 1;
        while (== ' ') I = I + 1;
        if (== ',') {
          COMMAAFTER = 1;
          CCOUNT = 1;
        }
      }
      for (I = ; I < CURLINEAD; I += -1) {
        if (== ',') {
          if (CCOUNT == 0) FIRSTC = I;
          CCOUNT = CCOUNT + 1;
        }
      }
      if (CCOUNT == 0) return OPLINE;
      if (COMMAAFTER == 0) {
        for (I = FIRSTC; I < -1; I += 1) {
          if (33 <= && <= 127) BCOUNT = BCOUNT + 1;
          if (== '{' || == '}') BCOUNT = BCOUNT + 1;
        }
      }
      for (I = 0; I < OPLINE; I += 1) {
        if (OPLINE == ',' || OPLINE == ';') {
          CCOUNT = CCOUNT - 1;
          if (CCOUNT == 0) goto;
        }
      }
      return OPLINE;
      NEXT;
    NEXT:
      if (COMMAAFTER != 0) return I;
      if (BCOUNT == 0) return I + 1;
      for (I = I; I < OPLINE; I += 1) {
        if (33 <= OPLINE && OPLINE <= 127) BCOUNT = BCOUNT - 1;
        if (BCOUNT == 0) {
          while (I < OPLINE - 1 && 'a' <= OPLINE && OPLINE <= 'z' ||
                 'A' <= OPLINE && OPLINE <= 'Z')
            I = I + 1;
          if (OPLINE == '*' && OPLINE == '/') I = I - 1;
          if (OPLINE == '/' && OPLINE == '*') I = I + 1;
          if (OPLINE == '*' && OPLINE == '/') I = I + 2;
          return I + 1;
        }
      }
      return OPLINE;
    }
    void CURLYCHECK() {
      static int LASTLINEAD;
      int I;
      int AT;
      if (NEXTLINEAD > CURLINEAD && CURLINEAD != LASTLINEAD) {
        for (I = CURLINEAD; I < NEXTLINEAD - 1; I += 1) {
          if (== '{') {
            AT = LOCATECURLY;
            I = I + INSERTCURLY;
          }
        }
        LASTLINEAD = CURLINEAD;
      }
    }
    void FORCELINE() {
      int I;
      int AT;
      extern int FILESSEEN;
      if (FILESSEEN == 0 || LINE < 20000) {
        CURLYCHECK(0);
        if (OPLINE == 0) return;
        for (I = 0; I < OPLINE - 1; I += 1) {
          (OPLINE);
        }
        ();
      }
      I = OPLINE - 1;
      while (I > 0 && OPLINE == '}' || OPLINE ==) I = I - 1;
      if (I >= 0) OPLINE = OPLINE;
      OPLINE = 0;
      OPLINE = -1;
    }
    void OUTSYM() {
      if (==) OPLINE = OPLINE;
      OPLINE = ;
      OPLINE = OPLINE + 1;
      if (CURRENTSSALT == 12 && == ',') {
        OUTSYM();
        return;
      }
      if (OPLINE - OPLINE > BREAKOPLINES) {
        if (OPLINE != '#') {
          if (== ' ' || == ',') OUTSYM();
        }
      }
    }
    void OUTSEP() {
      int I;
      I = OPLINE - 1;
      while (I >= 0 && OPLINE == || OPLINE == '}') {
        I = I - 1;
      }
      if (I >= 0 && OPLINE == ';') return;
      if (I < 0 && OPLINE == ';') return;
      OUTSYM(';');
    }
    void OUTSTRING() {
      int I;
      int J;
      int SYM;
      J = OPLINE;
      for (I = 1; I < ; I += 1) {
        SYM = ;
        if (SYM ==) {
        } else if (SYM == '"') {
        }
      }
      OPLINE = J;
    }
    void OUTCOMMENTEND() {
      if (OPLINE != '*') {
      }
      OUTSTRING("*/");
    }
    Imp_String VALIDNAME() {
      const int NR;
      const Imp_String RNAMES[];
      int I;
      for (I = 0; I < NR; I += 1) {
        if (== RNAMES) {
          = -32;
          return;
        }
      }
      return;
    }
    void REVISENAME() {
      int I;
      return;
      for (I = 1; I < ; I += 1) {
        if ('a' <= && <= 'z') = -32;
      }
    }
    void OUTNAME() {
      int I;
      int AD;
      recfm *LCELL;
      Imp_String NAME;
      I = WORKA;
      AD = ;
      NAME = ;
      LCELL = ASLIST;
      if (LCELL & X 'ff00' == X '4000' && LCELL & X 'f0' == 0) REVISENAME(NAME);
      if (!(LCELL == X '156')) NAME = VALIDNAME;
      OUTSTRING(NAME);
      if (OPLINE - OPLINE > BREAKOPLINES) {
        if (OPLINE != '#') OUTSYM();
      }
    }
    void OUTSWADNAME() {
      int I;
      int AD;
      recfm *LCELL;
      Imp_String NAME;
      I = WORKA;
      AD = ;
      NAME = ;
      LCELL = ASLIST;
      if (LCELL & X 'ff00' == X '4000' && LCELL & X 'f0' == 0) REVISENAME(NAME);
      OUTSTRING(NAME);
      if (CURRINF > 0) {
        OUTSYM('_');
        OUTINT(CURRINF);
      }
    }
    int POSSIBLETYPENAME() {
      int I;
      int AD;
      int J;
      Imp_String NAME;
      Imp_String FIRSTPART;
      Imp_String S;
      Imp_String T;
      I = WORKA;
      AD = ;
      NAME = ;
      J = 0;
      while (NAME * ERROR * S.("type").NAME) {
        if (J == 0)
          FIRSTPART = S;
        else
          FIRSTPART = FIRSTPART."type".S;
        J = J + 1;
      }
      if (NAME == "" && > 3) {
        = FIRSTPART."_type";
        return 1;
      } else {
        = "not_a_valid_type_name";
        return 0;
      }
    }
    void OUTREVISABLENAME() {
      int I;
      int AD;
      Imp_String NAME;
      I = WORKA;
      AD = ;
      NAME = ;
      REVISENAME(NAME);
      OUTSTRING(VALIDNAME);
      if (OPLINE - OPLINE > BREAKOPLINES) {
        if (OPLINE != '#') OUTSYM();
      }
    }
    void OUTFORMATNAME() {
      int I;
      int KK;
      recfm *LCELL;
      Imp_String S;
      for (I = 0; I < WORKA; I += 1) {
        KK = TAGS;
        if (KK != 0) {
          LCELL = ASLIST;
          if (LCELL & 15 == 4 && LCELL ==) {
            if (POSSIBLETYPENAME > 0) {
              OUTSTRING(S);
            } else {
              if (LCELL == 4)
                OUTSTRING("struct ");
              else
                OUTSTRING("union ");
              OUTNAME(I);
            }
            return;
          }
        }
      }
      OUTSTRING(" ? unknown format name ?");
    }
    void OUTEXTERN() {
      if (&3 == 0) {
        OUTSTRING("static const ");
      } else if (== 1) {
        OUTSTRING("static ");
      } else if (== 3) {
        OUTSTRING("extern ");
      }
    }
    void OUTHEX() {
      const Imp_String HEX[];
      int I;
      int DIGIT;
      Imp_String RES;
      RES = "";
      for (I = (8 << 2) - 4; I < 0; I += -4) {
        DIGIT = >> I & 15;
        if (RES != "" || DIGIT != 0) RES = RES.HEX;
      }
      if (RES == "") RES = "0";
      OUTSTRING("0x".RES);
    }
    void OUTTYPE() {
      if (== X '31') {
        OUTSTRING("unsigned char ");
      } else if (== X '41') {
        OUTSTRING("short int ");
      } else if (== X '51') {
        OUTSTRING("int ");
      } else if (== X '61') {
        OUTSTRING("INT64 ");
      } else if (== X '52') {
        OUTSTRING("float ");
      } else if (== X '62') {
        OUTSTRING("double ");
      } else if (== X '72') {
        OUTSTRING("long double ");
      } else if (== X '35') {
        OUTSTRING("char * ");
      } else if (== X '33') {
        OUTFORMATNAME();
        OUTSYM(' ');
      } else {
        OUTSTRING("void ");
      }
    }
    void OUTXTYPE() {
      int ROUT;
      int NAM;
      int ARR;
      int TYPE;
      ROUT = >> 12 & 1;
      NAM = >> 10 & 3;
      ARR = >> 8 & 3;
      TYPE = &7;
      OUTTYPE(&255, );
      if (ROUT != 0 || ARR != 0 && TYPE != 5) OUTSYM('*');
    }
    void OUTLHEX() {
      const Imp_String HEX[];
      int I;
      int DIGIT;
      Imp_String RES;
      RES = "";
      for (I = (8 << 2) - 4; I < 0; I += -4) {
        DIGIT = >> I & 15;
        if (RES != "" || DIGIT != 0) RES = RES.HEX;
      }
      for (I = (8 << 2) - 4; I < 0; I += -4) {
        DIGIT = >> I & 15;
        if (RES != "" || DIGIT != 0) RES = RES.HEX;
      }
      if (RES == "") RES = "0";
      OUTSTRING("0x".RES);
    }
    void OUTINT() {
      int SIGN;
      int WORK;
      int PTR;
      char CH[];
      if (== X '80000000') {
        OUTHEX();
        return;
      }
      SIGN = ' ';
      if (< 0) {
        SIGN = '-';
        = -;
      }
      PTR = 0;
      do {
        WORK = / 10;
        CH = -10 * WORK;
        = WORK;
        PTR = PTR + 1;
      } while (!(== 0));
      WORK = PTR - 1;
      if (SIGN == '-') OUTSYM(SIGN);
      for (PTR = WORK; PTR < 0; PTR += -1) OUTSYM(CH + '0');
    }
    void OUTINTERNAMES() {
      int K;
      int ID;
      for (K = 12; K < 0; K += -4) {
        ID = >> K & 15;
        if (ID != 0) {
          if (ID & 8 != 0) {
            OUTSTRING("s");
            OUTINT(ID & 7);
          } else {
            OUTSTRING("u");
            OUTINT((ID & 7) - 1);
          }
          OUTSYM('.');
        }
      }
    }
    auto void OUTFL();
    void PRINT() {
      const double DZ;
      double Y;
      double Z;
      double ROUND;
      double FACTOR;
      int I;
      int J;
      int L;
      int MORIG;
      char SIGN;
      = &63;
      MORIG = ;
      if (N < 0) N = 1;
      N = N & 31;
      = +DZ;
      SIGN = ' ';
      if (< 0) SIGN = '-';
      Y = ;
      ROUND = 0.5 / REXP(10, );
      if (Y > 1.0 * REXP(10, 16) || N == 0) {
        if (N >) = N;
        OUTFL(, );
        return;
      }
      I = 0;
      Z = 1;
      Y = Y + ROUND;
      while (!(Z > Y)) {
        I = I + 1;
        Z = 10 * Z;
      }
      OUTSYM(SIGN);
      J = I - 1;
      Z = REXP(10, J);
      FACTOR = 1 / 10;
      do {
        while (!(J < 0)) {
          L = ;
          Y = Y - L * Z;
          Z = Z * FACTOR;
          OUTSYM(L + '0');
          J = J - 1;
        }
        if (== 0) break;
        OUTSTRING(".");
        J = -1;
        Z = REXP(10, (J - 1));
        = 0;
        Y = 10 * Y * Z;
      } while (1);
      if (MORIG > 0) {
        while (== '0' && OPLINE != '.') OPLINE = OPLINE - 1;
      }
    }
    void OUTFL() {
      double SIGN;
      double ROUND;
      double FACTOR;
      double LB;
      double UB;
      const double DZ;
      int COUNT;
      int INC;
      INC = ;
      if (INC >> 20 & X '7ff' == X '7ff') {
        OUTSTRING("NAN {");
        OUTHEX(INC);
        OUTHEX();
        OUTSYM('}');
        return;
      }
      ROUND = 0.5 / REXP(10, N);
      LB = 1 - ROUND;
      UB = 10 - ROUND;
      SIGN = 1;
      = +DZ;
      if (== 0)
        COUNT = 0;
      else {
        if (< 0) {
          = -;
          SIGN = -SIGN;
        }
        INC = 1;
        COUNT = 0;
        FACTOR = 1 / 10;
        if (<= 1) {
          FACTOR = 10;
          INC = -1;
        }
        while (< LB || >= UB) {
          = *FACTOR;
          COUNT = COUNT + INC;
        }
      }
      PRINT(SIGN *, 1, N);
      if (COUNT != 0) {
        OUTSTRING("E");
        OUTINT(COUNT);
      }
    }
    void FORCETRIPS() {
      TRIPLES = 0;
      NEXTTRIP = 1;
      TRIPLES = 1;
    }
    void COMPILEASTMNT() {
      int I;
      FORCETRIPS();
      I = NEXTP;
      STARSIZE = (A << 16) + (A << 8) + A;
      NEXTP = NEXTP + STARSIZE;
      LINE = (A << 8) + A;
      CURLINEAD = FROMAR4;
      NEXTLINEAD = FROMAR4;
      STMTS = STMTS + 1;
      OPLINE = LINE;
      CSS(I + 9);
      if (A << 8 | A == LINE) {
        CURLYCHECK(1);
        OUTSYM(9);
      } else {
        FORCELINE();
      }
    }
    int NEXTSTMNTALT() { return A; }
    void CSS() {
      auto void ENTERJUMP();
      auto int ENTERLAB();
      auto void REMOVELAB();
      auto void SAVESTACKPTR();
      auto void CEND();
      auto int CCOND();
      auto int REVERSE();
      auto void SETLINE();
      auto void CUI();
      auto void ASSIGN();
      auto void CSTART();
      auto void CCYCBODY();
      auto void CLOOP();
      auto void CIFTHEN();
      auto int CREATEAH();
      auto void TORP();
      auto int INTEXP();
      auto int CONSTEXP();
      auto void CSEXP();
      auto void LABEXP();
      auto void OUTOPND();
      auto void OUTTRIPLE();
      auto void CSTREXP();
      auto void CRES();
      auto void EXPOP();
      auto void TESTAPP();
      auto void SKIPEXP();
      auto void SKIPAPP();
      auto void NOAPP();
      auto int DOPEVECTOR();
      auto void DECLAREARRAYS();
      auto void DECLARESCALARS();
      auto void CRSPEC();
      auto void CFPLIST();
      auto void CFPDEL();
      auto void CLT();
      auto int ROUNDINGLENGTH();
      auto void CQN();
      auto int TSEXP();
      auto int TCOND();
      auto void CRCALL();
      auto void NAMEOP();
      auto void CNAME();
      auto void CANAME();
      auto void CSNAME();
      auto void COPYTAG();
      auto void REDUCETAG();
      auto void STORETAG();
      auto void UNPACK();
      auto void PACK();
      auto void RDISPLAY();
      auto void RHEAD();
      auto int CFORMATREF();
      auto void CRFORMAT();
      auto void PROCESSFORMAT();
      auto int DISPLACEMENT();
      auto int COPYRECORDTAG();
      auto int CHKRECALIGN();
      SW;
      const char FCOMP[];
      int RFHEAD[];
      int RFBOT[];
      RFALT;
      int RFLEVEL;
      int P;
      int SNDISP;
      int ACC;
      int K;
      int KFORM;
      int STNAME;
      int MIDCELL;
      int TCELL;
      int JJ;
      int JJJ;
      int KK;
      int QQ;
      int MARKER;
      int REPORTUI;
      int XDISP;
      int MASK;
      int BASE;
      int AREA;
      int ACCESS;
      int DISP;
      int EXTRN;
      int CURRINST;
      int VALUE;
      int STRINGL;
      int PTYPE;
      int I;
      int J;
      int OLDI;
      int USEBITS;
      int STRFNRES;
      int MARKIU;
      int MARKUI;
      int MARKC;
      int MARKE;
      int MARKR;
      int INAFORMAT;
      int LITL;
      int ROUT;
      int NAM;
      int ARR;
      int PREC;
      int TYPE;
      int LHFORMATNAME;
      int DOINGLABEL;
      recfm EXPOPND;
      recfm NAMEOPND;
      recfm MLOPND;
      P = ;
      DOINGLABEL = 0;
      CURRINST = 0;
      INAFORMAT = 0;
      CURRENTSSALT = A;
      goto SW;
      SW;
    SW_13 : {
      Imp_String S;
      Imp_String HEAD;
      Imp_String TAIL;
      S = ;
      if (S * ERROR * HEAD.(".inc").TAIL) S = HEAD.".h";
      OUTSTRING("#include ");
      OUTSYM('"');
      OUTSTRING(S);
      OUTSYM('"');
    }
      goto;
      SW;
    SW_24:
      if (A == 10) OUTSYM(' ');
      goto;
    SW_2:
      P = P + 1;
      KK = A;
      P = P + 1;
      JJ = A;
      JJJ = 0;
      if (KK == 1)
        OUTSYM('#');
      else
        OUTSTRING("/*");
      while (JJ !=) {
        if (KK == 1) {
          OUTSYM();
          OUTSYM('#');
        } else {
          OUTCOMMENTEND();
          OUTSYM();
          OUTSTRING("/*");
        }
        JJJ = JJ;
        P = P + 1;
        JJ = A;
      }
    }
    if (KK > 1) OUTCOMMENTEND();
    goto;
  CSSEXIT:
    if (!(OPLINE > 0 && OPLINE == '}')) OUTSEP();
  CSSEXIT2:
    LASTINST = CURRINST;
    return;
  SW_1:
    MARKER = P + 1 + (A << 8) + A;
    P = P + 3;
    if (A == 1) goto;
    if (A == 2) {
      SETLINE();
      CUI(0);
      goto CSSEXIT;
    }
    MARKE = 0;
    MARKR = 0;
    MARKUI = P;
    MARKIU = MARKER + 1;
    MARKC = MARKIU + 1;
    if (A == 3) {
      (MARKIU, MARKC, MARKUI, 0, 0, NO);
      goto CSSEXIT;
    }
    CLOOP(A, MARKC + 2, MARKUI);
    goto CSSEXIT;
  LABFND:
    OLDLINE = 0;
    if (!(A == 1 && A == 2)) goto;
    if (!(A == 2 && A == 2)) goto;
    JJ = ENTERLAB;
    OUTNAME(FROMAR2);
    OUTSYM(':');
    CURLYCHECK(0);
    OUTSYM();
    if (1 << NEXTSTMNTALT & (1 << 6 | 1 << 4 | 1 << 18 | 1 << 9) != 0) OUTSEP();
    goto CSSEXIT2;
  SW_5:
    if (A == 2) {
      CLOOP(0, P + 1, P + 1);
    } else {
      SETLINE();
      CLOOP(6, P + 6, P + 1);
    }
    goto CSSEXIT;
  SW_6:
    goto CSSEXIT2;
  SW_22:
    goto CSSEXIT2;
  SW_3:
    MARKIU = P + 1;
    MARKC = MARKIU + 3;
    MARKR = P + 2 + (A << 8) + A;
    MARKE = 0;
    if (A == 3) {
      MARKE = MARKR + 1 + FROMAR2;
      MARKUI = MARKR + 3;
    }
    CIFTHEN(MARKIU, MARKC, MARKUI, MARKE, MARKR, NO);
    goto CSSEXIT;
  SW_4:
  SW_18:
    goto CSSEXIT2;
  SWITCH : {
    recfm *LCELL;
    recfm *SWDATA;
    int NAPS;
    int FNAME;
    FNAME = FROMAR2;
    if (!(A == 1 && A == 1)) {
      FAULT(5, 0, FNAME);
      goto;
    }
    P = P + 6;
    COPYTAG(FNAME, NO);
    if (OLDI != LEVEL || TYPE != 6) {
      FAULT(4, 0, FNAME);
      goto;
    }
    LCELL = ASLIST;
    SWDATA = ;
    SWDATA = P;
    SWDATA = SWDATA + 1;
    OUTSWADNAME(FNAME);
    OUTSTRING("_");
    LABEXP();
    OUTSYM(':');
    CURLYCHECK(0);
    OUTSYM();
    if (1 << NEXTSTMNTALT & (1 << 6 | 1 << 4 | 1 << 18 | 1 << 9) != 0) OUTSEP();
    BEND;
  BEND:
  }
    if (PARM == 0) FORCETRIPS();
    goto CSSEXIT2;
  SW_23 : {
    recfm *LCELL;
    recfm *SWDATA;
    int FNAME;
    int JJ;
    int RES;
    FNAME = FROMAR2;
    COPYTAG(FNAME, NO);
    if (OLDI == LEVEL && TYPE == 6) {
      LCELL = ASLIST;
      SWDATA = ;
      SWDATA = P;
      OUTSWADNAME(FNAME);
      OUTSTRING("_default:");
    } else
      FAULT(4, 0, FNAME);
  }
    if (PARM == 0) FORCETRIPS();
    goto CSSEXIT2;
    SW;
  SW_7:
    MARKIU = P + 1;
    MARKC = MARKIU + 3;
    CLOOP(A + 3, MARKC, MARKIU + 1 + FROMAR2);
    goto CSSEXIT;
  SW_8:
    P = P + 1;
    MARKER = P + FROMAR2;
    P = P + 2;
    ROUT = 0;
    LITL = 0;
    if (A != 1) {
      CLT();
      if (TYPE == 5 && ACC <= 0 || ACC > 256) {
        (70, ACC - 1, 0);
        ACC = 255;
      }
      NAM = 0;
      SETLINE();
      QQ = 2 - A;
      P = P + 2;
      DECLAREARRAYS(QQ, KFORM);
      if (QQ == 1) goto CSSEXIT2;
      if (PARM == 0) FORCETRIPS();
    } else {
      CLT();
      CQN(P + 1);
      P = P + 2;
      DECLARESCALARS(KFORM);
    }
    goto CSSEXIT;
  SW_9 : {
    S;
    int ETYPE;
    ETYPE = A;
    goto S;
    S;
  S_1:
    OUTSTRING("exit(0);");
    OUTSYM();
  S_2:
    if (PARM == 0) PARM = 2;
    if (!(LEVEL + PARM == 3)) FAULT(15, LEVEL + PARM - 3, 0);
    CEND(PARM);
    if (ETYPE == 1) OUTSYM('}');
    goto;
  S_3:
    goto;
  S_4:
    if (PARM == 1 && LEVEL == 2)
      FAULT(14, 0, 0);
    else
      (CURRINF);
    OUTSTRING("}");
  BEND:
  }
    goto CSSEXIT2;
  SW_11 : {
    int MARKER1;
    int RTNAME;
    int KKK;
    int PTR;
    int PTYPEP;
    int CNT;
    int PP;
    int PCHAIN;
    int AXNAME;
    int PNAME;
    int NPARAMS;
    int SCHAIN;
    int PARMSPACE;
    int D;
    int PARAMPTYPE;
    int PARAMACC;
    int PCOUNT;
    recfm *LCELL;
    recfm *LCELL2;
    recfm *TCELL;
    P = P + 1;
    MARKER1 = FROMAR2 + P;
    MARKC = A;
    AGN;
  AGN:
    Q = P;
    RTNAME = FROMAR2;
    EXTRN = A;
    LITL = EXTRN & 3;
    if (A == 1) {
      P = P + 3;
      CRSPEC(1 - (EXTRN >> 2));
      goto;
    }
    FORCETRIPS();
    COPYTAG(RTNAME, NO);
    AXNAME = ;
    if (EXTRN == 3) EXTRN = 2;
    if (TARGET == EMAS && EXTRN == 1) WARN(11, 0);
    if (A == 1) {
      MOVEBYTES(A + 1, , MARKER1 + 6, , WORKA);
      AXNAME = ;
      WORKA = (WORKA + 4 + A) & (-4);
    }
    if (EXTRN == 4) AXNAME = 0;
    if (OLDI != LEVEL) {
      P = Q + 3;
      CRSPEC(2);
      P = Q;
      goto AGN;
    } else {
      if (PARM == 0) PARM = 2;
      if (!(== 4 || PARM == 2 && LEVEL == 1)) FAULT(56, 0, RTNAME);
      if (A == 1)
        KKK = LITL << 14 | X '1000';
      else {
        ROUT = 1;
        P = P + 4;
        CLT();
        ARR = 0;
        NAM = 0;
        if (A == 2) NAM = 2;
        PACK(KKK);
      }
    }
    if (!(J == 15 || J == 7 * EXTRN && PTYPE & X 'FFFF' == KKK)) {
      P = Q + 3;
      CRSPEC(2);
      P = Q;
      goto AGN;
    }
    PTYPE = PTYPE | (EXTRN & 3) << 14;
    TCELL = ASLIST;
    TCELL = PTYPE;
    if (PTYPE & X 'c000' == X '8000') USEBITS = 2;
    TCELL = TCELL & X '3FF0' | USEBITS << 14;
    if (TARGET == PERQ || TARGET == ACCENT && J == 14) {
      = WORKA;
      WORKA = WORKA + 1;
    }
    PTYPEP = PTYPE;
    if (PTYPEP & X 'c000' == 0) OUTSTRING("static ");
    OUTTYPE(PTYPEP & 255, TCELL);
    if (PTYPEP & X '800' != 0 && PTYPEP & 7 != 5) OUTSYM('*');
    if (AXNAME == 0)
      OUTNAME(RTNAME);
    else
      OUTSTRING();
    OUTSYM('(');
    PCHAIN = TCELL;
    RHEAD(RTNAME, AXNAME, FROMAR2);
    P = MARKER1 + 6;
    if (A == 1) P = P + A + 1;
    CNT = 0;
    PTYPE = PTYPEP;
    UNPACK();
    N = RTPARAM1OFFSET;
    if (TARGET == PERQ || TARGET == ACCENT) {
      if (TYPE != 0) N = (BYTES + 1) & (-2);
      if (TYPE == 5 || TYPE == 3) N = 4;
      if (NAM != 0) {
        if (TYPE == 5)
          N = 4;
        else
          N = PTRSIZE;
      }
      CURRINF = N;
    }
    NPARAMS = 0;
    PARMSPACE = 0;
    if (PCHAIN != 0) NPARAMS = ASLIST;
    if (NPARAMS != 0) {
      = NPARAMS >> 16;
      NPARAMS = NPARAMS & X 'FF';
    }
    while (A == 1) {
      PP = P + 1 + FROMAR2;
      P = P + 3;
      CFPDEL();
      PARAMPTYPE = PTYPE;
      PARAMACC = ACC;
      PTR = P;
      while (!(A == 2)) {
        if (PARAMSBWARDS == YES) {
          PCHAIN = TCELL;
          for (KKK = 2; KKK < NPARAMS - CNT; KKK += 1) PCHAIN = ASLIST;
        }
        LCELL = ASLIST;
        if (PCHAIN != 0) {
          if (!(LCELL == PARAMPTYPE && &X 'FFFF' == PARAMACC))
            FAULT(9, CNT + 1, RTNAME);
        }
        PNAME = FROMAR2;
        LCELL = LCELL | PNAME << 4;
        D = LCELL + N;
        if (PARAMPTYPE & X '1000' != 0) {
          P = PTR;
          while (!(A == 2)) P = P + 3;
          CFPLIST(SCHAIN, KKK);
          PTYPE = PARAMPTYPE;
          OUTTYPE(PARAMPTYPE & 255, KFORM);
          OUTNAME(PNAME);
          OUTSTRING("(");
          LCELL2 = ASLIST;
          if (KKK == 0)
            OUTSTRING("void ");
          else {
            for (PCOUNT = 1; PCOUNT < KKK; PCOUNT += 1) {
              if (LCELL2 & X '10000000' != 0) {
                OUTTYPE(LCELL2 >> 16 & 255, LCELL2);
                OUTSTRING("()");
              } else {
                OUTXTYPE(LCELL2 >> 16, LCELL2);
              }
              if (LCELL2 != 0) OUTSYM(',');
              LCELL2 = ASLIST;
            }
          }
          OUTSTRING(")");
          STORETAG(PNAME, LEVEL, RBASE, 13, D, LCELL, SCHAIN, 0);
        } else {
          if (TARGET == EMAS && PTYPE == X '33') D = D + 8;
          if (STRVALINWA == YES && PTYPE == X '35') PTYPE = X '435';
          OUTXTYPE(PARAMPTYPE, KFORM);
          OUTNAME(PNAME);
          STORETAG(PNAME, LEVEL, RBASE, LCELL & 15, 0, ACC, D, KFORM);
          PTYPE = PARAMPTYPE;
        }
        PTR = PTR + 3;
        CNT = CNT + 1;
        if (PARAMSBWARDS == NO) PCHAIN = LCELL;
        if (!(PCHAIN == 0)) OUTSYM(',');
      }
      P = PP;
    }
    OUTSTRING(") {");
    N = N + PARMSPACE;
    N = (N + MINPARAMSIZE - 1) & (-MINPARAMSIZE);
    if (CNT > NPARAMS) FAULT(8, 0, RTNAME);
    if (CNT < NPARAMS) FAULT(10, 0, RTNAME);
    PTYPE = PTYPEP;
    if (STRRESINWA == YES) {
      if (!(3 != PTYPE & X 'F0F' && PTYPE & X 'F0F' != 5)) N = N + PTRSIZE;
      CURRINF = N;
    }
    N = N + ALPHA;
    if (TARGET == PNX) {
      if (N & 7 != 0) IMPABORT();
    }
    RDISPLAY(RTNAME);
  BEND:
  }
    if (PARM == 0) FORCETRIPS();
    goto CSSEXIT2;
  SW_14 : {
    FORCETRIPS();
    PTYPE = 0;
    if (LEVEL == 1 && RLEVEL == 0) {
      if (PARM == 0) {
        RLEVEL = 1;
        RBASE = 1;
        PARM = 1;
        RHEAD(-1, , 1);
        N = RTPARAM1OFFSET + ALPHA;
        OUTSTRING("main() {");
      } else
        FAULT(58, 0, 0);
    } else {
      SETLINE();
      OUTSTRING("{");
      RHEAD(-1, 0, 1);
    }
    RDISPLAY(-1);
  }
    goto CSSEXIT2;
  SW_15:
    P = P + 2;
    SKIPEXP();
    while (A == 1) {
      P = P + 1;
      SKIPEXP();
    }
    P = P + 1;
    OUTSTRING("if (0) {");
    OUTSYM();
    CSTART(0, 3);
    OUTSTRING(" }");
    goto CSSEXIT;
  SW_16 : {
    int Q;
    int RANGE;
    int KKK;
    int LB;
    int UB;
    int PP;
    int D0;
    int OPHEAD;
    int V;
    int R;
    int DATAD;
    recfm OPND1;
    recfm OPND2;
    recfm *SWDATA;
    Q = P;
    while (!(A == 2)) {
      P = P + 3;
      while (A == 1) P = P + 3;
      P = P + 4;
      KKK = INTEXP;
      P = P + 3;
      KKK = KKK | INTEXP;
      RANGE = (UB - LB + 1);
      if (RANGE <= 0 || KKK != 0) {
        LB = 0;
        UB = 10;
        RANGE = 1024;
      }
      DATAD = MALLOC;
      SWDATA = ;
      SWDATA = 0;
      SWDATA = 0;
      PTYPE = X '56' + (1 << 8);
      PP = P;
      P = Q + 1;
      while (!(A == 2)) {
        K = FROMAR2;
        P = P + 3;
        OPHEAD = 0;
        OPND1 = PTYPE;
        OPND1 = 0;
        OPND1 = DNAME;
        OPND1 = K;
        OPND1 = 0;
        OPND2 = X '61';
        OPND2 = 0;
        OPND2 = DNAME;
        OPND2 = LB;
        OPND2 = UB;
        V = BRECTRIP;
        PUSH(OPHEAD, DATAD, LB, UB);
        STORETAG(K, LEVEL, RBASE, 1, 0, 4, OPHEAD, 0);
        OUTSTRING("int ");
        OUTSWADNAME(K);
        OUTSTRING("_value;");
        OUTSTRING("int ");
        OUTSWADNAME(K);
        OUTSTRING("_line;");
        OUTSTRING("char *");
        OUTSWADNAME(K);
        OUTSTRING("_file;");
      }
      Q = PP;
      P = Q;
    }
  }
    goto CSSEXIT2;
    SW;
  SW_17:
    goto CSSEXIT;
  SW_12 : {
    auto void CLEAR();
    auto void XTRACTCONST();
    auto int INITSPACE();
    int SLENGTH;
    int PP;
    int SIGN;
    int TAGDISP;
    int DVO;
    int K;
    int STALLOC;
    int SPOINT;
    int TP;
    int SAVEP;
    int CONSTSFOUND;
    int CPREC;
    int EXTRN;
    int NNAMES;
    int MARK;
    int QPUTP;
    int LB;
    int CTYPE;
    int CONSTP;
    int FORMAT;
    int DPTYPE;
    int DIMEN;
    int SACC;
    int TYPEP;
    int KK;
    int ORLEVEL;
    int SAVESNDISP;
    int SAVEKFORM;
    int II;
    recfm COPND;
    recfm FCOPND;
    static double ZERO;
    Imp_String SCONST;
    Imp_String NAMTXT;
    recfm *LCELL;
    QPUTP = 5;
    EXTRN = A;
    P = P + 2;
    if (EXTRN >= 4) EXTRN = 0;
    SNDISP = 0;
    CONSTSFOUND = 0;
    if (EXTRN == 0) QPUTP = 4;
    CLT();
    if (A == 1) {
      if (EXTRN == 2)
        EXTRN = 3;
      else
        FAULT(46, 0, 0);
    }
    if (2 <= EXTRN && EXTRN <= 3 && A == 1 && A != 3 || A == 2 && != 2)
      FAULT(46, 0, 0);
    if (TYPE == 5 && A != 1) EXTRN = 1;
    LITL = EXTRN;
    if (LITL <= 1) LITL = LITL ^ 1;
    if (A == 1)
      CQN(P + 1);
    else {
      ARR = 1;
      NAM = 0;
    }
    if (TYPE == 5 && NAM == 0) {
      (70, ACC - 1, 0);
      ACC = 2;
    }
    STALLOC = ACC;
    if (TARGET == PERQ || TARGET == ACCENT && == 5)
      STALLOC = (STALLOC + 1) & X 'FFE';
    ROUT = 0;
    PACK(PTYPE);
    DPTYPE = PTYPE;
    if (NAM != 0) {
      if (ARR != 0)
        STALLOC = 8;
      else
        STALLOC = 4;
    } else {
      if (ARR != 0) goto;
    }
    P = P + 2;
    while (!(A == 2)) {
      MARK = P + 1 + FROMAR2;
      PP = P + 3;
      P = PP + 2;
      K = FROMAR2;
      NAMTXT = ;
      if (A == 1) {
        if (LITL == 0) WARN(10, 0);
        = A;
        for (KK = 1; KK < A; KK += 1) = A;
        P = P + A + 1;
        OUTSTRING("#define ");
        OUTNAME(K);
        OUTSYM(' ');
        OUTSTRING(NAMTXT);
        OUTSYM();
      }
      P = P + 1;
      SCONST = "";
      PTYPE = DPTYPE;
      UNPACK();
      SIGN = 3;
      CTYPE = TYPE;
      CONSTSFOUND = 0;
      CPREC = PREC;
      if (TYPE == 3) CTYPE = 1;
      if (NAM != 0) {
        CTYPE = 1;
        CPREC = 5;
      }
      P = P + 1;
      if (RLEVEL == 0 && EXTRN == 0) {
        OUTSTRING("#define ");
        OUTREVISABLENAME(K);
      } else {
        OUTEXTERN(EXTRN);
        if (PTYPE == X '35')
          OUTSTRING("char ");
        else
          OUTTYPE(PTYPE & 255, KFORM);
        if (NAM != 0) OUTSYM('*');
        OUTNAME(K);
      }
      if (PTYPE == X '35') {
        OUTSTRING(" [");
        OUTINT(STALLOC);
        OUTSYM(']');
      }
      TP = 1;
      if (A == 1) {
        SAVEP = P;
        P = P - 3;
        TP = TSEXP;
        P = SAVEP;
        if (RLEVEL == 0 && EXTRN == 0) {
          OUTSTRING(" ");
          if (TP <= 0) OUTSTRING("(");
        } else {
          OUTSYM('=');
        }
        XTRACTCONST(CTYPE, CPREC);
      } else {
        if (EXTRN == 0) WARN(7, K);
        FCOPND = 0;
        COPND = 0;
      }
      if (RLEVEL == 0 && EXTRN == 0) {
        if (TP <= 0) OUTSYM(')');
      } else {
        OUTSEP();
      }
      if (!(A == 2)) OUTSYM();
      PTYPE = DPTYPE;
      UNPACK();
      J = 0;
      ORLEVEL = 0;
      if (NAM != 0) {
        if (ARR == 0) {
          if (TARGET == IBM || TARGET == AMDAHL && == 0) {
            TAGDISP = WORKA;
            if (TYPE == 5) {
              CTABLE = ACC;
              = WORKA + 1;
            }
            CTABLE = FCOPND;
            WORKA = WORKA + 1;
            if (WORKA > WORKA) (102, WORKA, 0);
            TAGDISP = 4 * TAGDISP;
            ORLEVEL = 14;
          } else
            TAGDISP = PINITOWN;
        } else {
          if (PARM != 0 && LB != 0) FAULT(99, 0, 0);
          if (EXTRN != 0) {
            SNDISP = 0;
            J = 0;
          } else {
            = 1;
            SNDISP = (SNDISP & X '3FFFF') >> 2;
          }
          TAGDISP = POWNARRAYHEAD;
        }
        STORETAG(K, LEVEL, ORLEVEL, J, SNDISP, ACC, TAGDISP, KFORM);
        P = MARK;
        continue;
      }
      if (EXTRN == 3) {
        FCOPND = 0;
        TAGDISP = PINITOWN;
        STORETAG(K, LEVEL, 0, J, SNDISP, ACC, TAGDISP, KFORM);
        P = MARK;
        continue;
      }
      if (TYPE == 3) {
        TAGDISP = PINITOWN;
      }
      if (1 << TYPE & B '100110' != 0) {
        if (EXTRN != 0) {
          TAGDISP = PINITOWN;
        } else
          TAGDISP = 0;
      }
      STORETAG(K, LEVEL, 0, J, SNDISP, ACC, TAGDISP, KFORM);
      if (EXTRN == 0 && 0 == NAM && 1 << TYPE & B '100110' != 0) {
        LCELL = ASLIST;
        LCELL = LCELL | (COPND & 8) << 16;
        LCELL = COPND;
        LCELL = COPND;
        if (TYPE == 5) {
          LCELL = WORKA;
          WORKA = (WORKA + COPND + 4) & (-4);
        }
      }
      P = MARK;
    }
    goto;
    NONSCALAR;
  NONSCALAR:
    P = P + 1;
    FORMAT = 2 - A;
    if (FORMAT != 0) {
      ARR = 3;
      PACK(PTYPE);
    }
    PP = P + 2;
    P = P + 4;
    NNAMES = 1;
    K = FROMAR2;
    NAMTXT = ;
    if (A == 1) {
      if (LITL == 0) WARN(10, 0);
      = A;
      for (KK = 1; KK < A; KK += 1) = A;
      P = P + A + 1;
    }
    P = P + 1;
    SACC = ACC;
    TYPEP = PTYPE;
    SAVEKFORM = KFORM;
    DVO = DOPEVECTOR;
    if (SNDISP == -1) SNDISP = 0;
    SNDISP = (SNDISP & X '3FFFF') >> 2;
    SAVESNDISP = SNDISP;
    DIMEN = J;
    ACC = SACC;
    PTYPE = TYPEP;
    UNPACK();
    PP = P;
    {
      short int SAVEDP;
      short int SAVEDP2;
      short int SAVEDPTYPE;
      int I;
      int COUNT;
      COUNT = 0;
      if (FORMAT == 0) {
        SAVEDPTYPE = PTYPE & 255;
        OUTEXTERN(EXTRN);
        OUTTYPE(SAVEDPTYPE, SAVEKFORM);
        for (II = DIMEN; II < 1; II += -1) {
          for (I = 1; I < II; I += 1) OUTSYM('*');
          OUTNAME(K);
          if (II != DIMEN) {
            OUTSYM('_');
            OUTINT(II);
          }
          if (II != 1) OUTSYM(',');
        }
        OUTSYM(';');
        OUTSYM();
        OUTEXTERN(EXTRN);
        OUTSTRING("int ");
        for (II = DIMEN; II < 1; II += -1) {
          OUTNAME(K);
          OUTSTRING("_dim_");
          OUTINT(II);
          if (II != 1) OUTSYM(',');
        }
        OUTSYM(';');
        OUTSYM();
        for (II = DIMEN; II < 1; II += -1) {
          OUTNAME(K);
          if (II != DIMEN) {
            OUTSYM('_');
            OUTINT(II);
          }
          P = CTABLE;
          SAVEDP = P;
          OUTSTRING(" = (");
          OUTTYPE(SAVEDPTYPE, SAVEKFORM);
          for (I = 1; I < II; I += 1) OUTSYM('*');
          OUTSTRING(")malloc(((");
          CSEXP(X '51');
          OUTSYM(')');
          if (CTABLE == X '80000000') {
            OUTSYM('-');
            P = CTABLE;
            OUTSYM('(');
            CSEXP(X '51');
            OUTSTRING(")+1");
          } else if (CTABLE < 1) {
            OUTSYM('+');
            OUTINT(1 - CTABLE);
          } else if (CTABLE > 1) {
            OUTSYM('-');
            OUTINT(CTABLE - 1);
          }
          OUTSTRING(") * sizeof(");
          OUTTYPE(SAVEDPTYPE, SAVEKFORM);
          for (I = 1; I < II - 1; I += 1) OUTSYM('*');
          OUTSTRING(") );");
          OUTSYM();
          if (CTABLE == X '80000000') {
            OUTNAME(K);
            if (II != DIMEN) {
              OUTSYM('_');
              OUTINT(II);
            }
            OUTSTRING(" -= ");
            P = CTABLE;
            CSEXP(X '51');
          } else if (CTABLE != 0) {
            OUTNAME(K);
            if (II != DIMEN) {
              OUTSYM('_');
              OUTINT(II);
            }
            OUTSTRING(" -= ");
            OUTINT(CTABLE);
          }
          OUTSYM(';');
          OUTSYM();
          OUTSTRING("for (");
          OUTNAME(K);
          OUTSTRING("_dim_");
          OUTINT(II);
          OUTSTRING(" = ");
          if (CTABLE == X '80000000') {
            P = CTABLE;
            CSEXP(X '51');
          } else if (CTABLE != 0) {
            OUTINT(CTABLE);
          } else
            OUTINT(0);
          OUTSTRING("; ");
          OUTNAME(K);
          OUTSTRING("_dim_");
          OUTINT(II);
          OUTSTRING(" <= ");
          CSEXP(X '51');
          OUTSTRING("; ");
          OUTNAME(K);
          OUTSTRING("_dim_");
          OUTINT(II);
          OUTSTRING("++) {");
          OUTSYM();
        }
        for (II = 1; II < DIMEN; II += 1) {
          if (II != 1) {
            OUTNAME(K);
            if (II != DIMEN) {
              OUTSYM('_');
              OUTINT(II);
            }
            OUTSTRING("[");
            OUTNAME(K);
            OUTSTRING("_dim_");
            OUTINT(II);
            OUTSTRING("] = ");
            OUTNAME(K);
            OUTSYM('_');
            OUTINT(II - 1);
            OUTSTRING(";");
            OUTSYM();
          } else {
            OUTSTRING("/* Assign initialised elements if any */");
            OUTSYM();
          }
          OUTSYM('}');
          OUTSYM();
        }
        OUTSYM('{');
        OUTSYM();
        OUTEXTERN(EXTRN);
        OUTTYPE(SAVEDPTYPE, SAVEKFORM);
        OUTNAME(K);
        OUTSTRING("_data[] ");
      }
      PTYPE = TYPEP;
      UNPACK();
      if (LB == 0 && FORMAT == 0) {
        ARR = 2;
        PACK(PTYPE);
      }
      if (TYPE == 3)
        SLENGTH = QQ;
      else
        SLENGTH = QQ / STALLOC;
      CAS = (CAS + ARRAYROUNDING) & (~ARRAYROUNDING);
      SPOINT = CAS;
      if (FORMAT == 0) {
        if (A == 1) {
          P = PP + 1;
          COUNT = INITSPACE;
        }
      }
      if (FORMAT == 0) OUTSEP();
      if (EXTRN == 3) SPOINT = 0;
      PTYPE = TYPEP;
      UNPACK();
      if (FORMAT != 0) QPUTP = 0;
      TAGDISP = POWNARRAYHEAD;
      SNDISP = SAVESNDISP;
      STORETAG(K, LEVEL, 0, DIMEN, SNDISP, ACC, TAGDISP, SAVEKFORM);
      OUTSYM();
      OUTSTRING("int ");
      OUTNAME(K);
      OUTSTRING("_inels = 0;");
      OUTSYM();
      ACC = SACC;
      PTYPE = TYPEP;
      UNPACK();
      PP = P;
      for (II = DIMEN; II < 1; II += -1) {
        P = CTABLE;
        OUTSTRING("for (");
        OUTNAME(K);
        OUTSTRING("_dim_");
        OUTINT(II);
        OUTSTRING(" = ");
        SAVEDP = P;
        if (CTABLE == X '80000000') {
          P = CTABLE;
          CSEXP(X '51');
        } else if (CTABLE != 0) {
          OUTINT(CTABLE);
        } else
          OUTINT(0);
        OUTSTRING("; ");
        OUTNAME(K);
        OUTSTRING("_dim_");
        OUTINT(II);
        OUTSTRING(" <= ");
        P = SAVEDP;
        CSEXP(X '51');
        OUTSTRING("; ");
        OUTNAME(K);
        OUTSTRING("_dim_");
        OUTINT(II);
        OUTSTRING("++) {");
        OUTSYM();
        OUTSTRING("if (");
        OUTNAME(K);
        OUTSTRING("_inels == ");
        OUTINT(COUNT);
        OUTSTRING(") break;");
        OUTSYM();
        if (CTABLE == X '80000000') {
          P = CTABLE;
        }
      }
      OUTNAME(K);
      for (II = DIMEN; II < 1; II += -1) {
        OUTSTRING("[");
        OUTNAME(K);
        OUTSTRING("_dim_");
        OUTINT(II);
        OUTSTRING("]");
      }
      OUTSTRING(" = ");
      OUTNAME(K);
      OUTSTRING("_data[");
      OUTNAME(K);
      OUTSTRING("_inels++];");
      OUTSYM();
      for (II = DIMEN; II < 1; II += -1) {
        OUTSTRING("}");
        OUTSYM();
      }
      OUTSYM('}');
      OUTSYM();
    }
    goto;
    int INITSPACE() {
      const int BUFSIZE;
      int RF;
      int I;
      int II;
      int ELSIZE;
      int AD;
      int SPP;
      int SLENGTH;
      int WRIT;
      int PIN;
      int PP;
      int CONTYPE;
      int CONPREC;
      int PPP;
      int VALUE;
      int NELSOUT;
      NELSOUT = 0;
      PIN = P;
      CONTYPE = TYPE;
      CONPREC = PREC;
      OUTSTRING(" = {");
      SPP = 0;
      WRIT = 0;
      while (!(A == 2)) {
        P = P - 3;
        PP = P;
        SKIPEXP();
        if (A == 1) {
          P = P + 2;
          if (A == 2) {
            RF = 1;
            if (!(A == 4 && A == 2)) WARN(10, 0);
          } else {
            P = P + 2;
            if (INTEXP != 0) {
              WARN(10, 0);
              RF = 1;
            }
          }
          P = P + 1;
        } else {
          RF = 1;
          P = P + 2;
        }
        NELSOUT = NELSOUT + RF;
        if (RF <= 0) WARN(10, 0);
        SPP = P;
        for (I = RF; I < 1; I += -1) {
          P = PP;
          if (CONTYPE == 5)
            CSTREXP(1);
          else
            CSEXP(CONPREC << 4 | CONTYPE);
          CONSTSFOUND = CONSTSFOUND + 1;
          if (!(I == 1 && A == 2)) OUTSYM(',');
          if (CONTYPE == 5 && CONSTSFOUND & 3 == 0 || CONSTSFOUND & 7 == 0)
            OUTSYM();
        }
        P = SPP;
      }
      OUTSTRING("}");
      return NELSOUT;
    }
    void XTRACTCONST() {
      int SLENGTH;
      int STYPE;
      int SACC;
      int MODE;
      int CH;
      int WR;
      int I;
      int PP;
      STYPE = PTYPE;
      SACC = ACC;
      if (== 5) {
        P = P - 3;
        CSTREXP(1);
        WR = WORKA;
        if (EXPOPND == LCONST && EXPOPND == X '35') {
          SLENGTH = EXPOPND;
          = SLENGTH;
          A = SLENGTH;
          for (I = 1; I < SLENGTH; I += 1) {
            CH = A;
            = CH;
            A = CH;
          }
          COPND = X '35';
          COPND = LCONST;
          COPND = EXPOPND;
          COPND = SLENGTH;
        } else {
          FAULT(44, CONSTSFOUND, K);
          SCONST = "";
          SLENGTH = 0;
        }

      } else {
        MODE = << 4 | ;
        if (< 5) MODE = | X '50';
        PP = P;
        P = P - 3;
        CSEXP(MODE);
        P = PP;
        I = CONSTEXP;
        COPND = EXPOPND;
        COPND = MODE;
      }
      PTYPE = STYPE;
      UNPACK();
      ACC = SACC;
      FCOPND = COPND;
    }
    BEND;
  BEND:
  }
    goto CSSEXIT2;
  SW_10 : {
    int NAME;
    int OPHEAD;
    int OPBOT;
    int NLIST;
    int HEADCELL;
    int FHEAD;
    int SPEC;
    int L1;
    int L2;
    int STRID;
    int FPT;
    recfm *LCELL;
    recfm *FRCELL;
    Imp_String TYPENAME;
    SNDISP = 0;
    SPEC = A;
    NAME = FROMAR2;
    P = P + 4;
    COPYTAG(NAME, NO);
    if (SPEC == 1 || !(PTYPE == 4 && J == 15)) {
      KFORM = 0;
      PUSH(KFORM, 0, 0, 0);
      PTYPE = 4;
      STORETAG(NAME, LEVEL, RBASE, 15, 0, MAXRECSIZE, KFORM, KFORM);
    }
    if (SPEC == 2) {
      OPHEAD = 0;
      OPBOT = 0;
      NLIST = 0;
      for (L1 = 0; L1 < 12; L1 += 1) {
        for (L2 = 0; L2 < 12; L2 += 1) {
          RFHEAD = 0;
          RFBOT = 0;
        }
        RFALT = 0;
      }
      INAFORMAT = 1;
      RFLEVEL = 0;
      CRFORMAT(RFLEVEL);
      INAFORMAT = 0;
      if (PARM != 0) {
        for (L1 = 0; L1 < 12; L1 += 1) {
          for (L2 = 0; L2 < 12; L2 += 1) {
            if (RFHEAD != 0) {
              ("level&rfalt=");
              (L1, 5);
              (L2, 5);
              ();
              PRINTLIST(RFHEAD);
            }
          }
        }
      }
      STRID = 0;
      HEADCELL = RFHEAD;
      if (HEADCELL == 0) {
        OUTSTRING("struct ");
        OUTNAME(NAME);
        OUTSYM('{');
        OUTSYM();
        PROCESSFORMAT(0, 0, 's', 0, STRID, OPHEAD, OPBOT);
        FPT = 4;
      } else {
        OUTSTRING("union ");
        OUTNAME(NAME);
        OUTSYM('{');
        OUTSYM();
        PROCESSFORMAT(0, 0, 'u', 0, STRID, OPHEAD, OPBOT);
        FPT = X '14';
      }
      OUTSYM('}');
      OUTSYM(';');
      OUTSYM();
      if (PARM != 0) {
        ("after processing");
        PRINTLIST(OPHEAD);
      }
      if (POSSIBLETYPENAME != 0) {
        OUTSYM();
        OUTSTRING("typedef ");
        if (HEADCELL == 0) {
          OUTSTRING("struct ");
        } else {
          OUTSTRING("union ");
        }
        OUTNAME(NAME);
        OUTSTRING(" ".TYPENAME.";");
        OUTSYM();
      }
      CLEARLIST(NLIST);
      LCELL = ASLIST;
      KFORM = LCELL;
      if (PARM != 0) {
        ("before throwing dummy cell");
        PRINTLIST(KFORM);
      }
      POP(KFORM, I, I, FHEAD);
      FHEAD = OPHEAD;
      while (FHEAD > 0) {
        FRCELL = ASLIST;
        if (FRCELL == X '433' && FRCELL == LCELL) {
          FRCELL = FRCELL & X 'FFFFFFF0';
          FRCELL = ACC;
          FRCELL = OPHEAD;
        }
        FHEAD = FRCELL;
      }
      LCELL = LCELL & X 'FFFFFFF0';
      LCELL = ACC;
      LCELL = NAME;
      LCELL = FPT;
      LCELL = OPHEAD;
      if (PARM != 0) {
        ("after processing self refs");
        PRINTLIST(OPHEAD);
      }
    }
  }
    goto CSSEXIT2;
    SW;
  SW_19:
    OUTSTRING("***Untranslateable stmnt***");
    I = CURLINEAD;
    while (I < NEXTLINEAD) {
      OUTSYM();
      I = I + 1;
    }
    goto CSSEXIT;
  SW_20:
    if (PARM == 0 && PARM == 0) PARM = 1;
    goto CSSEXIT;
  SW_21:
    KK = FROMAR2;
    if (!(PARM == 0)) FAULT(97, 0, 0);
    MAINEP = ;
    goto CSSEXIT;
    int CFORMATREF() {
      int FNAM;
      int OPHEAD;
      int OPBOT;
      int NHEAD;
      int MRL;
      recfm *LCELL;
      if (A == 1) {
        FNAM = FROMAR2;
        P = P + 3;
        COPYTAG(FNAM, NO);
        if (3 <= TYPE && TYPE <= 4) return KFORM;
        if (INAFORMAT != 0 && OLDI != LEVEL) {
          PTYPE = 4;
          ACC = MAXRECSIZE;
          PUSH(KFORM, 0, 0, 0);
          STORETAG(FNAM, LEVEL, RBASE, 15, 0, MAXRECSIZE, KFORM, KFORM);
          return KFORM;
        }
        FAULT(62, 0, FNAM);
        ACC = 8;
        return DUMMYFORMAT;
      }
      P = P + 1;
      OPHEAD = 0;
      OPBOT = 0;
      OUTSTRING("*** imp construction too difficult***");
      return OPHEAD;
    }
    void CRFORMAT() {
      int D1;
      int D2;
      int FORM;
      int RL;
      int STALLOC;
      int INC;
      int Q;
      int R;
      int RFD;
      int LB;
      int TYPEP;
      int SACC;
      int DVO;
      auto void SN();
      auto void ROUND();
      FORM = 0;
      ACC = 0;
      INC = 0;
      do {
        ROUT = 0;
        LITL = 0;
        NAM = 0;
        RFD = A;
        P = P + 1;
        if (RFD == 1) {
          CLT();
          FORM = KFORM;
          STALLOC = ACC;
          P = P + 1;
          if (A == 1) {
            FORM = KFORM;
            CQN(P);
            P = P + 1;
            PACK(PTYPE);
            D2 = 0;
            RL = ROUNDINGLENGTH;
            if (NAM == 1) {
              STALLOC = PTRSIZE;
              RL = PTRROUNDING;
              if (ARR != 0) {
                STALLOC = AHEADSIZE;
                RL = ROUNDINGLENGTH;
              }
            }
            if (TYPE == 5 && STALLOC == 0) FAULT(70, 0, 0);
            ROUND();
            J = 0;
            while (!(A == 2)) {
              D1 = 0;
              SN(P);
              P = P + 3;
              INC = INC + STALLOC;
            }
          } else {
            Q = P + 1;
            ARR = 1;
            PACK(PTYPE);
            do {
              P = Q;
              while (!(A == 2)) P = P + 3;
              TYPEP = PTYPE;
              SACC = ACC;
              D2 = DOPEVECTOR >> 2;
              ACC = SACC;
              PTYPE = TYPEP;
              UNPACK();
              RL = ROUNDINGLENGTH;
              if (RL < ARRAYINRECROUNDING) = ARRAYINRECROUNDING;
              do {
                ROUND();
                D1 = 0;
                SN(Q);
                Q = Q + 3;
              } while (!(A == 2));
              P = P + 1;
              Q = P + 1;
            } while (!(A == 2));
          }

        } else {
          RFLEVEL = RFLEVEL + 1;
          BINSERT(RFHEAD, RFBOT, 0, RFLEVEL, 0);
          CRFORMAT(RFLEVEL);
          INC = ACC;
        }
        P = P + 1;
      } while (!(A == 2));
      if (A == 1) {
        P = P + 1;
        RFALT = RFALT + 1;
        CRFORMAT();
        if (ACC > INC) INC = ACC;
      } else
        P = P + 1;
      ACC = INC;
      return;
      void SN() {
        recfm CELL;
        FNAME = FROMAR2;
        if (ASLIST == X '4051') WARN(11, 0);
        CELL = PTYPE;
        CELL = FNAME << 4 | J;
        CELL = ACC;
        CELL = D2 & X 'FFFF';
        CELL = D1 & X 'FFFF';
        CELL = FORM;
        BINSERT(RFHEAD, RFBOT, CELL, CELL, CELL);
      }
      void ROUND() {}
    }
    void OUTFMTCELL() {
      int PT;
      int NAME;
      int DVDISP;
      int ND;
      int II;
      recfm *FCELL;
      PT = >> 16;
      NAME = >> 4 & X 'FFF';
      if (PT & X 'cff' == X '35') {
        OUTSTRING("char ");
        OUTNAME(NAME);
      } else {
        OUTXTYPE(PT & X 'cff', );
        OUTNAME(NAME);
      }
      if (PT & X '300' != 0) {
        ND = &15;
        DVDISP = ;
        for (II = ND; II < 1; II += -1) {
          P = CTABLE;
          OUTSTRING(" [");
          CSEXP(X '51');
          if (CTABLE == X '80000000') {
            OUTSYM('-');
            P = CTABLE;
            OUTSYM('(');
            CSEXP(X '51');
            OUTSTRING(")+1");
          } else if (CTABLE < 1) {
            OUTSYM('+');
            OUTINT(1 - CTABLE);
          } else if (CTABLE > 1) {
            OUTSYM('-');
            OUTINT(CTABLE - 1);
          }
          OUTSYM(']');
        }
      }
      if (PT & X 'cff' == X '35') {
        OUTSYM('[');
        OUTINT();
        OUTSYM(']');
      }
      OUTSEP();
      OUTSYM();
    }
    void PROCESSFORMAT() {
      recfm LCELL;
      int I;
      int J;
      int K;
      int NEWID;
      int LSTRID;
      if (== 's') {
        while (RFHEAD != 0) {
          POP(RFHEAD, LCELL, LCELL, LCELL);
          if (LCELL != 0) {
            OUTFMTCELL(LCELL);
            LCELL = ;
            BINSERT(, , LCELL, LCELL, LCELL);
          } else {
            NEWID = << 4 | (LCELL);
            OUTSTRING("union {");
            OUTSYM();
            PROCESSFORMAT(LCELL, 0, 'u', NEWID, , , );
            OUTSTRING("} u");
            OUTINT(LCELL - 1);
            OUTSYM(';');
            OUTSYM();
          }
        }
      } else {
        for (I = ; I < RFALT; I += 1) {
          if (RFHEAD == RFBOT) {
            POP(RFHEAD, LCELL, LCELL, LCELL);
            if (LCELL != 0) {
              OUTFMTCELL(LCELL);
              LCELL = ;
              BINSERT(, , LCELL, LCELL, LCELL);
            } else {
              NEWID = << 4 | (LCELL);
              OUTSTRING("union {");
              OUTSYM();
              PROCESSFORMAT(LCELL, 0, 'u', NEWID, , , );
              OUTSTRING("} u");
              OUTINT(LCELL - 1);
              OUTSYM(';');
              OUTSYM();
            }
          } else {
            LSTRID = ;
            = +1;
            NEWID = << 4 | 8 | LSTRID;
            OUTSTRING("struct {");
            OUTSYM();
            PROCESSFORMAT(LEVEL, I, 's', NEWID, , , );
            OUTSTRING("} s");
            OUTINT(LSTRID);
            OUTSYM(';');
            OUTSYM();
          }
        }
      }
    }
    int DISPLACEMENT() {
      recfm *FCELL;
      recfm *PCELL;
      recfm *LCELL;
      recfm TOPND;
      int RR;
      int II;
      int ENAME;
      int CELL;
      ENAME = (A << 8) + A;
      CELL = 0;
      if (!= 0) {
        FCELL = ASLIST;
        CELL = ;
        II = -1;
        ACC = -1;
        while (> 0) {
          LCELL = ASLIST;
          if (LCELL << 16 >> 20 == ENAME) {
            TCELL = ;
            SNDISP = LCELL;
            K = LCELL;
            J = LCELL & 15;
            PTYPE = LCELL;
            ACC = LCELL & X 'FFFF';
            SNDISP = LCELL;
            KFORM = LCELL;
            if (!= CELL) {
              PCELL = LCELL;
              LCELL = FCELL;
              FCELL = ;
            }
            return K;
          }
          PCELL = LCELL;
          = LCELL;
        }
      }
      FAULT(65, 0, ENAME);
      if (CELL > 0) {
        TOPND = X '51';
        TOPND = ENAME << 4;
        PUSH(ASLIST, TOPND, 0, 0);
      }
      PTYPE = X '51';
      TCELL = 0;
      UNPACK();
      return -1;
    }
    int COPYRECORDTAG() {
      int Q;
      int FNAME;
      = 0;
      while (!(TYPE != 3)) {
        FNAME = KFORM;
        P = P + 2;
        SKIPAPP();
        if (A == 2 || FNAME <= 0) return 0;
        = +1;
        P = P + 1;
        Q = DISPLACEMENT;
        UNPACK();
      }
      return Q + 1;
    }
    int CHKRECALIGN() {
      int CELL;
      int I;
      auto int SCAN();
      P = ;
      REDUCETAG(NO);
      CELL = KFORM;
      return SCAN;
      int SCAN() {
        int J;
        while (CELL != 0) {
          I = ASLIST >> 4 & 7;
          if (I >= 5) return I;
          if (ASLIST == X '33') {
            I = SCAN;
            if (I >= 5) return I;
          }
          CELL = ASLIST;
        }
        return 0;
      }
    }
    void CRNAME() {
      int DEPTH;
      int FNAME;
      int EMNAME;
      auto void CENAME();
      recfm HDOPND;
      HDOPND = 0;
      DEPTH = 0;
      EMNAME = &X 'FFFF';
      FNAME = KFORM;
      if (ARR == 0 || 6 <= && <= 7 && A == 2) {
        if (A == 2)
          P = P + 3;
        else
          NOAPP();
        CENAME(, FNAME, , , 0);
      } else {
        HDOPND = AHEADPT;
        HDOPND = LOCALIR;
        HDOPND = << 16 | ;
        CANAME(, ARR, HDOPND);
        = -1;
        CENAME(ACCESS, FNAME, BASE, DISP, 0);
      }
      return;
      void CENAME() {
        auto void FETCHRAD();
        int Q;
        int QQ;
        int D;
        int C;
        int TR;
        int ENAME;
        int RPTYPE;
        int EPTYPE;
        recfm RADOPND;
        recfm OPND1;
        recfm *LCELL;
        DEPTH = DEPTH + 1;
        RPTYPE = PTYPE;
        if (A == 2) {
          ACCESS = ;
          XDISP = ;
          BASE = ;
          DISP = ;
          if (< 14) {
            if (!(3 <= && <= 4 || == 6)) {
              FAULT(64, 0, EMNAME);
              BASE = RBASE;
              DISP = 0;
              ACCESS = 0;
              PTYPE = X '51';
              UNPACK();
            }
          }
          return;
        }
        P = P + 1;
        Q = DISPLACEMENT;
        EPTYPE = PTYPE;
        UNPACK();
        ENAME = A << 8 | A;
        = ENAME << 16 | ;
        if (RPTYPE & X 'f00' == X '400')
          OUTSTRING("->");
        else
          OUTSTRING(".");
        OUTINTERNAMES(Q);
        OUTNAME(ENAME);
        if (ARR == 1) goto;
        if (A == 2)
          P = P + 3;
        else
          NOAPP();
        if (TYPE <= 2 || TYPE == 5) {
          ACCESS = +4 + 4 * NAM;
          BASE = ;
          DISP = ;
          XDISP = +Q;
          return;
        }
        = +Q;
        = | X 'FFFF0000';
        if (NAM == 1) {
          = +4;
          FETCHRAD();
          EXPOPND = RADOPND;
          = 3;
          = 0;
          = 0;
          = 0;
          = -1;
        }
        CENAME(, KFORM, , , );
        return;
        AE;
      AE:
        LCELL = ASLIST;
        ACC = LCELL & X 'FFFF';
        SNDISP = LCELL & X 'FFFF';
        KFORM = LCELL;
        K = LCELL & X 'ffff';
        C = ACC;
        D = SNDISP;
        Q = K;
        QQ = KFORM;
        if (== 6 || >= 11 && A == 2) {
          P = P + 3;
          if (NAM == 1) {
            ACCESS = +8;
            BASE = ;
            DISP = ;
            XDISP = +Q;
            PTYPE = AHEADPT;
            NAMEOP(6, 8, );
            return;
          }
          FETCHRAD();
          = -1;
          OPND1 = 0;
          OPND1 = AHEADPT;
          OPND1 = LOCALIR;
          OPND1 = Q;
          NAMEOPND = CREATEAH;
          NAMEOPND = AHEADPT;
          NAMEOPND = REFTRIP;
          NAMEOPND = 0;
        } else {
          if (NAM == 1) {
            = +Q;
            ACCESS = +8;
            BASE = ;
            DISP = ;
            XDISP = ;
            NAMEOP(6, AHEADSIZE, );
            OPND1 = NAMEOPND;
            OPND1 = AHEADPT;
            PTYPE = LCELL;
            UNPACK();
            CANAME(, 3, OPND1);
            = 0;
          } else {
            FETCHRAD();
            OPND1 = 0;
            OPND1 = AHEADPT;
            OPND1 = LOCALIR;
            OPND1 = Q;
            CANAME(, 3, OPND1);
            TR = 0;
            EXPOPND = REFTRIP;
            EXPOPND = TR;
            = 0;
          }
          = -1;
          XDISP = ;
          if (TYPE == 3) {
            CENAME(ACCESS, QQ, BASE, DISP, );
            C = ACC;
          } else {
            if (>= 11) FAULT(17, 0, ENAME);
          }
        }
        ACC = C;
        return;
        void FETCHRAD() {
          ACCESS = +4;
          BASE = ;
          DISP = ;
          XDISP = ;
          PTYPE = RPTYPE;
          UNPACK();
          NAMEOP(4, 4, );
          PTYPE = EPTYPE;
          UNPACK();
          RADOPND = NAMEOPND;
        }
      }
    }
    void CSTREXP() {
      int PP;
      int WKAREA;
      int DOTS;
      int ERR;
      int KEEPWA;
      int FNAM;
      int I;
      int ENDFLAG;
      int FIRSTTRIP;
      int TRIP;
      recfm OPND1;
      recfm OPND2;
      recfm OPND3;
      auto int STROP();
      KEEPWA = &16;
      = &15;
      OPND1 = 0;
      OPND1 = X '35';
      OPND1 = LOCALIR;
      OPND1 = 268;
      PP = P;
      STRINGL = 0;
      FNAM = 0;
      WKAREA = 0;
      P = P + 3;
      ERR = 72;
      if (!(A == 4)) goto;
      P = P + 1;
      DOTS = 0;
      ENDFLAG = 0;
      STRINGL = 0;
      ERR = STROP;
      if (STRRESINWA == NO && PTYPE & X '1000' != 0) = 1;
      if (!(ERR == 0)) goto;
      NEXT() {
      NEXT:
        if (A == 2)
          ENDFLAG = 1;
        else {
          if (A != CONCOP) {
            ERR = 72;
            goto;
          }
          P = P + 2;
          if (DOTS == 0 && OPND2 == LCONST) {
            ERR = STROP;
            if (!(ERR == 0)) goto;
          } else
            OPND3 = 255;
        }
        if (ENDFLAG == 0 && OPND2 == LCONST && LCONST == OPND3) {
          I = CONCAT;
          CTOP(I, ERR, 0, OPND2, OPND3);
          if (I == 0) goto NEXT;
        }
        if (DOTS == 0) {
          if (ENDFLAG != 0) {
            OUTOPND(OPND2, 0);
            OPND1 = OPND2;
            goto;
          }
          FIRSTTRIP = BRECTRIP;
          OPND1 = REFTRIP;
          OPND1 = FIRSTTRIP;
          DOTS = DOTS + 1;
        }
        if (ENDFLAG == 0) {
          if (OPND3 == 255) {
            ERR = STROP;
            if (!(ERR == 0)) goto;
          }
          OPND1 = BRECTRIP;
          DOTS = DOTS + 1;
          goto NEXT;
        }
        for (I = 2; I < DOTS; I += 1) OUTSTRING("imp_concat(");
        TRIP = FIRSTTRIP;
        while (TRIP != 0) {
          OUTOPND(TRIPLES, 0);
          if (TRIP == FIRSTTRIP)
            OUTSTRING(",");
          else {
            OUTSTRING(")");
            if (!(TRIPLES == 0)) OUTSYM(',');
          }
          TRIP = TRIPLES;
        }
      TIDY:
        EXPOPND = OPND1;
        VALUE = WKAREA;
        P = P + 1;
        if (KEEPWA == 0 && WKAREA > 0) RETURNWSP(WKAREA, 268);
        STRINGL = 0;
        return;
      ERROR:
        FAULT(ERR, 0, FNAM);
        EXPOPND = OPND1;
        BASE = RBASE;
        DISP = 0;
        VALUE = 0;
        ACCESS = 0;
        P = PP;
        SKIPEXP();
        return;
        int STROP() {
          int CTYPE;
          int ALT;
          int I;
          ALT = A;
          = 0;
          if (ALT > 2) return 75;
          if (ALT != 1) {
            CTYPE = A;
            if (CTYPE == X '35') {
              PTYPE = CTYPE;
              STRINGL = A;
              = CTYPE;
              = LCONST;
              = P + 2;
              = STRINGL;
              P = P + STRINGL + 3;
            } else
              return 73;
          } else {
            P = P + 1;
            COPYTAG(FROMAR2, NO);
            if (PTYPE == X '1006') TYPE = ACC & 7;
            if (TYPE == 3) REDUCETAG(NO);
            if (5 != TYPE && TYPE != 7) {
              FNAM = FROMAR2;
              return 71;
            }
            if (PTYPE == X '4035' && A == 2 && 2 == A) {
              = LCONST;
              = X '35';
              = MIDCELL;
              = KFORM;
              STRINGL = ;
              P = P + 4;
              return 0;
            }
            if (PTYPE == X '35' && A == 2 && 2 == A) {
              = DNAME;
              = 0;
              = PTYPE;
              = FROMAR2;
              P = P + 4;
            } else {
              = ARNAME;
              = P;
              P = P + 2;
              SKIPAPP();
              while (A == 1) {
                P = P + 3;
                SKIPAPP();
              }
              P = P + 1;
            }
            STRINGL = 0;
          }
          return 0;
        }
      }
      void CRES() {
        int P1;
        int P2;
        int SEXPRN;
        int W;
        int LAST;
        int ERR;
        int FNAM;
        int JJ;
        recfm OPND1;
        recfm OPND2;
        LAST = 0;
        FNAM = 0;
        SEXPRN = 0;
        P1 = P;
        ERR = 43;
        if (NAMEOPND & X 'C700' == X '4000') {
          = NAMEOPND;
          goto;
        }
        ERR = 74;
        GETWSP(W, 4);
        OPND1 = X '61';
        OPND1 = LOCALIR;
        OPND1 = RBASE << 16 | W;
        P = P + 3;
        if (A == 4) goto;
        ERR = 72;
        ERROR;
      ERROR:
        FAULT(ERR, 0, FNAM);
        P = P1;
        SKIPEXP();
        return;
      RES:
        P = P + 1;
        if (A == 3) {
          OPND2 = X '51';
          OPND2 = SCONST;
          OPND2 = 0;
          OUTSTRING("NULL,");
        } else {
          if (!(A == 1)) goto ERROR;
          P = P + 1;
          P2 = P;
          CNAME(2);
          OUTSYM(',');
          OPND2 = NAMEOPND;
          if (TYPE != 5) {
            ERR = 71;
            FNAM = FROMAR2;
            goto ERROR;
          }
          if (A != CONCOP) {
            ERR = 72;
            goto ERROR;
          }
          P = P + 2;
        }
        if (!(A == 3)) goto ERROR;
        SEXPRN = SEXPRN + 1;
        P = P + 1;
        CSTREXP(0);
        OUTSYM(',');
        OPND2 = X '51';
        OPND2 = SCONST;
        OPND2 = ;
        if (A == 2) {
          OUTSTRING("NULL");
          goto;
        }
        if (A != CONCOP) {
          ERR = 72;
          goto ERROR;
        }
        P2 = P + 1;
        P = P2 + 1;
        if (A == 3) {
          P = P2;
          OUTSTRING("_imptempstring)");
          if (== 0)
            OUTSYM(';');
          else
            OUTSYM('+');
          OUTSTRING("imp_resolve(_imptempstring,");
          goto RES;
        }
        if (!(A == 1)) goto ERROR;
        while (!(A == 2)) {
          P = P + 3;
          SKIPAPP();
        }
        if (A == 1) {
          P = P2;
          OUTSTRING("_imptempstring)");
          if (== 0)
            OUTSYM(';');
          else
            OUTSYM('+');
          OUTSTRING("imp_resolve(_imptempstring,");
          goto RES;
        }
        P1 = P + 1;
        P = P2 + 2;
        CNAME(2);
        P = P1;
      END:
        P = P + 1;
      }
      void SAVESTACKPTR() {
        int JJJ;
        if (CURRINF == 0) {
          JJJ = UTEMPTRIP;
          CURRINF = N;
          if (TARGET == EMAS && PARM == 0)
            N = N + 16;
          else
            N = N + 4;
        }
      }
      void CEND() {
        int KP;
        int JJ;
        int BIT;
        recfm *RCELL;
        recfm *TCELL;
        recfm *PCELL;
        auto void DTABLE();
        if (!(== 2)) SETLINE();
        BIT = 1 << LEVEL;
        if (&X '3FFF' > X '1000' && PARM == 0) JJ = UCONSTTRIP;
        if (== 0) {
          if (PARM == 1) {
            JJ = UCONSTTRIP;
          }
          JJ = CURRINF;
          if (JJ != 0) {
            JJ = UCONSTTRIP;
          }
        }
        FORCETRIPS();
        if (N > NMAX) NMAX = N;
        while (CURRINF != 0) {
          POP(CURRINF, I, J, KP);
          if (J & X 'FFFF' != 0) {
            J = J & X 'FFFF';
            if (0 < KP && KP <= MAXULAB) FAULT(11, ASLIST & X 'FFFF', KP);
            CLEARLIST(J);
          } else {
            if (I & LABUSEDBIT == 0 && KP < MAXULAB) WARN(3, KP);
          }
        }
        NMAX = (NMAX + 7) & (-8);
        CURRINF = NMAX;
        JJ = CURRINF - 1;
        if (JJ >= 0) {
          RCELL = ASLIST;
          if (RCELL & X '1000' != 0) {
            K = RCELL;
            while (K > 0) {
              TCELL = ASLIST;
              if (TCELL & X 'F00' == X '500' && TCELL & 15 == 0) {
                PCELL = ASLIST;
                TCELL = TCELL | PCELL & 15;
              }
              K = TCELL;
            }
          }
        }
        if (&X '1000' != 0) JJ = UCONSTTRIP;
        if (== 1) JJ = UCONSTTRIP;
        CLEARLIST(TWSPHEAD);
        for (JJ = 0; JJ < 4; JJ += 1) {
          CLEARLIST(CURRINF);
        }
        if (TARGET == PERQ || TARGET == ACCENT) FORCETRIPS();
        DTABLE(LEVEL);
        FORCETRIPS();
        while (CURRINF != 0) {
          POP(CURRINF, I, J, JJ);
          CLEARLIST(I);
          CLEARLIST(J);
          CLEARLIST(JJ);
        }
        if (== 2) return;
        if (!(LEVEL > 2 || LEVEL == 2 && PARM == 2)) {
          if (== 1 && LEVEL == 2)
            = 2;
          else
            FAULT(109, 0, 0);
        }
        LEVEL = LEVEL - 1;
        CURRINF = LEVELINF;
        if (&X '1000' != 0) {
          RLEVEL = CURRINF;
          RBASE = RLEVEL;
        }
        if (&X '1000' != 0) NMAX = CURRINF;
        N = CURRINF;
        if (== 2) CEND();
        if (&X '1000' != 0 && PARM == 0) {
          JJ = NEXTP + 6;
          if (!(A == 11 && A == 2)) {
            JJ = ENTERLAB;
            CURRINF = 0;
          }
        }
        return;
        void DTABLE() {
          auto int SWOPOF();
          Imp_String RTNAME;
          Imp_String LOCALNAME;
          if (1 << HOST & UNSIGNEDSHORTS == 0) {
          } else {
          }
          recfm *DHEAD;
          recfm *VAR;
          recfm *LCELL;
          recfm *SCELL;
          recfm *SWDATA;
          const int LARRROUT;
          recfm T;
          int DPTR;
          int LNUM;
          int ML;
          int KK;
          int JJ;
          int Q;
          int DEND;
          int BIT;
          int S4;
          int LANGD;
          int RULES;
          int II;
          const int DLIMIT;
          int DD[];
          BIT = 1 << LEVEL;
          LANGD = >> 14 << 30 | LEVEL << 18;
          if (PARM == 1) PDATA(DAREA, 4, 0, );
          FILLDTABREFS(CURRINF);
          if (PARM != 0) PUSH(LEVELINF, DAREA, CAS + 4, LANGD);
          DHEAD = ;
          DHEAD = SWOPOF;
          DHEAD = SWOPOF;
          DHEAD = SWOPOF;
          DHEAD = 0;
          if (TARGET == IBM || TARGET == IBMXA)
            = CURRINF;
          else
            = SWOPOF;
          DHEAD = SWOPOF;
          ML = CURRINF;
          if (ML != 0) ML = WORD;
          LNUM = WORKA;
          DPTR = 4;
          DEND = 0;
          if (LNUM == 0)
            DHEAD = 0;
          else {
            Q = ;
            RTNAME = ;
            LNUM = ;
            DHEAD = RTNAME;
            DPTR = DPTR + (LNUM >> 2);
          }
          DD = SWOPOF;
          DPTR = DPTR + 1;
          JJ = CURRINF;
          while (0 <= JJ && JJ < X '3FFF') {
            LCELL = ASLIST;
            T = LCELL;
            S4 = LCELL;
            PTYPE = T;
            TYPE = PTYPE & 15;
            if (TYPE > 2 || PTYPE & X 'FF00' != X '4000' && T & X 'C000' == 0)
              WARN(2, JJ);
            I = T >> 4 & 15;
            J = T & 15;
            K = T;
            if (PARM != 0 && PTYPE & X '7300' <= X '200') {
              Q = ;
              if (I == 0)
                II = 1;
              else
                II = 0;
              VAR = ;
              VAR = SWOPOF;
              if (PARAMSBWARDS == YES && K < CURRINF ||
                  STACKDOWN == YES && K > CURRINF && PTYPE & X 'C00' == 0) {
                if (K < CURRINF)
                  RULES = 2;
                else
                  RULES = 1;
                KK = ROUNDINGLENGTH;
                K = (K + T + KK) & (~KK);
              }
              VAR = SWOPOF;
              if (TARGET == EAMD && I != 0) VAR = K + 64;
              LOCALNAME = ;
              LNUM = ;
              VAR = LOCALNAME;
              if (HOST != TARGET && PARM != 0) (, 4 * DPTR + 4, LNUM + 1);
              DPTR = DPTR + ((LNUM + 8) >> 2);
            }
            if (J == 15 && PTYPE & X '3000' != 0) (28, 0, JJ);
            if (J == 15 && TYPE == 4) FAULT(62, 0, JJ);
            if (PTYPE & X '3000' != 0) {
              CLEARLIST(K);
            }
            if (TYPE == 4) {
              CLEARLIST(T);
            }
            if (TYPE == 6) {
              SCELL = ASLIST;
              SWDATA = ;
              OUTSTRING("goto ");
              OUTSWADNAME(JJ);
              OUTSTRING("_skip;");
              OUTSYM();
              OUTSWADNAME(JJ);
              OUTSTRING("_despatch:");
              OUTSYM();
              OUTSTRING("switch (");
              OUTSWADNAME(JJ);
              OUTSTRING("_value) {");
              OUTSYM();
              for (LNUM = 0; LNUM < SWDATA - 1; LNUM += 1) {
                OUTSTRING("case ");
                P = SWDATA;
                CSEXP(X '51');
                OUTSTRING(": goto ");
                OUTSWADNAME(JJ);
                OUTSYM('_');
                P = SWDATA;
                LABEXP();
                OUTSYM(';');
                OUTSYM();
              }
              OUTSTRING("default:");
              if (SWDATA != 0) {
                OUTSTRING("goto ");
                OUTSWADNAME(JJ);
                OUTSTRING("_default;");
              } else {
                OUTSTRING("BADSWITCH(");
                OUTSWADNAME(JJ);
                OUTSTRING("_value,");
                OUTSWADNAME(JJ);
                OUTSTRING("_line,");
                OUTSWADNAME(JJ);
                OUTSTRING("_file);");
              }
              OUTSYM();
              OUTSYM('}');
              OUTSYM();
              OUTSWADNAME(JJ);
              OUTSTRING("_skip:;");
              OUTSYM();
              FREE();
              KK = T;
              CLEARLIST(KK);
            }
            LCELL = ASL;
            ASL = TAGS;
            TAGS = S4 & X '3FFFF';
            JJ = S4 >> 18;
          }
          DD = -1;
          DPTR = (DPTR << 2) + 4;
          if (PARM == 1) PDATA(DAREA, 4, DPTR, );
          return;
          int SWOPOF() {
            recfm OPND;
            if (HOST != TARGET) {
              OPND = 0;
              OPND = VALUE;
              OPND = PTYPE;
              REFORMATC(OPND);
              VALUE = OPND;
            }
            return VALUE;
          }
        }
      }
      void DECLARESCALARS() {
        int INC;
        int SCALNAME;
        int RL;
        PACK(PTYPE);
        INC = ACC;
        SNDISP = 0;
        RL = ROUNDINGLENGTH;
        if (NAM != 0 && ARR == 0) {
          INC = PTRSIZE;
          RL = PTRROUNDING;
        }
        if (NAM > 0 && ARR > 0) {
          INC = AHEADSIZE;
          RL = ROUNDINGLENGTH;
        }
        if (PTYPE == X '35' && ACC <= 0 || ACC > 256) {
          (70, ACC - 1, 0);
          ACC = 255;
        }
        if (TYPE == 5) {
          OUTSTRING("char ");
        } else
          OUTTYPE(PTYPE & 255, );
        while (!(A == 2)) {
          N = ((N + RL + SFRAMEMISALIGN) & (~RL)) - SFRAMEMISALIGN;
          SCALNAME = FROMAR2;
          if (NAM != 0) OUTSTRING("*");
          OUTNAME(SCALNAME);
          P = P + 3;
          STORETAG(SCALNAME, LEVEL, RBASE, 0, SNDISP, ACC, N, );
          N = N + INC;
          if (TYPE == 5 && NAM == 0) {
            OUTSTRING(" [");
            OUTINT(ACC);
            OUTSTRING("] ");
          }
          if (A == 1) OUTSYM(',');
        }
        N = (N + MINPARAMSIZE - 1) & (-MINPARAMSIZE);
      }
      int DOPEVECTOR() {
        int I;
        int JJ;
        int K;
        int ND;
        int D;
        int M0;
        int HEAD;
        int NOPS;
        int TYPEPP;
        int PIN;
        int ETYPE;
        int VALUE;
        recfm OPND;
        recfm *LCELL;
        int LBH[];
        int LBB[];
        int LBP[];
        int UBP[];
        int DV[];
        ND = 0;
        TYPEPP = 0;
        PIN = P;
        M0 = 1;
        while (!(A == 2)) {
          ND = ND + 1;
          P = P + 1;
          LBP = P;
          ETYPE = TSEXP;
          P = LBP + 3;
          if (ND > 12) {
            FAULT(37, 0, );
            ND = 1;
          }
          LBH = 0;
          LBB = 0;
          NOPS = 0;
          TORP(LBH, LBB, NOPS, 1);
          UBP = P;
          SKIPEXP();
          if (== 1) {
            EXPOP(LBH, LBB, NOPS, X '251');
            LBB = EXPOPND;
          } else {
            LBB = X '80000000';
          }
        }
        P = P + 1;
        if (== YES) {
          for (D = 1; D < ND; D += 1) {
            if (LBB > 0 && LBB * ND <= 6) LBB = 0;
          }
        }
        DV = ND << 16 | ;
        for (D = 1; D < ND; D += 1) {
          K = 3 * D;
          DV = LBB;
          DV = LBP;
          DV = UBP;
        }
        K = 3 * ND + 2;
        J = ND;
        SNDISP = 4 * WORKA;
        I = SNDISP;
        for (D = 0; D < K; D += 1) {
          CTABLE = DV;
          WORKA = WORKA + 1;
        }
        if (WORKA > WORKA) (102, WORKA, 0);
        return I;
      }
      void DECLAREARRAYS() {
        int DVDISP;
        int PP;
        int DVF;
        int ELSIZE;
        int TOTSIZE;
        int PTYPEP;
        int ARRP;
        int NN;
        int ND;
        int II;
        int CDV;
        int LWB;
        int PTYPEPP;
        int JJJ;
        int JJ;
        int TRIP1;
        int RL;
        int TOPP;
        int IDEN;
        recfm OPND1;
        SAVESTACKPTR();
        ARRP = 2 * +1;
        ARR = ARRP;
        PACK(PTYPEP);
        ELSIZE = ACC;
        START;
      START:
        NN = 1;
        P = P + 1;
        PP = P;
        CDV = 0;
        PTYPEPP = PTYPEP;
        while (A == 1) {
          P = P + 3;
          NN = NN + 1;
        }
        P = P + 3;
        DVDISP = DOPEVECTOR;
        TOPP = P;
        ND = J;
        CDV = 1;
        if (LWB == 0 && == 0) PTYPEPP = PTYPEP + 256;
        SNDISP = SNDISP >> 2;
        DVDISP = DVDISP >> 2;
      DECL:
        J = ND;
        RL = ROUNDINGLENGTH;
        N = (N + RL) & (~RL);
        for (JJJ = 0; JJJ < NN - 1; JJJ += 1) {
          IDEN = FROMAR2;
          PTYPE = PTYPEPP;
          UNPACK();
          STORETAG(IDEN, LEVEL, RBASE, ND, DVDISP, ELSIZE, N, );
          N = N + AHEADSIZE;
          if (== 0) {
            if (PTYPEPP & 15 == 5)
              OUTSTRING("char ");
            else
              OUTTYPE(PTYPEPP & 255, );
            OUTNAME(IDEN);
            for (II = ND; II < 1; II += -1) {
              P = CTABLE;
              OUTSTRING(" [");
              CSEXP(X '51');
              if (CTABLE == X '80000000') {
                OUTSYM('-');
                P = CTABLE;
                OUTSYM('(');
                CSEXP(X '51');
                OUTSTRING(")+1");
              } else if (CTABLE < 1) {
                OUTSYM('+');
                OUTINT(1 - CTABLE);
              } else if (CTABLE > 1) {
                OUTSYM('-');
                OUTINT(CTABLE - 1);
              }
              OUTSYM(']');
              if (PTYPEPP & 15 == 5) {
                OUTSTRING(" [");
                OUTINT(ELSIZE);
                OUTSTRING("] ");
              }
            }
            if (JJJ != NN - 1) {
              OUTSYM(';');
              OUTSYM();
            }
          }
        }
        P = TOPP + 1;
        if (A == 2) return;
        {
          OUTSYM(';');
          OUTSYM();
        }
        goto START;
      }
      int ROUNDINGLENGTH() {
        if (PTYPE & X '1000' != 0) return PTRROUNDING;
        if (PTYPE & X 'C00' != 0) return PTRROUNDING;
        return RNDING;
      }
      void CLT() {
        int ALT;
        int PTYPEP;
        int I;
        int FLAGS;
        int SJ;
        ALT = A;
        FLAGS = TYPEFLAG;
        if (FLAGS & X '8000' != 0) {
          = P + 1;
          FLAGS = TYPEFLAG;
        }
        if (FLAGS & X '4000' != 0) P = P + 1;
        if (FLAGS & X '2000' != 0) WARN(8, 0);
        if (FLAGS & X '1000' != 0) FAULT(99, 0, 0);
        PREC = FLAGS >> 4 & 15;
        TYPE = FLAGS & 7;
        P = P + 1;
        ACC = BYTES;
        PACK(PTYPEP);
        if (TYPE == 5) {
          if (A == 1) {
            if (A == 1) {
              P = P + 4;
              if (INTEXP != 0) {
                FAULT(41, 0, 0);
                I = 255;
              }
              if (!(1 <= I && I <= 255)) FAULT(70, I, 0);
              ACC = I + 1;
              PTYPE = PTYPEP;
              UNPACK();
            } else {
              ACC = 0;
              P = P + 2;
            }
          } else {
            ACC = 0;
            P = P + 1;
          }
        }
        KFORM = 0;
        if (TYPE == 3) {
          SJ = J;
          KFORM = CFORMATREF;
          PTYPE = PTYPEP;
          UNPACK();
          J = SJ;
        }
      }
      void CQN() {
        int I;
        I = A;
        NAM = 0;
        ARR = 0;
        if (I == 1) ARR = 1;
        if (I <= 2) NAM = 1;
      }
      void CRSPEC() {
        int KK;
        int JJ;
        int TYPEP;
        int OPHEAD;
        int NPARMS;
        int AXNAME;
        int SACC;
        int SKFORM;
        int PCHKWORD;
        int PCOUNT;
        recfm *LCELL;
        Imp_String SS;
        LITL = EXTRN & 3;
        ACC = 0;
        KFORM = 0;
        if (A == 1) {
          TYPEP = LITL << 14 | X '1000';
          P = P + 4;
        } else {
          ROUT = 1;
          ARR = 0;
          P = P + 1;
          CLT();
          NAM = 0;
          if (A == 2) NAM = 2;
          PACK(TYPEP);
          P = P + 4;
        }
        KK = FROMAR2;
        AXNAME = ;
        JJ = 0;
        P = P + 3;
        SACC = ACC;
        SKFORM = KFORM;
        if (A == 1) {
          if (LITL == 0) WARN(10, 0);
          MOVEBYTES(A + 1, , P, , WORKA);
          OUTSTRING("#define ");
          OUTSTRING();
          AXNAME = ;
          OUTSYM(' ');
          if (== "s_cstring")
            OUTSTRING("s__cstring");
          else
            OUTSTRING();
          OUTSYM();
          WORKA = (WORKA + 4 + A) & (-4);
          P = P + A + 1;
        }
        CFPLIST(OPHEAD, NPARMS);
        PCHKWORD = 0;
        SS = ;
        if (0 <= && <= 1) {
          if (!(TYPEP & X 'c000' != 0 && SS == "malloc" || SS == "free")) {
            if (TYPEP & X 'c000' == X '8000') OUTSTRING("extern ");
            OUTTYPE(TYPEP & 255, SKFORM);
            if (TYPEP & X '800' != 0 && TYPEP & 7 != 5) OUTSYM('*');
            OUTNAME(KK);
            OUTSYM('(');
            OUTSYM(' ');
            LCELL = ASLIST;
            if (NPARMS == 0)
              OUTSTRING("void ");
            else {
              for (PCOUNT = 1; PCOUNT < NPARMS; PCOUNT += 1) {
                if (LCELL & X '10000000' != 0) {
                  OUTTYPE(LCELL >> 16 & 255, LCELL);
                  OUTSTRING("()");
                } else {
                  OUTXTYPE(LCELL >> 16, LCELL);
                }
                if (LCELL != 0) OUTSYM(',');
                LCELL = ASLIST;
              }
            }
            OUTSTRING(");");
          }
        }
        if (NPARMS > 0) PCHKWORD = NPARMS << 16 | ASLIST >> 16;
        if (== 1) {
          if (TARGET == EMAS || TARGET == PNX)
            (, 3 * PARM | EXTRN, PCHKWORD, JJ);
          if (TARGET == PERQ || TARGET == ACCENT) = AXNAME - ;
        } else {
          if (TARGET == PERQ || TARGET == ACCENT) {
            = WORKA;
            WORKA = WORKA + 1;
          }
        }
        if (== 0 && RLEVEL == 0) {
          if (PARM == 0) PARM = 2;
          if (PARM != 2) FAULT(56, 0, KK);
        }
        J = 15 - (&1);
        PTYPE = TYPEP;
        STORETAG(KK, LEVEL, RBASE, J, JJ, SACC, OPHEAD, SKFORM);
      }
      void CFPLIST() {
        int OPBOT;
        int PP;
        int INC;
        int RL;
        int RSIZE;
        int CELL;
        int PSIMPLE;
        recfm *LCELL;
        = 0;
        OPBOT = 0;
        = 0;
        PSIMPLE = 1;
        while (A == 1) {
          PP = P + 1 + FROMAR2;
          P = P + 3;
          CFPDEL();
          if (!(== X '51' || ROUT == ARR && ARR == 0 && NAM == 1)) PSIMPLE = 0;
          if (ROUT != 0) {
            INC = RTPARAMSIZE;
            RL = ROUNDINGLENGTH;
          } else if (ARR == 1) {
            INC = AHEADSIZE;
            RL = ROUNDINGLENGTH;
          } else if (NAM == 1) {
            INC = PTRSIZE;
            RL = PTRROUNDING;
          } else if (STRVALINWA == YES && PTYPE == X '35') {
            INC = PTRSIZE;
            RL = PTRROUNDING;
          } else if (RECVALINWA == YES && PTYPE == X '33') {
            INC = PTRSIZE;
            RL = PTRROUNDING;
          } else if (TARGET == EMAS && PTYPE == X '33') {
            INC = ACC + 8;
            RL = 3;
          } else {
            INC = ACC;
            RL = ROUNDINGLENGTH;
          }
          while (!(A == 2)) {
            if (PARAMSBWARDS == YES) {
              PUSH(, 0, 0, RL);
              CELL = ;
            } else {
              BINSERT(, OPBOT, 0, 0, RL);
              CELL = OPBOT;
            }
            LCELL = ASLIST;
            LCELL = PTYPE;
            LCELL = KFORM;
            LCELL = ACC;
            = +1;
            P = P + 3;
          }
          P = PP;
        }
        OPBOT = ;
        INC = 0;
        INC = ((INC + RL + SFRAMEMISALIGN) & (~RL)) - SFRAMEMISALIGN;
        P = P + 1;
        if (PARM != 0) PRINTLIST();
        PP = INC << 16 | ;
        if (TARGET == IBM || TARGET == IBMXA) = PP | PSIMPLE << 15;
        if (> 0) ASLIST = PP;
        if (PARM != 0) PRINTLIST();
      }
      void CFPDEL() {
        FP;
        int FPALT;
        FPALT = A;
        P = P + 1;
        KFORM = 0;
        LITL = 0;
        goto FP;
        FP;
      FP_1:
        ROUT = 0;
        CLT();
        CQN(P);
        if (TYPE == 5 && NAM == 0) {
          (70, ACC - 1, 0);
          ACC = 255;
        }
        P = P + 1;
        goto;
      FP_2:
        ROUT = 1;
        NAM = 1;
        ARR = 0;
        if (A == 1) {
          TYPE = 0;
          PREC = 0;
          P = P + 2;
        } else {
          P = P + 1;
          CLT();
          NAM = 1;
          if (A == 2) NAM = 3;
          P = P + 2;
        }
        ACC = RTPARAMSIZE;
        goto;
      FP_3:
        ACC = PTRSIZE;
        NAM = 1;
        ROUT = 0;
        TYPE = 0;
        ARR = 0;
        PREC = 0;
      PK:
        PACK(PTYPE);
      }
      void RHEAD() {
        int W3;
        int FLAGS;
        recfm *LCELL;
        FLAGS = 0;
        if (!= 0) FLAGS = BSTRUCT;
        CURRINF = NMAX;
        CURRINF = N;
        if (>= 0) {
          LCELL = ASLIST;
          if (PARM == 0 && LEVEL > 1) {
            PLABEL = PLABEL - 1;
            CURRINF = PLABEL;
            if (JRNDBODIES == YES) ENTERJUMP(15, PLABEL, 0);
          }
          RLEVEL = RLEVEL + 1;
          RBASE = RLEVEL;
        }
        LEVEL = LEVEL + 1;
        CURRINF = LEVELINF;
        CURRINF = 0;
        CURRINF = RBASE;
        CURRINF = LEVEL;
        CURRINF = -1;
        CURRINF = LEVELINF;
        CURRINF = LEVELINF;
        if (LEVEL == MAXLEVELS) FAULT(34, 0, 0);
        if (LEVEL > MAXLEVELS) FAULT(105, 0, 0);
        if (< 0) {
          if (== 0) {
            CURRINF = INTERNALBLOCKID;
            INTERNALBLOCKID = INTERNALBLOCKID + 1;
          }
          W3 = 0;
        } else {
          W3 = +1;
          INTERNALBLOCKID = 0;
        }
        CURRINF = LINE;
        CURRINF = W3;
        CURRINF = PTYPE & X 'FFFF';
        W3 = ULCONSTTRIP;
      }
      void RDISPLAY() {
        int TRIPNO;
        if (KK >= 0 || LEVEL == 2) {
          CURRINF = N - ALPHA;
          if (1 << TARGET & RISKMC != 0) {
            N = (N + DISPLAYROUNDING) & (~DISPLAYROUNDING);
          }
          CURRINF = N;
          if (DISPLAYNEEDED == YES) {
            N = N + DISPLAYC1 * RLEVEL + DISPLAYC0;
          }
          TRIPNO = UCONSTTRIP;
        }
        if (PARM != 0) {
          if (KK >= 0 || LEVEL == 2) {
            if (TARGET == VNS) {
              CURRINF = CURRINF + 8;
            } else {
              TRIPNO = UCONSTTRIP;
              N = N + 4;
              if (1 << TARGET & RISKMC != 0) {
                N = N + 4;
              }
              CURRINF = N;
              N = N + 4;
              if (TARGET == ORN || 1 << TARGET & RISKMC != 0) N = N + 4;
            }
          }
          TRIPNO = UCONSTTRIP;
        }
        OLDLINE = 0;
        SETLINE();
        if (KK >= 0 || LEVEL == 2) {
          NMAX = N;
        }
      }
      void CUI() {
        int PT;
        int MARKER;
        int J;
        int LNAME;
        int TYPEP;
        int PRECP;
        int ALT;
        int KK;
        recfm OPND1;
        int HEAD1;
        int BOT1;
        int NOPS;
        int SAVEPOS;
        recfm RPOP;
        recfm *LCELL;
        recfm *SWDATA;
        static int DEPTH;
        SW;
        DEPTH = DEPTH + 1;
        if (DEPTH == 1) {
          SAVEPOS = OPLINE;
          OUTSYM(' ');
        }
        REPORTUI = 0;
        ALT = A;
        goto SW;
        SW;
      SW_1:
        P = P + 1;
        MARKER = P + FROMAR2;
        if (A == 1) {
          J = P + 2;
          P = MARKER + 2;
          ASSIGN(A, J);
        } else {
          P = P + 2;
          CNAME(0);
          P = P + 1;
        }

      AUI:
        J = A;
        P = P + 1;
        if (J == 1) {
          if (DEPTH == 1) OPLINE = '{';
          if (OPLINE != '{') OUTSTRING("; ");
          CUI();
          if (DEPTH == 1) OUTSTRING(";}");
        }
        DEPTH = DEPTH - 1;
        return;
      SW_2:
        CURRINF = CURRINF | 1;
        if (== 0) CURRINST = 1;
        LNAME = FROMAR2;
        J = A;
        P = P + 4;
        if (J == 2) {
          ENTERJUMP(15, LNAME, 0);
          REPORTUI = 1;
          OUTSTRING("goto ");
          OUTNAME(LNAME);
        } else {
          COPYTAG(LNAME, NO);
          if (!(OLDI == LEVEL && TYPE == 6)) {
            FAULT(4, 0, LNAME);
            P = P - 1;
            SKIPAPP();
            return;
          }
          OUTSYM('{');
          OUTSWADNAME(LNAME);
          OUTSTRING("_value=");
          CSEXP(MINAPT);
          OUTSTRING("; ");
          OUTSWADNAME(LNAME);
          OUTSTRING("_line = __LINE__");
          OUTSTRING("; ");
          OUTSWADNAME(LNAME);
          OUTSTRING("_file = __FILE__");
          OUTSTRING("; goto ");
          OUTSWADNAME(LNAME);
          OUTSTRING("_despatch;}");
          REPORTUI = 1;
        }
        DEPTH = DEPTH - 1;
        return;
      SW_3:
        if (!(CURRINF & X '3FFF' == X '1000')) FAULT(30, 0, 0);
        P = P + 1;
        OUTSTRING("return ");
      RET:
        KK = UCONSTTRIP;
        REPORTUI = 1;
        if (== 0) CURRINST = 1;
        DEPTH = DEPTH - 1;
        return;
      SW_4:
        OUTSTRING("return ");
        PTYPE = CURRINF & X '3FFF';
        UNPACK();
        PT = PTYPE & 255;
        OPND1 = 0;
        OPND1 = PTYPE;
        OPND1 = DNAME;
        OPND1 = CURRINF - 1;
        if (PTYPE > X '1000' && A != 3) {
          if (A == 1 && NAM != 0) {
            P = P + 7;
            TYPEP = TYPE;
            PRECP = PREC;
            J = P;
            CNAME(4);
            KK = BRECTRIP;
            if (!(A == 2)) FAULT(81, 0, 0);
            P = P + 1;
            if (!(== TYPE && PRECP == PREC)) FAULT(83, CURRINF - 1, FROMAR2);
            goto RET;
          }
          if (A == 2 && NAM == 0) {
            P = P + 2;
            if (TYPE == 5) {
              CSTREXP(0);
            } else if (TYPE == 3) {
              if (!(A == 4 && A == 1)) goto;
              P = P + 5;
              CNAME(3);
              if (!(TYPE == 3)) FAULT(66, 0, OPND1);
              EXPOPND = NAMEOPND;
            } else {
              if (PREC < 4) PREC = 4;
              CSEXP(PREC << 4 | TYPE);
            }
            if (PT == X '31' || PT == X '41') {
              KK = URECTRIP;
              EXPOPND = REFTRIP;
              EXPOPND = KK;
              EXPOPND = PT;
            }
            KK = BRECTRIP;
            goto RET;
          }
        }
        P = P + 2;
      BADRES:
        FAULT(31, 0, 0);
        SKIPEXP();
        DEPTH = DEPTH - 1;
        return;
      SW_5:
        OUTSTRING("assert(_IMP_MONITOR_)");
        P = P + 1;
        goto AUI;
      SW_6:
        OUTSTRING("exit(0)");
        P = P + 1;
        if (== 0) CURRINST = 1;
        REPORTUI = 1;
        DEPTH = DEPTH - 1;
        return;
      SW_7:
        P = P + 5;
        KK = INTEXP;
        if (A == 1) {
          P = P + 3;
          SKIPEXP();
        }
        OUTSTRING("*** IMP signals untranslateable *****");
        DEPTH = DEPTH - 1;
        return;
      SW_8:
        OUTSTRING(" break ");
        REPORTUI = 1;
        if (== 0) CURRINST = 1;
        DEPTH = DEPTH - 1;
        return;
      SW_9:
        REPORTUI = 1;
        if (== 0) CURRINST = 1;
        OUTSTRING(" continue ");
        DEPTH = DEPTH - 1;
        return;
      }
      void CIFTHEN() {
        int ALTUI;
        int CCRES;
        int ELRES;
        int THENLAB;
        int ELSELAB;
        int USERLAB;
        int REPORT;
        int START;
        int ELSEALT;
        int K;
        int J;
        int CS;
        int LINETRIP;
        int CTYPE;
        const int NULLELSE;
        ESW;
        static int DEPTH;
        DEPTH = DEPTH + 1;
        LINETRIP = -1;
        {
          SETLINE();
          LINETRIP = TRIPLES;
        }
        MARKIU = A;
        PLABEL = PLABEL - 1;
        THENLAB = PLABEL;
        START = 0;
        CS = 0;
        if (STARSIZE > 100) CS = 1;
        ELSELAB = 0;
        P = MARKC;
        if (MARKR > 0 && A <= 2) START = 1;
        USERLAB = -1;
        if (START != 0)
          ALTUI = 0;
        else
          ALTUI = A;
        if (ALTUI == 2 && A == 2) USERLAB = FROMAR2;
        if (8 <= ALTUI && ALTUI <= 9 && CURRINF != 0) {
          if (ALTUI == 8)
            USERLAB = CURRINF;
          else
            = CURRINF;
        }
        CTYPE = RLEVEL;
        if (TCOND != 0) CTYPE = 0;
        P = MARKC;
        if (CTYPE == 0) {
          if (== NO) {
            OUTSYM();
            OUTSTRING("#if");
          }
        } else {
          OUTSTRING("if ");
        }
        CCRES = CCOND;
        if (START != 0) {
          if (CCRES == 0) {
            CURRINF = CURRINF | 1;
          } else {
            if (LINETRIP > 0) TRIPLES = NULLT;
          }
          P = MARKR + 1;
          if (CTYPE != 0) {
            CURLYCHECK(1);
            OUTSYM('{');
          }
          OUTSYM();
          CSTART(CCRES, 1);
          if (CTYPE != 0) OUTSTRING("}");
          if (A <= 2) {
            PLABEL = PLABEL - 1;
            ELSELAB = PLABEL;
          }
          MARKE = P;
          REPORT = LASTINST;
        } else {
          if (CCRES != 2) {
            if (CTYPE == 0) OUTSYM();
            P = MARKUI;
            CUI(1);
            if (MARKE != 0 && A != NULLELSE) OUTSEP();
            REPORT = REPORTUI;
          } else {
            REPORT = 1;
          }
        }
        static int ELSE;
      ELSE:
        if (MARKE == 0)
          ELSEALT = NULLELSE;
        else
          ELSEALT = A;
        if (ELSEALT < NULLELSE) {
          PLABEL = PLABEL - 1;
          ELSELAB = PLABEL;
        }
        P = MARKE + 1;
        goto ESW;
      ESW_1:
        if (CTYPE == 0) {
          OUTSYM();
          OUTSTRING("#else");
          CURLYCHECK(1);
          OUTSYM();
        } else {
          OUTSTRING(" else {");
          CURLYCHECK(1);
          OUTSYM();
        }
        if (CCRES == 0) CURRINF = CURRINF | 1;
        CSTART(CCRES, 2);
        if (CTYPE != 0) OUTSTRING("}");
        if (CTYPE == 0) {
          OUTSYM();
          OUTSTRING("#endif");
        }
        goto;
      ESW_2:
        MARKE = 0;
        MARKUI = 0;
        MARKR = P + 1 + FROMAR2;
        if (A == 3) {
          MARKE = MARKR + 1 + FROMAR2;
          MARKUI = MARKR + 3;
        }
        J = NEXTTRIP;
        if (CTYPE == 0) {
          OUTSYM();
          OUTSTRING("#else");
          OUTSYM();
          CIFTHEN(P, P + 3, MARKUI, MARKE, MARKR, NO);
          OUTSYM();
          OUTSTRING("#endif");
        } else {
          OUTSTRING(" else ");
          CIFTHEN(P, P + 3, MARKUI, MARKE, MARKR, NO);
          OUTSYM();
        }
        REPORT = 0;
        goto;
      ESW_3:
        if (CTYPE == 0) {
          OUTSYM();
          OUTSTRING("#else");
          OUTSYM();
        } else {
          OUTSTRING(" else ");
        }
        if (CCRES != 1) {
          if (START != 0) SETLINE();
          if (THENLAB == 0)
            K = 0;
          else
            K = 2;
          CUI(K);
          REPORT = REPORTUI;
          if (CTYPE == 0) {
            OUTSEP();
            OUTSYM();
            OUTSTRING("#endif");
          } else {
            if (DEPTH > 1) OUTSEP();
          }
        }

      ENTERELSELAB:
        if (ELSELAB > 0) ELRES = ENTERLAB;
        DEPTH = DEPTH - 1;
        return;
      ESW_NULLELSE:
        if (CTYPE == 0) {
          if (START == 0) OUTSEP();
          OUTSYM();
          OUTSTRING("#endif");
        }
        DEPTH = DEPTH - 1;
      }
      void CSTART() {
        int SKIPCODE;
        int FINISHAR;
        int OLDNEXTP;
        int OLDLINE;
        if (== 3) {
          OUTSTRING("/* beginning of onevent block */");
          OUTSYM();
        }
        SKIPCODE = NO;
        if (1 <= && <= 2 && | == 3) SKIPCODE = YES;
        FINISHAR = FROMAR4;
        OLDLINE = LINE;
        do {
          OLDNEXTP = NEXTP;
          COMPILEASTMNT();
        } while (!(OLDNEXTP >= FINISHAR));
        if (== 3) {
          OUTSTRING("/* end of onevent block */");
          OUTSYM();
        }
        P = FINISHAR + 10;
        if (A <= 3 && != 1) FAULT(45 +, OLDLINE, 0);
        if (SKIPCODE == YES) LASTINST = 1;
      }
      void CCYCBODY() {
        int FINISHAR;
        int OLDLINE;
        int SAVEE;
        int SAVEC;
        FINISHAR = FROMAR4;
        if (FINISHAR <= P) IMPABORT();
        FORDPTH = FORDPTH + 1;
        OLDLINE = LINE;
        SAVEE = CURRINF;
        SAVEC = CURRINF;
        CURRINF = ;
        CURRINF = ;
        CURLYCHECK(1);
        OUTSYM('{');
        OUTSYM();
        while (NEXTP <= FINISHAR) {
          COMPILEASTMNT();
        }
        OUTSTRING("}");
        CURRINF = SAVEE;
        CURRINF = SAVEC;
        P = FINISHAR + 10;
        FORDPTH = FORDPTH - 1;
        if (A == 1 && == 0) FAULT(12, OLDLINE, 0);
      }
      void CLOOP() {
        int L1;
        int L2;
        int L3;
        int L4;
        int CCRES;
        int ELRES;
        int FLINE;
        int TRIP;
        int FOT;
        int PP;
        int DEBJ;
        int JJ;
        int FSTRIP;
        int FORNAME;
        int INITP;
        int STEPP;
        int FINALP;
        int REPMASK;
        int FORPT;
        int FORWORDS;
        int FORBITS;
        recfm INITOPND;
        recfm STEPOPND;
        recfm FINALOPND;
        recfm DIFFOPND;
        recfm ZOPND;
        recfm OPND;
        recfm *CURRT;
        auto void FOREXP();
        SW;
        P = MARKC;
        FORBITS = 0;
        SFLABEL = SFLABEL - 2;
        L1 = SFLABEL;
        L2 = L1 + 1;
        L3 = 0;
        if (B '1100001' & 1 << != 0) {
          L3 = SFLABEL - 1;
          SFLABEL = L3;
        }
        if (1 <= && <= 3) SETLINE();
        goto SW;
        SW;
      SW_0:
        PP = FROMAR4 + 10;
        if (A == 1) {
          OUTSTRING("do ");
          CCYCBODY(1, L2, L3);
          SETLINE();
          OUTSTRING(" while ");
          P = PP + 1;
          CCRES = CCOND;
        } else {
          OUTSTRING("for (;;) ");
          CCYCBODY(1, L2, L1);
        }

      WAYOUT:
        return;
      SW_1:
        OUTSTRING("while ");
        CCRES = CCOND;
        P = MARKUI;
        CUI(1);
        goto WAYOUT;
      SW_2:
        P = MARKUI;
        OUTSTRING("do ");
        CUI(1);
        P = MARKC;
        OUTSEP();
        OUTSTRING(" while ");
        CCRES = CCOND;
        goto WAYOUT;
      SW_6:
      SW_3:
        FORCNT = FORCNT + 1;
        FORNAME = FROMAR2;
        INITP = P + 2;
        COPYTAG(FORNAME, YES);
        if (!(TYPE == 7 || TYPE == 1 && 4 <= PREC && PREC <= 5)) {
          FAULT(91, 0, FORNAME);
          PTYPE = X '51';
        }
        FOT = DNAME;
        if (NAM != 0) FOT = INDNAME;
        FORPT = PTYPE & 255;
        P = INITP;
        SKIPEXP();
        STEPP = P;
        SKIPEXP();
        FINALP = P;
        P = STEPP;
        FOREXP(STEPOPND, 1, 1);
        OUTSTRING(" for (");
        if (FOT == INDNAME) OUTSYM('*');
        OUTNAME(FORNAME);
        OUTSYM('=');
        P = INITP;
        CSEXP(FORPT);
        OUTSEP();
        OUTSYM(' ');
        if (FOT == INDNAME) OUTSYM('*');
        OUTNAME(FORNAME);
        if (STEPOPND <= 1) {
          if (STEPOPND == 0) FAULT(92, 0, 0);
          if (STEPOPND < 0)
            OUTSTRING(">=");
          else
            OUTSTRING("<=");
        } else {
          OUTSTRING("<=");
          WARN(10, 0);
        }
        P = FINALP;
        CSEXP(FORPT);
        OUTSEP();
        OUTSYM(' ');
        if (FOT == INDNAME) OUTSYM('*');
        OUTNAME(FORNAME);
        if (STEPOPND <= 1 && == 1) {
          if (STEPOPND < 0)
            OUTSTRING("--");
          else
            OUTSTRING("++");
        } else {
          OUTSTRING("+=");
          P = STEPP;
          CSEXP(FORPT);
        }
        OUTSTRING(") ");
        P = MARKUI;
        if (== 3) {
          CUI(0);
        } else {
          CCYCBODY(0, L2, L3);
        }
        goto WAYOUT;
      SW_4:
        SETLINE();
        OUTSTRING("while ");
        CCRES = CCOND;
        CCYCBODY(0, L2, L1);
        goto WAYOUT;
      SW_5:
        P = MARKUI;
        FLINE = LINE;
        OUTSTRING("do ");
        CCYCBODY(0, L2, L3);
        P = MARKC;
        LINE = FLINE;
        SETLINE();
        OUTSEP();
        OUTSTRING(" while ");
        CCRES = CCOND;
        goto WAYOUT;
        void FOREXP() {
          int INP;
          int VAL;
          int SUBBITS;
          int EXPHEAD;
          int EXPBOT;
          int NOPS;
          EXPHEAD = 0;
          EXPBOT = 0;
          NOPS = 0;
          INP = P;
          P = P + 3;
          TORP(EXPHEAD, EXPBOT, NOPS, 1);
          if (NOPS >> 16 & 7 == 0) {
            EXPOP(EXPHEAD, EXPBOT, NOPS, X '200' + FORPT);
            = EXPOPND;
          } else {
            = 255;
          }
        }
      }
      void ASSIGN() {
        int Q;
        int KK;
        int TYPEP;
        int PRECP;
        int PTYPEP;
        int JJJ;
        int P2;
        int JJ;
        int B;
        int D;
        int HEAD2;
        int BOT2;
        int ACCP;
        int II;
        int HEAD1;
        int NOPS;
        int TPCELL;
        int LVL;
        int BOT1;
        int LHNAME;
        int RHNAME;
        int A1;
        int A2;
        recfm *LHCELL;
        recfm OPND1;
        recfm OPND2;
        SW;
        P2 = P;
        LHNAME = A << 8 | A;
        LHCELL = ASLIST;
        P = ;
        REDUCETAG(NO);
        PTYPEP = PTYPE;
        JJ = J;
        KK = K;
        II = I;
        LVL = OLDI;
        TPCELL = TCELL;
        ACCP = ACC;
        P = P2;
        TYPEP = TYPE;
        PRECP = PREC;
        goto SW;
        SW;
      SW_2:
      SW_3:
        if (TYPE == 3) goto;
        if (!(TYPE == 2 || TYPE == 5)) TYPE = 1;
        if (TYPE == 5) goto;
      BACK:
        HEAD1 = 0;
        BOT1 = 0;
        HEAD2 = 0;
        BOT2 = 0;
        if (!(TYPE == 2)) TYPE = 1;
        TYPEP = TYPE;
        NOPS = (1 << 18) + 1;
        PTYPE = PTYPEP;
        UNPACK();
        if (LHSADDRFIRST == NO || NAM == 0 && 0 == ARR && A == 2 && 2 == A) {
          OPND1 = 0;
          OPND1 = PTYPE;
          OPND1 = ARNAME;
          BINSERT(HEAD1, BOT1, OPND1, , LHNAME);
        } else {
          P = ;
          CNAME(3);
          BINSERT(HEAD1, BOT1, NAMEOPND, NAMEOPND, NAMEOPND);
        }
        P = P2 + 3;
        TORP(HEAD2, BOT2, NOPS, 0);
        OPND2 = 0;
        OPND2 = VASS + -2;
        BINSERT(HEAD2, BOT2, OPND2, LHNAME << 16 | PTYPEP, 0);
        ASLIST = HEAD2;
        HEAD2 = 0;
        BOT1 = BOT2;
        if (PARM != 0) PRINTLIST(HEAD1);
        EXPOP(HEAD1, BOT1, NOPS, 256 + (PRECP << 4) + TYPEP);
        TRIPOPT(TRIPLES, TRIPLES);
        OUTOPND(EXPOPND, 0);
        return;
      ST:
        P = ;
        if (== 3) {
          OUTSTRING("imp_strjam(");
          if (NAM != 0) WARN(10, 0);
        } else
          OUTSTRING("strcpy(");
        CNAME(2);
        OUTSYM(',');
        P = P2;
        CSTREXP(0);
        if (== 3) {
          OUTSYM(',');
          OUTINT(ACCP - 1);
        }
        OUTSYM(')');
        return;
      RECOP:
        Q = TSEXP;
        if (Q == 1 && JJJ == 0) {
          OUTSTRING("memset(");
          P = ;
          CNAME(3);
          OUTSTRING(",0,");
          OPND1 = NAMEOPND;
          OPND2 = 0;
          OPND2 = X '51';
          OPND2 = SCONST;
          OUTSTRING("sizeof( ");
          P = ;
          REDUCETAG(NO);
          OUTFORMATNAME(KFORM);
          OUTSYM(')');
          OUTSYM(')');
          P = P2;
          SKIPEXP();
          return;
        }
        if (== 3) {
          if (!(TYPE == 3 && A == 4)) goto BACK;
          OUTSTRING("memcpy(");
          P = ;
          CNAME(3);
          OUTSYM(',');
          OPND1 = NAMEOPND;
          ACCP = ACC;
          P = P2 + 5;
          CNAME(3);
          OUTSYM(',');
          OPND2 = NAMEOPND;
          if (!(A == 2)) {
            FAULT(66, 0, LHNAME);
            goto;
          }
          if (ACCP > ACC) ACCP = ACC;
          OUTSTRING("sizeof( ");
          P = ;
          REDUCETAG(NO);
          OUTFORMATNAME(KFORM);
          OUTSYM(')');
          OUTSYM(')');
          P = P2;
          SKIPEXP();
          return;
        }
        P = ;
        CNAME(7);
        OUTSTRING("=");
        P = P2 + 5;
        CNAME(7);
        P = P2;
        SKIPEXP();
        return;
      SW_4:
        OUTSTRING("imp_resolve(");
        P = ;
        CNAME(2);
        OUTSYM(',');
        P = P2;
        if (TYPE == 5)
          CRES(0);
        else {
          SKIPEXP();
          if (!(TYPE == 7)) FAULT(71, 0, LHNAME);
        }
        OUTSYM(')');
        return;
      SW_1:
        if (!(A == 4 && A == 1)) goto;
        if (!(NAM == 1 && LITL != 1)) {
          FAULT(82, 0, LHNAME);
          goto;
        }
        LHFORMATNAME = KFORM;
        if (ARR == 1) {
          JJ = 11;
          KK = 12;
          II = AHASS;
          B = AHEADPT;
        } else {
          JJ = 6;
          KK = 3;
          II = PTRAS;
          B = X '51';
          if (PTRSIZE > 4) B = X '61';
        }
        P = ;
        CNAME(JJ);
        OUTSYM('=');
        P = P2 + 5;
        RHNAME = A << 8 | A;
        if (TYPEP == 3) {
          REDUCETAG(NO);
          if (KFORM != LHFORMATNAME) {
            OUTSYM('(');
            OUTFORMATNAME(LHFORMATNAME);
            OUTSTRING("*)");
          }
        }
        CNAME(KK);
        if (KK == 12) {
          if (LHCELL & 15 == 0) LHCELL = LHCELL | (J & 15);
          if (LHCELL == 0) LHCELL = SNDISP;
        }
        if (!(A == 2)) goto;
        P = P + 1;
        return;
      F83:
        FAULT(83, LHNAME, RHNAME);
        goto;
      F86:
        FAULT(86, LHNAME, RHNAME);
        goto;
      F81:
        FAULT(81, 0, LHNAME);
      F00:
        P = P2;
        SKIPEXP();
      }
      void OUTOPND() {
        int I;
        int PP;
        double R;
        SW;
        if (&1 == 1) OUTSYM('(');
        goto SW;
        SW;
      SW_0:
      SW_1:
        if (&7 == 1) {
          if (&X 'f0' == X '60')
            OUTLHEX(, );
          else {
            if (&8 != 0 && DOINGLABEL == 0) {
              if (>> 4 & 7 == 3) {
              } else
                OUTHEX();
            } else
              OUTINT();
          }
        }
        if (== X '52') OUTFL(, 7);
        if (== X '62') {
          = ;
          = ;
          OUTFL(R, 15);
        }
        if (== X '72') {
          OUTSTRING("NAN or unrepresentable value");
        }
        if (== X '35') {
          OUTSYM('"');
          OUTSTRING();
          OUTSYM('"');
        }

      WAYOUT:
        if (&1 == 1) OUTSYM(')');
        return;
      SW_2:
        OUTNAME();
        goto WAYOUT;
      SW_3:
        PP = P;
        P = ;
        if (&2 != 0)
          CNAME(1);
        else
          CNAME(2);
        P = PP;
        goto WAYOUT;
      SW_8:
        OUTTRIPLE(, &X 'ff00');
        goto WAYOUT;
      }
      void OUTTRIPLE() {
        recfm *TRIP;
        const Imp_String RSASSOP[];
        Imp_String OP;
        Imp_String OPL;
        int CASE;
        int I;
        int J;
        SW;
        TRIP = TRIPLES;
        if (== 1 && DOINGLABEL == 0) OUTSYM('(');
        CASE = TRIP;
        goto SW;
        SW;
      SW_ADD:
        OP = "+";
        OPL = "plus";
      BINOP:
        OUTOPND(TRIP, &X 'ff00' | TRIP >> 3 & 1);
        if (DOINGLABEL != 0)
          OUTSTRING(OPL);
        else
          OUTSTRING(OP);
        OUTOPND(TRIP, &X 'ff00' | TRIP >> 3 & 1);
      WAYOUT:
        if (== 1 && DOINGLABEL == 0) OUTSYM(')');
        return;
      SW_SUB:
        OP = "-";
        OPL = "minus";
      SW_NONEQ:
        OP = "^";
        OPL = "non";
        goto BINOP;
      SW_ORL:
        OP = "|";
        OPL = "or";
        goto BINOP;
      SW_MULT:
        OP = "*";
        OPL = "mul";
        goto BINOP;
      SW_INTDIV:
        OP = " / ";
        OPL = "idiv";
        goto BINOP;
      SW_REALDIV:
        OP = " / ";
        OPL = "div";
        goto BINOP;
      SW_ANDL:
        OP = "&";
        OPL = "and";
        goto BINOP;
      SW_RSHIFT:
        OP = ">>";
        OPL = "rsh";
        if (DOINGLABEL == 0) {
          if (TRIP & X 'ff' == X '61') {
            OUTSTRING("(UINT64)");
          } else {
            OUTSTRING("(unsigned)");
          }
        }
        goto BINOP;
      SW_LSHIFT:
        OP = "<<";
        OPL = "lsh";
        goto BINOP;
      SW_IEXP:
        OUTSTRING("(int)");
      SW_REXP:
        OUTSTRING("pow(");
        OUTOPND(TRIP, &X 'ff00');
        OUTSTRING(",");
        OUTOPND(TRIP, &X 'ff00');
        OUTSTRING(")");
        goto WAYOUT;
      SW_RSTORE:
        if (ADD <= TRIP && TRIP <= SUB && 0 <= TRIP && TRIP <= 1) {
          OUTOPND(TRIP, &X 'ff00');
          if (TRIP == ADD)
            OUTSTRING("++");
          else
            OUTSTRING("--");
          goto WAYOUT;
        }
        OP = RSASSOP;
        goto;
      SW_VASS:
      SW_VJASS:
        OP = "=";
      ASSOP:
        OUTOPND(TRIP, &X 'ff00' | 2);
        OUTSTRING(OP);
        OUTOPND(TRIP, &X 'ff00' | 0);
        goto WAYOUT;
      SW_NOTL:
        OP = "~";
        OPL = "not";
      UNARYOP:
        if (DOINGLABEL != 0)
          OUTSTRING(OPL);
        else
          OUTSTRING(OP);
        OUTOPND(TRIP, &X 'ff00' | TRIP >> 3 & 1);
        goto WAYOUT;
      SW_LNEG:
        OP = "-";
        OPL = "uminus";
        goto UNARYOP;
      SW_IFLOAT:
        if (TRIP == SCONST) {
          TRIP = X '62';
          {
            double X;
            X = TRIP;
            TRIP = ;
            TRIP = ;
          }
          OP = "";
          goto UNARYOP;
        }
        OP = "(double)";
        goto UNARYOP;
        SW;
      SW_SHRTN:
      SW_LNGTHN:
      SW_JAMSHRTN:
      SW_NULLT:
      SW_PRELOAD:
        OUTOPND(TRIP, &X 'ff00' | 0);
      }
      void CSEXP() {
        int EXPHEAD;
        int NOPS;
        int EXPBOT;
        int FORM;
        EXPHEAD = 0;
        EXPBOT = 0;
        NOPS = 0;
        FORM = 0;
        P = P + 3;
        if (A == 4 && A == 3) FORM = 1;
        TORP(EXPHEAD, EXPBOT, NOPS, 0);
        EXPOP(EXPHEAD, EXPBOT, NOPS, &X 'ffff');
        OUTOPND(EXPOPND, FORM | >> 16);
      }
      void LABEXP() {
        DOINGLABEL = 1;
        CSEXP(X '51');
        DOINGLABEL = 0;
      }
      int CONSTEXP() {
        int EXPHEAD;
        int EXPBOT;
        int NOPS;
        int RES;
        EXPHEAD = 0;
        EXPBOT = 0;
        NOPS = 0;
        RES = 0;
        TORP(EXPHEAD, EXPBOT, NOPS, 1);
        EXPOP(EXPHEAD, EXPBOT, NOPS, X '200' +);
        if (!(EXPOPND <= 1)) goto;
        RES = ;
        WAYOUT;
      WAYOUT:
        return RES;
      }
      int INTEXP() {
        int EXPHEAD;
        int EXPBOT;
        int NOPS;
        int CODE;
        int SPTYPE;
        int SACC;
        EXPHEAD = 0;
        EXPBOT = 0;
        NOPS = 0;
        CODE = 0;
        SPTYPE = PTYPE;
        SACC = ACC;
        TORP(EXPHEAD, EXPBOT, NOPS, 1);
        EXPOP(EXPHEAD, EXPBOT, NOPS, X '200' +);
        if (!(EXPOPND <= 1 && EXPOPND & X '77' ==)) CODE = 1;
        VALUE = EXPOPND;
        ACC = SACC;
        PTYPE = SPTYPE;
        UNPACK();
        return CODE;
      }
      void TORP() {
        OPERAND;
        const char PRECEDENCE[];
        const char OPVAL[];
        int RPHEAD;
        int PASSHEAD;
        int SAVEHEAD;
        int REAL;
        int REALOP;
        int OPERATOR;
        int OPPREC;
        int OPND;
        int C;
        int D;
        int E;
        int BDISP;
        int OPNAME;
        int OPMASK;
        int RPBOT;
        int OPSTK;
        int OPPSTK;
        int PASSBOT;
        int PIN;
        recfm *LCELL;
        recfm RPOP;
        PASSHEAD = 0;
        RPHEAD = 0;
        SAVEHEAD = 0;
        REAL = 0;
        REALOP = 0;
        BDISP = 0;
        RPBOT = 0;
        OPSTK = 0;
        OPPSTK = 0;
        PIN = P;
        C = A;
        if (2 <= C && C <= 3) {
          = +1;
          OPSTK = C + 17;
          OPPSTK = PRECEDENCE;
          OPMASK = 1 << (19 + C);
        } else
          OPMASK = 0;
        NEXTOPND;
      NEXTOPND:
        OPND = A;
        P = P + 2;
        RPOP = 0;
        goto OPERAND;
      OPERAND_1:
        OPNAME = (A << 8) + A;
        LCELL = ASLIST;
        LCELL = LCELL | X '8000';
        PTYPE = LCELL;
        TYPE = PTYPE & 7;
        PREC = PTYPE >> 4 & 15;
        if (PTYPE == X 'FFFF') PTYPE = X '51';
        if (PTYPE == SNPT) {
          PTYPE = LCELL;
          UNPACK();
        }
        if (!= 0 || == "pi" && PTYPE & X 'FF00' == X '4000') {
          RPOP = LCELL;
          RPOP = LCELL;
          RPOP = 1;
          PTYPE = PTYPE & 255;
          if (TYPE == 1 && PREC <= 5) {
            = 0;
            PTYPE = MINAPT;
          }
          if (TYPE == 2) REAL = 1;
          P = P + 2;
          goto;
        }
        RPOP = OPNAME;
        RPOP = ARNAME;
        RPOP = P;
        if (PTYPE == X '57') PTYPE = X '51';
        if (TYPE == 3) {
          D = P;
          KFORM = LCELL;
          C = COPYRECORDTAG;
          P = D;
        }
        if (TYPE == 5) {
          FAULT(76, 0, OPNAME);
          RPOP = 0;
          = X '51';
        }
        if (PREC >= 6) OPMASK = OPMASK | 1 << 17;
        if (TYPE == 2) REAL = 1;
        P = P + 2;
      SKNAM:
        if (A == 2)
          P = P + 1;
        else
          SKIPAPP();
        if (A == 1) {
          P = P + 3;
          goto SKNAM;
        }
        P = P + 2;
      INS:
        if (RPOP == ARNAME) OPMASK = OPMASK | 1 << 18;
        if (PTYPE >> 4 & 15 > 5) OPMASK = OPMASK | 1 << 17;
        if (3 <= PTYPE & 7 && PTYPE & 7 <= 7) PTYPE = X '51';
        RPOP = PTYPE;
        BINSERT(RPHEAD, RPBOT, RPOP, RPOP, RPOP);
        goto;
      OPERAND_2:
        PTYPE = A;
        D = PTYPE >> 4;
        C = PTYPE & 7;
        if (PTYPE == X '61' && 1 << TARGET & LINTAVAIL == 0 || D == 7 && C == 2)
          FAULT(99, 0, 0);
        if (D >= 6) OPMASK = OPMASK | 1 << 17;
        if (D == 4 || D == 3) {
          D = 4;
          RPOP = FROMAR2;
        } else
          RPOP = FROMAR4;
        if (C == 2) REAL = 1;
        RPOP = 1;
        if (D == 6) RPOP = FROMAR4;
        if (C == 5) {
          FAULT(77, 0, 0);
          RPOP = 1;
          RPOP = 0;
          P = P + A + 3;
          PTYPE = X '51';
        } else {
          if (D == 7) {
            RPOP = RPOP;
            RPOP = P + 1;
          }
          if (PTYPE == X '51' && X 'FFFF8000' <= RPOP && RPOP <= X '7FFF') {
            = 0;
            PTYPE = MINAPT;
          }
          P = P + 2 + BYTES;
        }
        goto INS;
      OPERAND_3:
        PASSHEAD = 0;
        PASSBOT = 0;
        P = P + 3;
        TORP(PASSHEAD, PASSBOT, , );
        if (TYPE == 2) REAL = 1;
        if (RPBOT == 0)
          RPHEAD = PASSHEAD;
        else
          = PASSHEAD;
        RPBOT = PASSBOT;
        P = P + 1;
      OP:
        RPOP = 0;
        if (A == 2) goto;
        OPERATOR = A;
        if (OPERATOR == CONCOP) FAULT(78, 0, 0);
        OPPREC = PRECEDENCE;
        C = OPVAL;
        if (C == REALDIV || C == REXP) REAL = 1;
        = +1;
        while (OPPREC <= OPPSTK & 31) {
          RPOP = OPVAL;
          BINSERT(RPHEAD, RPBOT, RPOP, 0, 0);
          OPSTK = OPSTK >> 5;
          OPPSTK = OPPSTK >> 5;
        }
        OPSTK = OPSTK << 5 | OPERATOR;
        OPPSTK = OPPSTK << 5 | OPPREC;
        goto NEXTOPND;
      EOE:
        while (OPSTK != 0) {
          RPOP = OPVAL;
          BINSERT(RPHEAD, RPBOT, RPOP, 0, 0);
          OPSTK = OPSTK >> 5;
        }
        PTYPE = REAL + 1;
        TYPE = PTYPE;
        if (== 0)
          = RPBOT;
        else
          ASLIST = ;
        = RPHEAD;
        = | OPMASK;
      }
      void EXPOP() {
        auto void PSEVAL();
        int OPERAND[];
        int STK[];
        recfm *LIST;
        recfm *OPND1;
        recfm *OPND2;
        recfm *OPND;
        recfm *CURRT;
        int C;
        int D;
        int KK;
        int JJ;
        int COMM;
        int XTRA;
        int INHEAD;
        int CURRTRIP;
        int STPTR;
        int CONSTFORM;
        int CONDFORM;
        int SAVEP;
        int INITTRIP;
        const unsigned short int CORULES[];
        const int PTYPECH[];
        STPTR = 0;
        CONSTFORM = &512;
        INITTRIP = NEXTTRIP;
        CONDFORM = &256;
        SAVEP = P;
        INHEAD = ;
        PSEVAL();
        const int NEXT[];
      NEXT:
        LIST = ASLIST;
        XTRA = LIST;
        JJ = LIST;
        D = INHEAD;
        INHEAD = LIST;
        if (JJ >= 10) goto;
        OPND1 = ASLIST;
        STK = D;
        STPTR = STPTR + 1;
        if (STPTR > 99) IMPABORT();
      ANYMORE:
        if (!(INHEAD == 0)) goto NEXT;
        OPND1 = ASLIST;
        EXPOPND = OPND1;
        goto;
      OPERATOR:
        if (JJ < 128)
          KK = 1;
        else
          KK = 2;
        for (KK = KK; KK < 1; KK += -1) {
          STPTR = STPTR - 1;
          OPERAND = STK;
        }
        COMM = 1;
        OPND1 = ASLIST;
        if (JJ >= 128) {
          OPND2 = ASLIST;
        } else
          OPND2 = ;
        if (JJ < 128)
          C = 0;
        else
          C = CORULES;
        if (JJ == VASS || JJ == VJASS)
          KK = 1;
        else
          KK = 2;
        if (CONSTFORM != 0 && OPND1 < 2) (JJ, MASK, XTRA, OPND1, OPND2);
        if (JJ != 0) {
          CURRTRIP = NEWTRIP;
          CURRT = TRIPLES;
          CURRT = 0;
          CURRT = 0;
          CURRT = 1 | (C >> 1 & 128);
          CURRT = JJ;
          CURRT = OPND1;
          if (12 <= JJ && JJ <= 16) {
            CURRT = XTRA;
            XTRA = 0;
          } else if (&7 == 1 && OPND1 & 255 < MINAPT)
            = MINAPT;
          if (TARGET == PERQ || TARGET == ACCENT && == 39) = CURRT | DONTOPT;
          CURRT = XTRA;
          CURRT = OPND1;
          if (1 << OPND1 & BTREFMASK != 0) KEEPUSECOUNT(OPND1);
          if (JJ >= 128) {
            CURRT = OPND2;
            if (1 << OPND2 & BTREFMASK != 0) KEEPUSECOUNT(OPND2);
          }
          OPND1 = 8;
          OPND1 = CURRT;
          OPND1 = CURRTRIP;
        }
        STK = OPERAND;
        STPTR = STPTR + 1;
        goto ANYMORE;
      FINISH:
        PTYPE = EXPOPND;
        TYPE = PTYPE & 7;
        PREC = PTYPE >> 4;
        P = SAVEP;
        ASLIST = ASL;
        ASL = ;
        = 0;
        = 0;
        return;
        void PSEVAL() {
          auto void AMEND();
          auto void COERCET();
          auto void COERCEP();
          int TMPHEAD;
          int INHEAD;
          int C;
          int JJ;
          int NEXT;
          recfm *OPND1;
          recfm OPND2;
          recfm RPOP;
          recfm *CELL;
          if (!(ASLIST == 0)) {
            PRINTLIST();
            IMPABORT();
          }
          RPOP = 0;
          TMPHEAD = 0;
          INHEAD = ;
          while (INHEAD != 0) {
            CELL = ASLIST;
            NEXT = CELL;
            RPOP = CELL;
            JJ = RPOP;
            if (JJ < 10) {
              PUSH(TMPHEAD, RPOP, RPOP, INHEAD);
            } else {
              if (JJ >= 128) {
                POP(TMPHEAD, OPND2, OPND2, OPND2);
                OPND1 = ASLIST;
                C = CORULES;
                if (JJ == REXP && OPND2 & 7 == 2) C = X 'F2';
                if (C & 15 != 0) COERCET(C & 15);
                if (C >> 4 & 15 != 0) COERCEP(C >> 4 & 15);
              } else {
                OPND1 = ASLIST;
                if (JJ == MODULUS) {
                  if (OPND1 & 7 == 1 && RPOP & 7 == 2) COERCET(3);
                  if (OPND1 >> 4 & 15 < RPOP >> 4 & 15) (OPND1, LNGTHN);
                  if (OPND1 >> 4 & 15 > RPOP >> 4 & 15) (OPND1, SHRTN);
                } else {
                  if (JJ < 19) OPND1 = OPND1 + PTYPECH;
                }
              }
              OPND1 = INHEAD;
            }
            INHEAD = NEXT;
          }
          POP(TMPHEAD, OPND2, OPND2, OPND2);
          if (!(TMPHEAD == 0)) {
            PRINTLIST();
            IMPABORT();
          }
          if (CONDFORM == 0) {
            if (&7 == 1 && OPND2 & 7 == 2) FAULT(25, 0, 0);
            if (OPND2 & 7 == 1 && &7 == 2) AMEND(OPND2, IFLOAT);
            C = >> 4 & 15;
            while (C<OPND2>> 4 & 15) AMEND(OPND2, SHRTN);
            while (C > OPND2 >> 4 & 15) AMEND(OPND2, LNGTHN);
          }
          if (PARM != 0 && PARM != 0) PRINTLIST();
          while (ASLIST != 0) = ASLIST;
          return;
          void AMEND() {
            recfm RPOP;
            if (1 << TARGET & EMACHINE == 0 && == LNGTHN) {
              = OPND & X 'FF00' | MINAPT;
              return;
            }
            RPOP = 0;
            RPOP = ;
            if (== IFLOAT && OPND & 255 < MINAPT) = MINAPT;
            OPND = OPND + PTYPECH;
            if (1 << TARGET & LLREALAVAIL == 0 && == IFLOAT)
              OPND = OPND - X '10';
            INSERTAFTER(OPND, RPOP, OPND, 0);
            = +1;
          }
          void COERCET() {
            int PT1;
            int PT2;
            recfm RPOP;
            RPOP = 0;
            RPOP = 12;
            PT1 = OPND1 & 7;
            PT2 = OPND2 & 7;
            if (PT2 == 7) PT2 = 1;
            if (== 4) PT1 = CELL & 7;
            if (PT1 == 7) PT1 = 1;
            if (== 1 || == 15 && PT1 == 1 && 1 == PT2) return;
            if (== 1 || == 4 && PT1 == 1) {
              (24, 0, 0);
              return;
            }
            if (PT1 == 1) AMEND(OPND1, IFLOAT);
            if (PT2 == 1 && == 2 || == 4) (OPND2, IFLOAT);
          }
          void COERCEP() {
            int PREC1;
            int PREC2;
            int TPREC;
            int OPER;
            recfm *OPND;
            recfm RPOP;
            RPOP = 0;
            if (== 6) {
              COERCEP(4);
              = 2;
            }
            PREC1 = OPND1 >> 4 & 15;
            PREC2 = OPND2 >> 4 & 15;
            if (== 5 || == 1) {
              PREC1 = CELL >> 4 & 15;
              if (PREC2 > PREC1) {
                do {
                  if (== 1)
                    OPER = SHRTN;
                  else
                    OPER = JAMSHRTN;
                  AMEND(OPND2, OPER);
                  PREC2 = PREC2 - 1;
                } while (!(PREC1 == PREC2));
                return;
              } else
                = 1;
            }
            if (PREC1 < MINAPREC) {
              = MINAPREC;
              = OPND1 & X 'FF0F' | (MINAPREC << 4);
            }
            if (PREC2 < MINAPREC) {
              = MINAPREC;
              = OPND2 & X 'FF0F' | (MINAPREC << 4);
            }
            if (== 7) {
              = 4;
              if (PREC1 == 4) {
                AMEND(OPND1, LNGTHN);
                PREC1 = 5;
              }
            }
            if (2 <= && <= 4) {
              if (<= 2)
                OPND = OPND1;
              else
                OPND = OPND2;
              if (OPND & X 'FF' > MINAPT) AMEND(OPND, SHRTN);
              return;
            }
            if (PREC1 < PREC2) {
              = PREC2;
              OPND = OPND1;
            } else {
              = PREC1;
              OPND = OPND2;
            }
            OPER = OPND;
            while (OPND >> 4 & 15 < TPREC) AMEND(OPND, LNGTHN);
          }
        }
      }
      int CCOND() {
        auto void SKIPSC();
        auto void SKIPCOND();
        auto int CCOMP();
        auto void JUMP();
        auto void NOTEJUMP();
        auto void LABUNUSED();
        auto void OMITTO();
        int PIN;
        int PP;
        int II;
        int L;
        int CPTR;
        int CMAX;
        int LL;
        int BITMASK;
        int LLA;

        recfm CLIST[];
        recfm *C1;
        recfm *C2;
        PIN = P;
        CPTR = 1;
        L = 3;
        C1 = CLIST;
        C1 = 0;
        OUTSYM('(');
        if (== 2) {
          SKIPSC(1);
          SKIPCOND(1);
        } else {
          SKIPSC(0);
          SKIPCOND(0);
        }
        OUTSTRING(") ");
        return 0;
        void SKIPSC() {
          const Imp_String CMP[];
          const Imp_String REVCMP[];
          SCALT;
          int ALT;
          int TE1;
          int TE2;
          int PRECP;
          int TYPEP;
          int FINALP;
          int REXP;
          ALT = A;
          P = P + 1;
          goto SCALT;
          SCALT;
        SCALT_1:
          C1 = P;
          TE1 = TSEXP;
          TYPEP = TYPE;
          PRECP = PREC;
          P = C1;
          SKIPEXP();
          C1 = A;
          C1 = 3 *;
          P = P + 1;
          C1 = P;
          SKIPEXP();
          if (A == 2)
            P = P + 1;
          else {
            C1 = A;
            P = P + 2;
            C1 = P;
            SKIPEXP();
          }
          FINALP = P;
          if (TYPEP == 5) {
            P = C1;
            if (C1 == 8) {
              OUTSTRING("imp_resolve(");
              P = P + 5;
              CNAME(2);
              OUTSYM(',');
              P = C1;
              CRES(1);
              if (== 1) {
                OUTSTRING(")!=0");
              } else {
                OUTSTRING(")==0");
              }
              if (C1 != 0) OUTSTRING("untranslateable cond");
            } else {
              if (C1 != 0) OUTSYM('(');
              OUTSTRING("strcmp(");
              CSTREXP(0);
              OUTSYM(',');
              P = C1;
              CSTREXP(0);
              OUTSYM(')');
              if (== 1) {
                OUTSTRING(REVCMP);
              } else {
                OUTSTRING(CMP);
              }
              OUTSYM('0');
              if (C1 != 0) {
                if (== 1) {
                  OUTSTRING(") || (");
                } else {
                  OUTSTRING(") && (");
                }
                P = C1;
                CSTREXP(0);
                OUTSYM(',');
                P = C1;
                CSTREXP(0);
                OUTSYM(')');
              }
            }
          } else {
            if (C1 != 0) OUTSYM('(');
            P = C1;
            REXP = 2 - A;
            if (REXP != 0) OUTSYM('(');
            if (C1 > 8) {
              P = P + 5;
              CNAME(4);
            } else
              CSEXP(PRECP << 4 | TYPEP | 256);
            if (REXP != 0) OUTSYM(')');
            if (== 1) {
              OUTSTRING(REVCMP);
            } else {
              OUTSTRING(CMP);
            }
            P = C1;
            REXP = 2 - A;
            if (REXP != 0) OUTSYM('(');
            if (C1 > 8) {
              P = P + 5;
              CNAME(4);
            } else
              CSEXP(PRECP << 4 | TYPEP | 256);
            if (REXP != 0) OUTSYM(')');
            if (C1 != 0) {
              if (== 1) {
                OUTSTRING(") || (");
              } else {
                OUTSTRING(") && (");
              }
              if (REXP != 0) OUTSYM('(');
              P = C1;
              CSEXP(PRECP << 4 | TYPEP);
              if (REXP != 0) OUTSYM(')');
              if (== 1) {
                OUTSTRING(REVCMP);
              } else {
                OUTSTRING(CMP);
              }
              P = C1;
              REXP = 2 - A;
              if (REXP != 0) OUTSYM('(');
              CSEXP(PRECP << 4 | TYPEP);
              if (REXP != 0) OUTSYM(')');
              OUTSYM(')');
            }
          }
          P = FINALP;
          return;
        SCALT_2:
          OUTSYM('(');
          L = L + 1;
          SKIPSC();
          SKIPCOND();
          L = L - 1;
          OUTSYM(')');
          return;
        SCALT_3:
          SKIPSC (^1);
          return;
        SCALT_4:
          if (== 1)
            OUTSTRING(
                "/* what is a pseudo-boolean? - is the conditio accidentally "
                "inverted? */");
          CSEXP(X '51');
        }
        void SKIPCOND() {
          int ALT;
          int ALTP;
          ALT = A;
          P = P + 1;
          if (ALT != 3) {
            while (!(ALTP == 2)) {
              C1 = L;
              C1 = ALT;
              C1 = C1 ^ (3 *);
              if (== 1) {
                if (ALT == 1)
                  OUTSTRING(" || ");
                else
                  OUTSTRING(" && ");
              } else {
                if (ALT == 1)
                  OUTSTRING(" && ");
                else
                  OUTSTRING(" || ");
              }
              CPTR = CPTR + 1;
              C1 = CLIST;
              C1 = 0;
              SKIPSC();
              ALTP = A;
              P = P + 1;
            }
          }
        }
      }
      int REVERSE() {
        if (MASK == 0 || MASK == 15) return MASK ^ 15;
        return MASK ^ X '8F';
      }
      int ENTERLAB() { return 0; }
      void ENTERJUMP() {}
      void REMOVELAB() {}
      int CREATEAH() {
        int JJ;
        JJ = BRECTRIP;
        TRIPLES = PTYPE << 4 | ;
        return JJ;
      }
      void CSNAME() {
        auto int OPTMAP();
        ADHOC;
        const Imp_String SMDETAILS[];
        const int SNINFO[];
        const Imp_String SNXREFS[];
        if (PARAMSBWARDS == YES) {
          const int SNPARAMS[];

        } else {
          const int SNPARAMS[];
        }
        const char WRONGZ[];
        auto void RTOS();
        auto int CIOCP();
        recfm *LCELL;
        recfm PCELL;
        recfm OPND;
        recfm OPERATOR;
        recfm *CURRT;
        Imp_String SNXREF;
        int ERRNO;
        int FLAG;
        int POINTER;
        int PIN;
        int SNNO;
        int SNNAME;
        int NAPS;
        int SNPTYPE;
        int JJ;
        int XTRA;
        int IOCPEP;
        int B;
        int D;
        int SNINF;
        int P0;
        int OPHEAD;
        int ERRVAL;
        int EXPHEAD;
        int EXPBOT;
        int FORMATNAME;
        int NOPS;
        SNNAME = FROMAR2;
        SNNO = K;
        TESTAPP(NAPS);
        PIN = P;
        P = P + 2;
        SNPTYPE = ACC;
        SNINF = SNINFO;
        XTRA = SNINF & X 'FFFF';
        POINTER = (SNINF >> 16) & 255;
        FLAG = SNINF >> 24;
        if (SNPTYPE & 255 == X '61' && 1 << TARGET & LINTAVAIL == 0) {
          = 99;
          goto;
        }
        goto ADHOC;
        ADHOC;
      ADHOC_47:
        OUTSTRING("imp_substring(");
        P = P + 1;
        CSTREXP(0);
        OUTSYM(',');
        P = P + 1;
        CSEXP(X '51');
        OUTSYM(',');
        P = P + 1;
        CSEXP(X '51');
        OUTSYM(')');
        P = P + 1;
        goto;
      ADHOC_24:
      ADHOC_25:
      ADHOC_26:
      ADHOC_27:
      ADHOC_28:
      ADHOC_29:
      ADHOC_30:
        SNXREF = SNXREFS;
        P0 = SNPARAMS;
        if (TARGET == PERQ || TARGET == ACCENT) {
          JJ = ;
          D = ;
          MOVEBYTES(D + 1, JJ, 0, , WORKA);
          JJ = -;
          WORKA = (WORKA + D + 4) & (-4);
        } else
          CXREF(SNXREF, 3 * PARM, P0 << 16 | P0 >> 16, JJ);
        OPHEAD = 0;
        K = OPHEAD;
        D = 1;
        while (D <= P0 & 15) {
          B = SNPARAMS;
          PTYPE = B & X 'FFFF';
          UNPACK();
          if (NAM == 0)
            ACC = BYTES;
          else
            ACC = 8;
          if (PTYPE == X '35') ACC = 256;
          PCELL = 0;
          PCELL = PTYPE;
          PCELL = B >> 16;
          PCELL = ACC;
          if (PARAMSBWARDS == YES)
            (OPHEAD, PCELL, PCELL, 0);
          else
            (OPHEAD, PCELL, PCELL, 0);
          D = D + 1;
        }
        if (P0 > 0) ASLIST = P0;
        LCELL = ASLIST;
        LCELL = SNPTYPE;
        LCELL = 1 << 4 | 14;
        LCELL = JJ;
        LCELL = BYTES;
        LCELL = OPHEAD;
        LCELL = 0;
        P = PIN;
        CNAME();
        P = P - 1;
        return;
      ADHOC_6:
      ADHOC_7:
        if (PARM == 0) {
          if (SNNO == 6)
            OUTSTRING("_imp_newlines(");
          else
            OUTSTRING("_imp_spaces(");
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
          P = P + 1;
          goto;
        }
        P = P + 1;
        if (TSEXP > 0 && JJ > 0) {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          for (XTRA = 1; XTRA < JJ; XTRA += 1) {
            if (SNNO == 6)
              OUTSTRING("\n");
            else
              OUTSTRING(" ");
          }
          OUTSYM('"');
          OUTSYM(')');
        } else {
          P = PIN + 3;
          OUTSTRING("{ for (_imptempint=1; _imptempint<=");
          CSEXP(X '51');
          OUTSTRING("; _imptempint++) fprintf(out_file, ");
          OUTSYM('"');
          if (SNNO == 6)
            OUTSTRING("\n");
          else
            OUTSTRING(" ");
          OUTSYM('"');
          OUTSTRING(");}");
        }
        P = P + 1;
        goto;
      ADHOC_37:
        if (PARM == 0) {
          OUTSTRING("_imp_printstring(");
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING("%s");
          OUTSYM('"');
          OUTSTRING(", ");
        }
        P = P + 1;
        CSTREXP(0);
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_2:
        if (PARM == 0) {
        }
        P = P + 1;
        goto;
      ADHOC_3:
        if (PARM == 0) {
          OUTSTRING("_imp_spaces(1)");
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING("%s");
          OUTSYM('"');
          OUTSTRING(", ");
          OUTSYM('"');
          OUTSYM(' ');
          OUTSYM('"');
          OUTSYM(')');
        }
        P = P + 1;
        goto;
      ADHOC_21:
      ADHOC_22:
      ADHOC_61:
      ADHOC_66:
      ADHOC_39:
      ADHOC_32:
      ADHOC_54:
      ADHOC_55:
        OUTSTRING("(*(");
        OUTTYPE(SNPTYPE & 255, 0);
        OUTSTRING(" *)(");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING("))");
        P = P + 1;
        goto;
      ADHOC_42:
        OUTSTRING("((char *)");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_45:
        if (!= 2) WARN(10, 0);
        P = P + 1;
        CSTREXP(0);
        OUTSYM('[');
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING("-1]");
        P = P + 1;
        goto;
      ADHOC_36:
        if (!= 2) WARN(10, 0);
        OUTSTRING("strlen(");
        P = P + 1;
        CSTREXP(0);
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_46:
        OUTSTRING("imp_tostring(");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_9:
      ADHOC_40:
        if (PARM == 0) {
          OUTSTRING("_imp_printsymbol(");
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING("%c");
          OUTSYM('"');
          OUTSTRING(", ");
        }
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_12:
        if (PARM == 0) {
          OUTSTRING("_imp_write(");
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(',');
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
          P = P + 1;
          goto;
        }
        P = P + 1;
        SKIPEXP();
        P = P + 1;
        JJ = TSEXP;
        P = PIN + 2;
        if (JJ != 0) {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING("%");
          OUTINT(+1);
          OUTSTRING("d");
          OUTSYM('"');
          OUTSTRING(",");
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING(" %d");
          OUTSYM('"');
          OUTSTRING(",");
        }
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = PIN + 2;
        SKIPAPP();
        P = P - 1;
        goto;
      ADHOC_19:
        if (PARM == 0) {
          OUTSTRING("_imp_print(");
          P = P + 1;
          CSEXP(X '62');
          OUTSYM(',');
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(',');
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING(" %f");
          OUTSYM('"');
          OUTSTRING(",");
          P = P + 1;
          CSEXP(X '62');
          OUTSTRING(")");
        }
        P = PIN + 2;
        SKIPAPP();
        P = P - 1;
        goto;
      ADHOC_20:
        if (PARM == 0) {
          OUTSTRING("_imp_printf(");
          P = P + 1;
          CSEXP(X '62');
          OUTSYM(',');
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
        } else {
          OUTSTRING("fprintf(out_file, ");
          OUTSYM('"');
          OUTSTRING(" %e");
          OUTSYM('"');
          OUTSTRING(",");
          P = P + 1;
          CSEXP(X '62');
          OUTSTRING(")");
        }
        P = PIN + 2;
        SKIPAPP();
        P = P - 1;
        goto;
      ADHOC_0:
        if (PARM == 0) {
          OUTSTRING("_imp_selectinput(");
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
          P = P + 1;
          goto;
        }
        OUTSTRING("selectinput(");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_1:
        if (PARM == 0) {
          OUTSTRING("_imp_selectoutput(");
          P = P + 1;
          CSEXP(X '51');
          OUTSYM(')');
          P = P + 1;
          goto;
        }
        OUTSTRING("selectoutput(");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_default:
        OUTSTRING("/* Call to ");
        OUTSTRING(SMDETAILS);
        OUTSTRING(" - please modify pass2.i to handle it */");
        SKIPAPP();
        P = P - 1;
        goto;
      ADHOC_64:
      ADHOC_65:
        if (!(TYPEFLAG & 255 == X '61' && TYPEFLAG & 255 >= X '62')) {
          = 99;
          goto;
        }
        OUTSTRING("((long int) floor(");
        P = P + 1;
        CSEXP(TYPEFLAG & 255);
        if (SNNO == 64) OUTSTRING("+0.5");
        OUTSTRING("))");
        P = P + 1;
        P0 = X '61';
        goto;
      ADHOC_16:
      ADHOC_17:
        OUTSTRING("((int) floor(");
        P = P + 1;
        CSEXP(LRLPT);
        if (SNNO == 16) OUTSTRING("+0.5");
        OUTSTRING("))");
        P = P + 1;
        goto;
      ADHOC_67:
        OUTSTRING("((int)(");
        P = P + 1;
        CSEXP(LRLPT);
        OUTSTRING("))");
        P = P + 1;
        goto;
      ADHOC_4:
        OUTSTRING("(void)fgetc(in_file)");
        P = P + 2;
        goto;
      ADHOC_8:
        P = P + 6;
        CNAME(1);
        OUTSTRING("ungetc(fgetc(in_file), in_file)");
        P = P + 2;
        goto;
      ADHOC_10:
      ADHOC_41:
        P = P + 6;
        CNAME(1);
        OUTSTRING(" = fgetc(in_file)");
        P = P + 2;
        goto;
      ADHOC_14:
        P = P + 6;
        CNAME(4);
        P = P + 2;
        goto;
      ADHOC_23:
        OUTSTRING("fabs(");
        P = P + 1;
        CSEXP(X '62');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_51:
        OUTSTRING("abs(");
        P = P + 1;
        CSEXP(X '51');
        OUTSTRING(")");
        P = P + 1;
        goto;
      ADHOC_52:
      ADHOC_38:
        P = P + 1;
        goto;
      ADHOC_48:
        P = P + 1;
        if (TSEXP == 1 && JJ == 0) {
          OUTSTRING("NULL");
        } else {
          if (!= 4) {
            OUTSYM('(');
          }
          P = PIN + 3;
          CSEXP(X '51');
          P = P + 1;
          OUTSYM(')');
        }
        DISP = 0;
        BASE = 0;
        ACCESS = 3;
        OLDI = 0;
        ACC = X 'FFFF';
        SNPTYPE = SNPTYPE + X '1C00';
        PTYPE = SNPTYPE;
        UNPACK();
        return;
      ADHOC_49:
        P = P + 1;
        SKIPEXP();
        ERRNO = 22;
        ERRVAL = 2;
        if (!(A == 4 && A == 1)) goto;
        P = P + 6;
        FORMATNAME = FROMAR2;
        COPYTAG(FORMATNAME, NO);
        P = P + 4;
        if (!(A == 2)) goto;
        XTRA = P + 2;
        OUTSTRING("((");
        OUTTYPE(PTYPE & 255, LHFORMATNAME);
        OUTSTRING("*)(");
        P = PIN + 3;
        CSEXP(X '51');
        OUTSTRING("))");
        COPYTAG(FORMATNAME, NO);
        P = XTRA;
        return;
      ADHOC_13:
        D = CURRINF;
        if (D == 0) FAULT(16, 0, SNNAME);
        if (SNNO != 33) D = D + 4;
        BASE = RBASE;
        ACCESS = 0;
        DISP = D;
        SNPTYPE = SNPTYPE + X '1C00';
        goto;
        D = (SNNO & 3) * 8;
        JJ = X '62517261' >> D & 255;
        if (1 << TARGET & LLREALAVAIL == 0 && JJ == X '72') JJ = X '62';
        if (1 << TARGET & LINTAVAIL == 0 && JJ == X '61') JJ = X '51';
        CSEXP(JJ);
        P = P + 1;
        NAMEOPND = EXPOPND;
        goto;
      ADHOC_15:
        if (!(PARM == 0)) JJ = UCONSTTRIP;
        goto;
        CSEXP(LRLPT);
        NAMEOPND = EXPOPND;
        P = P + 1;
      OKEXIT:
        PTYPE = SNPTYPE;
        UNPACK();
        ACC = BYTES;
        return;
      ERREXIT:
        FAULT(ERRNO, ERRVAL, SNNAME);
        NAMEOPND = 0;
        NAMEOPND = X '51';
        BASE = 0;
        DISP = 0;
        ACCESS = 0;
        AREA = 0;
        PTYPE = SNPTYPE;
        UNPACK();
        P = PIN + 2;
        SKIPAPP();
        P = P - 1;
        return;
        int CIOCP() {
          recfm OPND;
          OPND = MINAPT;
          OPND = SCONST;
          OPND = ;
          return BRECTRIP;
        }
        void RTOS() {
          int KK;
          int JJ;
          if (EXPOPND <= 1) {
            KK = ITOS1;
            CTOP(KK, JJ, 0, EXPOPND, NAMEOPND);
            if (KK == 0) {
              NAMEOPND = EXPOPND;
              return;
            }
          }
          JJ = URECTRIP;
          NAMEOPND = X '35';
          NAMEOPND = REFTRIP;
          NAMEOPND = JJ;
        }
      }
      void CANAME() {
        int HEAD1;
        int BOT1;
        int NOPS;
        int ELSIZE;
        int PTYPEP;
        int JJ;
        int SOLDI;
        int KK;
        int PP;
        int TYPEP;
        int LB;
        int ARRNAME;
        int Q;
        int PRECP;
        int NAMINF;
        int DVD;
        int DVDP;
        int PRIVOPS;
        recfm VMYOP;
        recfm RPOP;
        recfm *LCELL;
        int HEADS[];
        int BOTS[];
        NOPS = 0;
        HEAD1 = 0;
        BOT1 = 0;
        PP = P;
        TYPEP = TYPE;
        JJ = J;
        PTYPEP = PTYPE;
        PRECP = PREC;
        SOLDI = OLDI;
        if (TYPE <= 2)
          ELSIZE = BYTES;
        else
          ELSIZE = ACC;
        if (ELSIZE > 4095 || TYPE == 5 && NAM != 0) ELSIZE = 0;
        DVD = SNDISP;
        VMYOP = 0;
        VMYOP = 0;
        ARRNAME = FROMAR2;
        NAMINF = TAGS;
        if (ARR == 3) FAULT(87, 0, ARRNAME);
        if (DVD > 0) {
          VMYOP = X '51';
          VMYOP = DVD;
        } else
          = ;
        TESTAPP(Q);
        if (JJ == 0) {
          LCELL = ASLIST;
          LCELL = LCELL | Q;
          JJ = Q;
        }
        if (JJ == Q && Q != 0) {
          P = PP + 3;
          for (KK = 1; KK < JJ; KK += 1) {
            HEADS = P;
            SKIPEXP();
            P = P + 1;
          }
          PP = P;
          OUTSTRING(" [");
          DVDP = DVD + 3 * JJ;
          for (KK = JJ; KK < 1; KK += -1) {
            P = HEADS;
            CSEXP(X '51');
            LB = CTABLE;
            if (DVD != 0) {
              if (LB == X '80000000') {
              } else if (LB > 0) {
              } else if (LB == 0) {
              } else if (LB < 0) {
              }
            } else {
              WARN(13, 0);
            }
            if (!(KK == 1)) OUTSTRING("] [");
            DVDP = DVDP - 3;
          }
          P = PP;
          OUTSYM(']');
        } else {
          RPOP = 0;
          RPOP = SCONST;
          BINSERT(HEAD1, BOT1, RPOP, 0, 0);
          if (JJ > Q)
            FAULT(20, JJ - Q, ARRNAME);
          else
            (21, Q - JJ, ARRNAME);
          P = P + 2;
          SKIPAPP();
        }
        SOLDI = OLDI;
        ACCESS = 3;
        ACC = ELSIZE;
        PTYPE = PTYPEP;
        UNPACK();
        J = JJ;
        if (TYPE == 5 && NAM > 0) MLOPND = ;
        OLDI = SOLDI;
        return;
      }
      void NAMEPREAMBLE() {
        int TYPEP;
        int QQ;
        int SUBS;
        int PP;
        TYPEP = TYPE;
        PP = P;
        if (TYPEP == 3) {
          QQ = COPYRECORDTAG;
          P = PP;
        }
        if (== 3 && TYPE != 5) OUTSYM('&');
        if (== 4 && TYPE != 5) OUTSTRING("(int)&");
        if (== 4 && TYPE == 5 || NAM != 0 && ARR == 0) OUTSTRING("(int)");
        if (== 1 || == 2 && NAM != 0 && ARR == 0 && 0 == ROUT ||
            NAM >= 2 && ROUT == 1)
          OUTSYM('*');
        if (== 7 && TYPEP == 3) ('*');
        OUTNAME(FNAME);
        if (TYPEP == 3) COPYTAG(FNAME, NO);
      }
      void CNAME() {
        int JJ;
        int KK;
        int LEVELP;
        int DISPP;
        int NAMEP;
        int PP;
        int SAVESL;
        int FNAME;
        recfm TOPND;
        S;
        FUNNY;
        SW;
        PP = P;
        FNAME = (A << 8) + A;
        if (== 1 || == 6) STNAME = FNAME;
        COPYTAG(FNAME, YES);
        SAVESL = ACC;
        JJ = J;
        if (JJ == 15) JJ = 0;
        NAMEP = FNAME;
        LEVELP = I;
        DISPP = K;
        if (== 1 && ROUT == 0 && 0 == NAM) FAULT(43, 0, FNAME);
        if (TYPE == 7) goto;
        if (== 0 && ROUT != 1 || 0 != TYPE && TYPE != 6 || == 13 && ROUT == 0) {
          (27, 0, FNAME);
          goto;
        }
        if (>= 10) goto FUNNY;
        if (ROUT == 1) goto;
        NAMEPREAMBLE(, FNAME);
        goto SW;
        SW;
      SW_6:
        FAULT(5, 0, FNAME);
        goto;
      SW_4:
        FAULT(87, 0, FNAME);
      NOTSET:
        NAMEPREAMBLE(, FNAME);
      SW_7:
        BASE = I;
        DISP = K;
        ACCESS = 0;
        NAMEOPND = 0;
        NAMEOPND = X '51';
        PTYPE = X '51';
        UNPACK();
        P = P + 2;
        if (A == 1) {
          JJ = '(';
          OUTSYM(JJ);
          P = P + 1;
          CSEXP(X '51');
          while (A == 1) {
            OUTSYM(',');
            P = P + 1;
            CSEXP(X '51');
          }
          OUTSYM(JJ + 1 + (JJ >> 6));
        }
        P = P + 1;
        goto;
      FUNNY_11:
      FUNNY_12:
        if (PTYPE == SNPT) {
          CSNAME(12);
          goto;
        }
        NAMEPREAMBLE(, FNAME);
        if (TYPE == 3 && ARR == 0 || A == 1) goto SW;
        if (A == 2)
          P = P + 3;
        else
          NOAPP();
        NAMEOPND = DNAME;
        NAMEOPND = FNAME;
        NAMEOPND = 0;
      S_12:
      S_11:
        NAMEOPND = AHEADPT;
        goto;
      FUNNY_13:
        if (PTYPE == SNPT) {
          CSNAME();
          P = P + 1;
          goto;
        }
        NAMEPREAMBLE(, FNAME);
        JJ = UNAMETRIP;
        NAMEOPND = RTPARAMPT;
        NAMEOPND = REFTRIP;
        NAMEOPND = JJ;
        NAMEOPND = 0;
        if (A == 2)
          P = P + 3;
        else
          NOAPP();
        goto;
      RFUN:
        EXPOPND = NAMEOPND;
      RMAP:
        COPYTAG(NAMEP, NO);
        P = P - 3;
        NAMEP = -1;
        CRNAME(, 3, 0, 0, NAMEP);
        goto;
      SW_3:
        CRNAME(, 2 * NAM, I, K, NAMEP);
      RBACK:
        if (>= 10) goto S;
        if (TYPE == 5 && != 6) goto;
        if (TYPE == 7) goto NOTSET;
        NAMEOP(, BYTES, NAMEP);
        if (== 1 || == 6) STNAME = NAMEP;
        goto;
      SW_5:
        if (== 6) goto SW;
        if (ARR >= 1) goto;
        if (A == 2)
          P = P + 3;
        else
          NOAPP();
        BASE = I;
        ACCESS = 2 * NAM;
        DISP = K;
      SMAP:
        MLOPND = 0;
        if (NAM != 1) {
          MLOPND = X '51';
          MLOPND = SAVESL - 1;
        } else {
          MLOPND = X '61';
          MLOPND = LOCALIR;
          MLOPND = I << 16 | K;
        }
        NAMEOP(, 4, NAMEP);
        goto;
      STRARR:
        TOPND = 0;
        TOPND = AHEADPT;
        TOPND = DNAME;
        TOPND = FNAME;
        CANAME(, ARR, TOPND);
        if (!(== 3 && NAM != 0)) goto SMAP;
        NAMEOP(3, 4, NAMEP);
        goto;
      STRINREC:
        SAVESL = ACC;
        if (!(== 3 && NAM != 0)) goto SMAP;
        NAMEOP(3, 4, NAMEP);
        goto;
      RTCALL:
        if (TYPE == 0 && != 0) {
          FAULT(23, 0, FNAME);
          goto NOTSET;
        }
        if (PTYPE == SNPT) {
          CSNAME();
          if (ROUT == 1 && NAM > 1) goto;
          goto;
        }
        NAMEPREAMBLE(, FNAME);
        CRCALL(FNAME);
        P = P + 1;
        if (PTYPE & 15 == 0) goto;
        if (NAM > 1) goto;
        if (!(== 2 || == 5)) {
          FAULT(29, 0, FNAME);
          BASE = 0;
          ACCESS = 0;
          DISP = 0;
        }
        if (TYPE == 3) goto RFUN;
        goto;
      UDM:
        DISP = 0;
        ACCESS = 3;
        BASE = 0;
        EXPOPND = NAMEOPND;
        if (TYPE == 3) goto RMAP;
      BIM:
        NAMEP = -1;
        STNAME = -1;
        if (TYPE == 5) {
          SAVESL = 256;
          goto SMAP;
        }
        KK = ;
        if (== 5) KK = 2;
        NAMEOP(, BYTES, NAMEP);
        goto;
      SW_0:
        if (!(3 <= && <= 4)) {
          FAULT(90, 0, FNAME);
          TYPE = 1;
        }

      SW_1:
      SW_2:
        if (ARR == 0 || == 6 && A == 2) {
          BASE = I;
          ACCESS = 2 * NAM;
          DISP = K;
          if (A == 2)
            P = P + 3;
          else
            NOAPP();
        } else {
          TOPND = 0;
          TOPND = AHEADPT;
          TOPND = DNAME;
          TOPND = FNAME;
          CANAME(, ARR, TOPND);
          NAM = 0;
        }
        NAMEOP(, BYTES, NAMEP);
        goto;
      CHKEN:
        while (A == 1) {
          FAULT(69, FROMAR2, FNAME);
          OUTSYM('_');
          OUTNAME(FROMAR2);
          P = P + 3;
          SKIPAPP();
        }
        P = P + 1;
      }
      void NAMEOP() {}
      void CRCALL() {
        int II;
        int III;
        int QQQ;
        int JJ;
        int JJJ;
        int NPARMS;
        int PT;
        int LP;
        int PSIZE;
        int TWSP;
        int PARMNO;
        int ERRNO;
        int FPTR;
        int TYPEP;
        int PRECP;
        int NAMP;
        int TL;
        int CLINK;
        int PSPECED;
        int OUTP;
        int PPTYPE;
        int DVD;
        int DVDP;
        int LB;
        int KK;
        recfm OPND;
        recfm OPND1;
        recfm OPND2;
        recfm *LCELL;
        PT = PTYPE;
        JJJ = J;
        TL = OLDI;
        TWSP = 0;
        FPTR = 0;
        LP = I;
        CLINK = K;
        TYPEP = TYPE;
        PRECP = PREC;
        NAMP = NAM;
        if (CLINK == 0)
          PSPECED = 0;
        else
          PSPECED = ASLIST & 255;
        {
          int ARP[];
          FPD;
          P = P + 2;
          NPARMS = 0;
          while (A == 1) {
            P = P + 1;
            if (NPARMS < PSPECED) {
              if (PARAMSBWARDS == YES)
                = P;
              else
                ARP = P;
            }
            NPARMS = NPARMS + 1;
            SKIPEXP();
          }
          OUTP = P;
          if (PSPECED != NPARMS) {
            if (PSPECED == 0)
              ERRNO = 17;
            else {
              if (NPARMS < PSPECED)
                ERRNO = 18;
              else
                ERRNO = 19;
            }
            FAULT(ERRNO, , );
            SKIPAPP();
            P = P - 1;
            NAMEOPND = 0;
            NAMEOPND = X '51';
            goto;
          }
          II = UNAMETRIP;
          PARMNO = 0;
          OUTSYM('(');
          goto;
          BADPARM;
        BADPARM:
          if (PARAMSBWARDS == YES)
            II = PSPECED - PARMNO + 1;
          else
            II = PARMNO;
          FAULT(22, II, );
        NEXTPARM:
          CLINK = LCELL;
          if (!(CLINK == 0)) OUTSYM(',');
        FIRSTPARM:
          if (CLINK == 0) goto;
          LCELL = ASLIST;
          PSIZE = LCELL & X 'FFFF';
          PARMNO = PARMNO + 1;
          P = ARP;
          PTYPE = LCELL;
          UNPACK();
          II = TYPE;
          III = PREC;
          JJ = (NAM << 1 | ARR) & 3;
          if (!(JJ == 0 && ROUT == 0 || JJ == 2)) goto BADPARM;
          OPND = PTYPE;
          OPND = DNAME;
          OPND = ;
          OPND = PARMNO << 24 | CLINK;
          if (ROUT == 1) {
            II = PTYPE;
            P = P + 5;
            CNAME(13);
            if (II & 255 != PTYPE & 255) goto BADPARM;
            P = P + 1;
            FPTR = FPTR + RTPARAMSIZE;
            goto NEXTPARM;
          }
          goto FPD;
        FPD_0:
          if (TYPE == 3) {
            II = TSEXP;
            if (II == 1 && III == 0) {
              goto BADPARM;
            } else {
              P = ARP;
              if (!(== 4 && A == 1)) goto BADPARM;
              P = P + 5;
              CNAME(6);
              P = P + 1;
              JJ = 1;
              EXPOPND = NAMEOPND;
              if (!(ACC == PSIZE)) goto BADPARM;
            }
            FPTR = FPTR + PSIZE;
            if (TARGET == EMAS) FPTR = FPTR + 8;
          } else if (TYPE == 5) {
            if (STRVALINWA == YES) {
              CSTREXP(0);
              PUSH(TWSP, VALUE, 0, 0);
              FPTR = FPTR + PTRSIZE;
              PPTYPE = X '51';
              if (PTRSIZE > 4) PPTYPE = X '61';
              OPND1 = 0;
              OPND2 = 0;
              OPND2 = SCONST;
              OPND2 = X '51';
              OPND2 = LCELL - 1;
              OPND1 = LOCALIR;
              OPND1 = X '35';
              OPND1 = RBASE << 16 | VALUE;
              OPND1 = REFTRIP;
              OPND1 = PPTYPE;
              goto NEXTPARM;
            } else {
              CSTREXP(0);
              FPTR = FPTR + ACC;
            }

          } else {
            CSEXP(III << 4 | II);
            FPTR = FPTR + BYTES;
          }
          FPTR = (FPTR + MINPARAMSIZE - 1) & (-MINPARAMSIZE);
          goto NEXTPARM;
        FPD_2:
          PPTYPE = X '51';
          if (PTRSIZE > 4) PPTYPE = X '61';
          if (II != 0) {
            QQQ = 0;
            if (A == 4 && A == 1) {
              P = P + 5;
              REDUCETAG(YES);
              if (II == TYPE && III == PREC)
                QQQ = 1;
              else
                P = P - 5;
            }
            if (QQQ != 0)
              CNAME(3);
            else {
              if (!(JJJ == 14 || LP == 0)) goto BADPARM;
              if (II == 3) goto BADPARM;
              if (II == 5) {
                CSTREXP(0);
                PUSH(TWSP, VALUE, 0, 0);
                QQQ = VALUE;
                OPND2 = 255;
              } else {
                GETWSP(QQQ, BYTES >> 2);
                CSEXP(LCELL & 255);
                OPND2 = BYTES;
              }
              OPND2 = SCONST;
              OPND2 = X '51';
              OPND1 = LOCALIR;
              OPND1 = LCELL & 255;
              OPND1 = RBASE << 16 | QQQ;
              OPND1 = 268;
              if (II != 5) = REFTRIP;
              NAMEOPND = PPTYPE;
              NAMEOPND = QQQ;
            }
            JJ = PTRSIZE;
            FPTR = FPTR + JJ;
          } else {
            if (!(== 4 && A == 1)) goto BADPARM;
            P = P + 5;
            FNAME = FROMAR2;
            REDUCETAG(NO);
            OPND2 = X '51';
            OPND2 = SCONST;
            OPND2 = ACC << 16 | PTYPE;
            OPND2 = 0;
            if (TYPE == 0) {
              NAMEOPND = PTYPE;
              NAMEOPND = DNAME;
              NAMEOPND = FNAME;
              NAMEOPND = X '80000000';
            } else if (NAM != 0 && TYPE == 5) {
              CNAME(3);
            } else
              CNAME(4);
            EXPOPND = X '61';
            EXPOPND = REFTRIP;
            EXPOPND = 0;
            FPTR = FPTR + PTRSIZE;
          }
          P = P + 1;
          goto NEXTPARM;
        FPD_1:
        FPD_3:
          P = P + 5;
          REDUCETAG(NO);
          DVD = SNDISP;
          if (DVD != 0) OUTSYM('&');
          CNAME(12);
          P = P + 1;
          if (!(1 <= ARR && ARR <= 2 && II == TYPE)) goto BADPARM;
          QQQ = ASLIST & 15;
          JJ = LCELL & 15;
          if (JJ == 0) {
            JJ = QQQ;
            LCELL = LCELL | JJ;
          }
          if (QQQ == 0) {
            QQQ = JJ;
            = ASLIST | JJ;
          }
          if (!(JJ == QQQ)) goto BADPARM;
          if (DVD != 0) {
            DVDP = DVD + 3 * JJ;
            for (KK = JJ; KK < 1; KK += -1) {
              LB = CTABLE;
              OUTSYM('[');
              if (LB == X '80000000') {
                OUTSTRING("-(");
                P = CTABLE;
                CSEXP(X '51');
                OUTSYM(')');
              } else if (LB > 0) {
                OUTSYM('-');
                OUTINT(LB);
              } else if (LB <= 0) {
                OUTINT(-LB);
              }
              OUTSTRING("] ");
              DVDP = DVDP - 3;
            }
          }
          FPTR = FPTR + AHEADSIZE;
          goto NEXTPARM;
        ENTRYSEQ:
          OUTSYM(')');
          while (TWSP > 0) {
            POP(TWSP, QQQ, JJ, III);
            RETURNWSP(QQQ, 268);
          }
          if (STRRESINWA == YES && NAMP <= 1) {
            GETWSP(QQQ, 268);
            OPND2 = PT;
            OPND2 = LOCALIR;
            OPND2 = RBASE << 16 | QQQ;
            OPND2 = 268;
            OPND = PT;
            OPND = DNAME;
            OPND = ;
            OPND = (PSPECED + 1) << 24;
            FPTR = FPTR + PTRSIZE;
          }
          II = UNAMETRIP;
          TRIPLES = FPTR;
          CURRINF = CURRINF | 2;
          ROUT = 1;
          TYPE = TYPEP;
          NAM = NAMP;
          PREC = PRECP;
          PTYPE = PT;
          if (PT & 255 != 0) {
            if (NAM >= 2)
              II = RCRMR;
            else
              II = RCRFR;
            II = UNAMETRIP;
            if (STRRESINWA == YES) TRIPLES = QQQ;
            NAMEOPND = PT & 255;
            NAMEOPND = REFTRIP;
            NAMEOPND = II;
            NAMEOPND = 0;
          }
        OVER:
          P = OUTP;
        }
      }
      int TSEXP() {
        SW;
        int PP;
        int KK;
        int SIGN;
        int CT;
        TYPE = 1;
        PP = P;
        P = P + 3;
        SIGN = A;
        if (!(SIGN == 4 || A == 2)) goto;
        goto SW;
        SW;
      SW_1:
        P = P + 2;
        REDUCETAG(NO);
        if (PTYPE & X 'ff0f' == X '4001') {
          if (A == 2 && A == 2) {
            VALUE = MIDCELL;
            P = P + 5;
            if (SIGN != 2) return 2;
            VALUE = -VALUE;
            return -2;
          }
        }
        goto;
      SW_2:
        CT = A;
        TYPE = CT & 7;
        if (!(CT == X '41' && SIGN != 3)) goto;
        KK = FROMAR2;
        if (!(A == 2)) goto;
        VALUE = KK;
        P = P + 6;
        if (SIGN != 2) return 1;
        VALUE = -VALUE;
        return -1;
      SW_3:
      TYPED:
        P = PP;
        return 0;
      }
      int TSC() {
        int VALUE;
        int RES;
        int PP;
        SW;
        PP = P;
        goto SW;
        SW;
      SW_1:
        P = P + 1;
        RES = TSEXP;
        if (RES == 0) return 0;
        P = P + 1;
        RES = TSEXP;
        if (RES == 0) return 0;
        P = P + 1;
        if (A == 1) return 0;
        return 1;
      SW_2:
        P = P + 1;
        RES = TCOND;
        return RES;
      SW_3:
        P = P + 1;
        return TSC;
      SW_4:
        return TSEXP;
      }
      int TCOND() {
        int VALUE;
        int RES;
        int PP;
        PP = P;
        RES = TSC;
        if (RES == 0) return 0;
        if (A == 3) {
          P = P + 1;
          return 1;
        }
        while (!(A == 2)) {
          P = P + 1;
          RES = TSC;
          if (RES == 0) return 0;
        }
        P = P + 1;
        return 1;
      }
      void SKIPEXP() {
        int OPTYPE;
        int PIN;
        int J;
        int PRECP;
        PIN = P;
        P = P + 3;
        do {
          OPTYPE = A;
          P = P + 2;
          if (OPTYPE == 0 || OPTYPE > 3) IMPABORT();
          if (OPTYPE == 3) SKIPEXP();
          if (OPTYPE == 2) {
            J = A & 7;
            if (J == 5)
              P = P + A + 2;
            else {
              PRECP = A >> 4;
              if (PRECP == 3) PRECP = 4;
              P = P + 1 + BYTES;
            }
          }
          if (OPTYPE == 1) {
            P = P - 1;
            while (!(A == 2)) {
              P = P + 3;
              SKIPAPP();
            }
            P = P + 1;
          }
          P = P + 1;
          if (A == 2) break;
        } while (1);
      }
      void SKIPAPP() {
        int PIN;
        PIN = P;
        while (A == 1) {
          P = P + 1;
          SKIPEXP();
        }
        P = P + 1;
      }
      void NOAPP() {
        P = P + 2;
        if (A == 1) {
          FAULT(17, 0, FROMAR2);
          OUTSYM('[');
          while (A == 1) {
            P = P + 1;
            CSEXP(X '51');
            if (A == 1) OUTSYM(',');
          }
          P = P + 1;
          OUTSYM(']');
        } else
          P = P + 1;
      }
      void TESTAPP() {
        int PP;
        int Q;
        Q = 0;
        PP = P;
        P = P + 2;
        while (A == 1) {
          P = P + 1;
          Q = Q + 1;
          SKIPEXP();
        }
        P = PP;
        = Q;
      }
      void SETLINE() {
        int I;
        int OFFSET;
        if (RLEVEL == 0) return;
        OFFSET = CURRINF + 2;
        if (TARGET == ORN || 1 << TARGET & RISKMC != 0) OFFSET = OFFSET + 2;
        I = UCONSTTRIP;
        if (PARM != 0) {
          I = PROFAAD + 4 + 4 * LINE;
        }
      }
      void STORETAG() {
        int Q;
        int I;
        int TCELL;
        recfm *LCELL;
        TCELL = TAGS;
        Q = LEVEL << 8 | RBASE << 4 | J;
        if (!((KFORM | ACC) >> 16 == 0)) IMPABORT();
        LCELL = ASLIST;
        if (LCELL >> 8 & 63 == LEVEL || KK == CURRINF - 1) {
          LCELL = LCELL & X 'C000' | Q;
        } else {
          I = ASL;
          if (I == 0) I = MORESPACE;
          LCELL = ASLIST;
          ASL = LCELL;
          LCELL = TCELL | CURRINF << 18;
          LCELL = Q;
          TAGS = I;
          CURRINF = KK;
        }
        LCELL = PTYPE;
        LCELL = ACC;
        LCELL = SNDISP;
        LCELL = KFORM;
        LCELL = ;
      }
      void COPYTAG() {
        recfm *LCELL;
        TCELL = TAGS;
        if (TCELL == 0) {
          TYPE = 7;
          PTYPE = X '57';
          PREC = 5;
          if (== YES) {
            FAULT(16, 0, );
            STORETAG(, LEVEL, RBASE, 0, 0, 4, N, 0);
            N = N + 4;
            COPYTAG(, NO);
            return;
          }
          ROUT = 0;
          NAM = 0;
          ARR = 0;
          LITL = 0;
          ACC = 4;
          I = -1;
          J = -1;
          K = -1;
          OLDI = -1;
          KFORM = -1;
        } else {
          LCELL = ASLIST;
          PTYPE = LCELL & X 'FFFF';
          USEBITS = LCELL >> 14 & 3;
          OLDI = LCELL >> 8 & 63;
          I = LCELL >> 4 & 15;
          J = LCELL & 15;
          LCELL = LCELL | X '8000';
          MIDCELL = LCELL;
          SNDISP = LCELL & X 'FFFF';
          ACC = LCELL & X 'FFFF';
          K = LCELL & X 'FFFF';
          KFORM = LCELL;
          LITL = PTYPE >> 14 & 3;
          ROUT = PTYPE >> 12 & 3;
          NAM = PTYPE >> 10 & 3;
          ARR = PTYPE >> 8 & 3;
          PREC = PTYPE >> 4 & 15;
          TYPE = PTYPE & 15;
        }
      }
      void REDUCETAG() {
        int SUBS;
        int QQ;
        int PP;
        COPYTAG(FROMAR2, );
        if (PTYPE == SNPT) {
          PTYPE = ACC;
          UNPACK();
          if (K == 42)
            ACC = 256;
          else if (== 48)
            ACC = X '7fff';
          else
            ACC = BYTES;
        }
        if (TYPE == 3) {
          PP = P;
          QQ = COPYRECORDTAG;
          P = PP;
        }
      }
      void UNPACK() {
        LITL = PTYPE >> 14;
        ROUT = PTYPE >> 12 & 3;
        NAM = PTYPE >> 10 & 3;
        ARR = PTYPE >> 8 & 3;
        PREC = PTYPE >> 4 & 15;
        TYPE = PTYPE & 15;
      }
      void PACK() {
        PTYPE = (((((LITL & 3) << 2 | ROUT & 3) << 2 | NAM & 3) << 2 | ARR & 3)
                     << 4 |
                 PREC & 15)
                    << 4 |
                TYPE & 15;
      }
    }
    int NEWTRIP() {
      recfm *CURRT;
      int I;
      CURRT = TRIPLES;
      I = NEXTTRIP;
      if (I >= WORKA) I = 1;
      NEXTTRIP = I + 1;
      CURRT = 0;
      CURRT = TRIPLES;
      TRIPLES = I;
      TRIPLES = I;
      return I;
    }
    int UCONSTTRIP() {
      recfm *CURRT;
      int CELL;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = X '51';
      CURRT = ;
      return CELL;
    }
    int ULCONSTTRIP() {
      recfm *CURRT;
      int CELL;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = X '61';
      CURRT = ;
      CURRT = ;
      return CELL;
    }
    int UNAMETRIP() {
      recfm *TAGINF;
      recfm *CURRT;
      int CELL;
      TAGINF = ASLIST;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = TAGINF;
      CURRT = DNAME;
      CURRT = ;
      CURRT = 0;
      return CELL;
    }
    int UTEMPTRIP() {
      int CELL;
      recfm *CURRT;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = LOCALIR;
      CURRT = ;
      return CELL;
    }
    void KEEPUSECOUNT() {
      recfm *REFT;
      REFT = TRIPLES;
      if (REFT == 0) {
        REFT = TRIPLES;
      }
      REFT = REFT + 1;
    }
    int URECTRIP() {
      int CELL;
      recfm *CURRT;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      if (1 << &BTREFMASK != 0) KEEPUSECOUNT();
      return CELL;
    }
    int BRECTRIP() {
      int CELL;
      recfm *CURRT;
      CELL = NEWTRIP;
      CURRT = TRIPLES;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      CURRT = ;
      if (1 << &BTREFMASK != 0) KEEPUSECOUNT();
      if (1 << &BTREFMASK != 0) KEEPUSECOUNT();
      return CELL;
    }
    void GETWSP() {
      int J;
      int K;
      int L;
      int F;
      F = >> 31;
      = << 1 >> 1;
      if (> 4) = 0;
      POP(CURRINF, J, K, L);
      if (K <= 0) {
        if (== 4)
          L = RNDING;
        else if (== 2)
          L = RNDING;
        else
          L = 3;
        N = (N + L) & (~L);
        K = N;
        if (== 0)
          N = N + 268;
        else
          N = N + (<< 2);
      }
      = K;
      if (!(F != 0)) PUSH(TWSPHEAD, K, , 0);
    }
    void RETURNWSP() {
      int CELL;
      if (!(<= N && &1 == 0)) IMPABORT();
      if (> 4) = 0;
      CELL = CURRINF;
      while (CELL > 0) {
        if (ASLIST ==) IMPABORT();
        CELL = ASLIST;
      }
      if (< 511)
        PUSH(CURRINF, 0, , 0);
      else
        (CURRINF, 0, , 0);
    }
    void REUSETEMPS() {
      int JJ;
      int KK;
      int QQ;
      while (TWSPHEAD != 0) {
        POP(TWSPHEAD, JJ, KK, QQ);
        RETURNWSP(JJ, KK);
      }
    }
    int FROMAR2() { return A << 8 | A; }
    int FROMAR4() {
      int I;
      MOVEBYTES(4, , , , 0);
      return I;
    }
    P2END;
  P2END:
  }
}