prop-src/sparc.C

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.0),
   3 //  last updated on Feb 5, 1997.
   4 //  The original source file is "sparc.pC".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_REWRITING_USED
   8 #define PROP_EQUALITY_USED
   9 #define PROP_QUARK_USED
  10 #include <propdefs.h>
  11 #line 36 "sparc.pC"
  12 ///////////////////////////////////////////////////////////////////////////////
  13 // Forward class definition for Inst
  14 ///////////////////////////////////////////////////////////////////////////////
  15 #ifndef datatype_Inst_defined
  16 #define datatype_Inst_defined
  17    typedef class a_Inst * Inst;
  18 #endif
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21 // Class hierarchy for datatype Inst
  22 ///////////////////////////////////////////////////////////////////////////////
  23 class a_Inst; // base class for datatype Inst
  24    class Inst_ADDD;     // subclass for 'ADDD (Inst, Inst)'
  25    class Inst_ADDF;     // subclass for 'ADDF (Inst, Inst)'
  26    class Inst_ADDI;     // subclass for 'ADDI (Inst, Inst)'
  27    class Inst_ADDP;     // subclass for 'ADDP (Inst, Inst)'
  28    class Inst_ADDU;     // subclass for 'ADDU (Inst, Inst)'
  29    class Inst_ADDRFP;   // subclass for 'ADDRFP ()'
  30    class Inst_ADDRGP;   // subclass for 'ADDRGP ()'
  31    class Inst_ADDRLP;   // subclass for 'ADDRLP ()'
  32    class Inst_ARGB;     // subclass for 'ARGB Inst'
  33    class Inst_ARGD;     // subclass for 'ARGD Inst'
  34    class Inst_ARGF;     // subclass for 'ARGF Inst'
  35    class Inst_ARGI;     // subclass for 'ARGI Inst'
  36    class Inst_ARGP;     // subclass for 'ARGP Inst'
  37    class Inst_ASGNB;    // subclass for 'ASGNB (Inst, Inst)'
  38    class Inst_ASGNC;    // subclass for 'ASGNC (Inst, Inst)'
  39    class Inst_ASGND;    // subclass for 'ASGND (Inst, Inst)'
  40    class Inst_ASGNF;    // subclass for 'ASGNF (Inst, Inst)'
  41    class Inst_ASGNI;    // subclass for 'ASGNI (Inst, Inst)'
  42    class Inst_ASGNP;    // subclass for 'ASGNP (Inst, Inst)'
  43    class Inst_ASGNS;    // subclass for 'ASGNS (Inst, Inst)'
  44    class Inst_BANDU;    // subclass for 'BANDU (Inst, Inst)'
  45    class Inst_BCOMU;    // subclass for 'BCOMU Inst'
  46    class Inst_BORU;     // subclass for 'BORU (Inst, Inst)'
  47    class Inst_BXORU;    // subclass for 'BXORU (Inst, Inst)'
  48    class Inst_CALLB;    // subclass for 'CALLB (Inst, Inst)'
  49    class Inst_CALLD;    // subclass for 'CALLD Inst'
  50    class Inst_CALLF;    // subclass for 'CALLF Inst'
  51    class Inst_CALLI;    // subclass for 'CALLI Inst'
  52    class Inst_CALLV;    // subclass for 'CALLV Inst'
  53    class Inst_CNSTC;    // subclass for 'CNSTC ()'
  54    class Inst_CNSTD;    // subclass for 'CNSTD ()'
  55    class Inst_CNSTF;    // subclass for 'CNSTF ()'
  56    class Inst_CNSTI;    // subclass for 'CNSTI ()'
  57    class Inst_CNSTP;    // subclass for 'CNSTP ()'
  58    class Inst_CNSTS;    // subclass for 'CNSTS ()'
  59    class Inst_CNSTU;    // subclass for 'CNSTU ()'
  60    class Inst_CVCI;     // subclass for 'CVCI Inst'
  61    class Inst_CVCU;     // subclass for 'CVCU Inst'
  62    class Inst_CVDF;     // subclass for 'CVDF Inst'
  63    class Inst_CVDI;     // subclass for 'CVDI Inst'
  64    class Inst_CVFD;     // subclass for 'CVFD Inst'
  65    class Inst_CVIC;     // subclass for 'CVIC Inst'
  66    class Inst_CVID;     // subclass for 'CVID Inst'
  67    class Inst_CVIS;     // subclass for 'CVIS Inst'
  68    class Inst_CVIU;     // subclass for 'CVIU Inst'
  69    class Inst_CVPU;     // subclass for 'CVPU Inst'
  70    class Inst_CVSI;     // subclass for 'CVSI Inst'
  71    class Inst_CVSU;     // subclass for 'CVSU Inst'
  72    class Inst_CVUC;     // subclass for 'CVUC Inst'
  73    class Inst_CVUI;     // subclass for 'CVUI Inst'
  74    class Inst_CVUP;     // subclass for 'CVUP Inst'
  75    class Inst_CVUS;     // subclass for 'CVUS Inst'
  76    class Inst_DIVD;     // subclass for 'DIVD (Inst, Inst)'
  77    class Inst_DIVF;     // subclass for 'DIVF (Inst, Inst)'
  78    class Inst_DIVI;     // subclass for 'DIVI (Inst, Inst)'
  79    class Inst_DIVU;     // subclass for 'DIVU (Inst, Inst)'
  80    class Inst_EQD;      // subclass for 'EQD (Inst, Inst)'
  81    class Inst_EQF;      // subclass for 'EQF (Inst, Inst)'
  82    class Inst_EQI;      // subclass for 'EQI (Inst, Inst)'
  83    class Inst_GED;      // subclass for 'GED (Inst, Inst)'
  84    class Inst_GEF;      // subclass for 'GEF (Inst, Inst)'
  85    class Inst_GEI;      // subclass for 'GEI (Inst, Inst)'
  86    class Inst_GEU;      // subclass for 'GEU (Inst, Inst)'
  87    class Inst_GTD;      // subclass for 'GTD (Inst, Inst)'
  88    class Inst_GTF;      // subclass for 'GTF (Inst, Inst)'
  89    class Inst_GTI;      // subclass for 'GTI (Inst, Inst)'
  90    class Inst_GTU;      // subclass for 'GTU (Inst, Inst)'
  91    class Inst_INDIRB;   // subclass for 'INDIRB Inst'
  92    class Inst_INDIRC;   // subclass for 'INDIRC Inst'
  93    class Inst_INDIRD;   // subclass for 'INDIRD Inst'
  94    class Inst_INDIRF;   // subclass for 'INDIRF Inst'
  95    class Inst_INDIRI;   // subclass for 'INDIRI Inst'
  96    class Inst_INDIRP;   // subclass for 'INDIRP Inst'
  97    class Inst_INDIRS;   // subclass for 'INDIRS Inst'
  98    class Inst_JUMPV;    // subclass for 'JUMPV Inst'
  99    class Inst_LABELV;   // subclass for 'LABELV ()'
 100    class Inst_LED;      // subclass for 'LED (Inst, Inst)'
 101    class Inst_LEF;      // subclass for 'LEF (Inst, Inst)'
 102    class Inst_LEI;      // subclass for 'LEI (Inst, Inst)'
 103    class Inst_LEU;      // subclass for 'LEU (Inst, Inst)'
 104    class Inst_LOADB;    // subclass for 'LOADB Inst'
 105    class Inst_LOADC;    // subclass for 'LOADC Inst'
 106    class Inst_LOADD;    // subclass for 'LOADD Inst'
 107    class Inst_LOADF;    // subclass for 'LOADF Inst'
 108    class Inst_LOADI;    // subclass for 'LOADI Inst'
 109    class Inst_LOADP;    // subclass for 'LOADP Inst'
 110    class Inst_LOADS;    // subclass for 'LOADS Inst'
 111    class Inst_LOADU;    // subclass for 'LOADU Inst'
 112    class Inst_LSHI;     // subclass for 'LSHI (Inst, Inst)'
 113    class Inst_LSHU;     // subclass for 'LSHU (Inst, Inst)'
 114    class Inst_LTD;      // subclass for 'LTD (Inst, Inst)'
 115    class Inst_LTF;      // subclass for 'LTF (Inst, Inst)'
 116    class Inst_LTI;      // subclass for 'LTI (Inst, Inst)'
 117    class Inst_LTU;      // subclass for 'LTU (Inst, Inst)'
 118    class Inst_MODI;     // subclass for 'MODI (Inst, Inst)'
 119    class Inst_MODU;     // subclass for 'MODU (Inst, Inst)'
 120    class Inst_MULD;     // subclass for 'MULD (Inst, Inst)'
 121    class Inst_MULF;     // subclass for 'MULF (Inst, Inst)'
 122    class Inst_MULI;     // subclass for 'MULI (Inst, Inst)'
 123    class Inst_MULU;     // subclass for 'MULU (Inst, Inst)'
 124    class Inst_NED;      // subclass for 'NED (Inst, Inst)'
 125    class Inst_NEF;      // subclass for 'NEF (Inst, Inst)'
 126    class Inst_NEI;      // subclass for 'NEI (Inst, Inst)'
 127    class Inst_NEGD;     // subclass for 'NEGD Inst'
 128    class Inst_NEGF;     // subclass for 'NEGF Inst'
 129    class Inst_NEGI;     // subclass for 'NEGI Inst'
 130    class Inst_RETD;     // subclass for 'RETD Inst'
 131    class Inst_RETF;     // subclass for 'RETF Inst'
 132    class Inst_RETI;     // subclass for 'RETI Inst'
 133    class Inst_RSHI;     // subclass for 'RSHI (Inst, Inst)'
 134    class Inst_RSHU;     // subclass for 'RSHU (Inst, Inst)'
 135    class Inst_SUBD;     // subclass for 'SUBD (Inst, Inst)'
 136    class Inst_SUBF;     // subclass for 'SUBF (Inst, Inst)'
 137    class Inst_SUBI;     // subclass for 'SUBI (Inst, Inst)'
 138    class Inst_SUBP;     // subclass for 'SUBP (Inst, Inst)'
 139    class Inst_SUBU;     // subclass for 'SUBU (Inst, Inst)'
 140    class Inst_VREGP;    // subclass for 'VREGP ()'
 141
 142 ///////////////////////////////////////////////////////////////////////////////
 143 // Base class for datatype 'Inst'
 144 ///////////////////////////////////////////////////////////////////////////////
 145 class a_Inst : public TermObj {
 146 public:
 147    enum Tag_Inst {
 148       tag_ADDD = 0, tag_ADDF = 1, tag_ADDI = 2, tag_ADDP = 3,
 149       tag_ADDU = 4, tag_ADDRFP = 5, tag_ADDRGP = 6, tag_ADDRLP = 7,
 150       tag_ARGB = 8, tag_ARGD = 9, tag_ARGF = 10, tag_ARGI = 11,
 151       tag_ARGP = 12, tag_ASGNB = 13, tag_ASGNC = 14, tag_ASGND = 15,
 152       tag_ASGNF = 16, tag_ASGNI = 17, tag_ASGNP = 18, tag_ASGNS = 19,
 153       tag_BANDU = 20, tag_BCOMU = 21, tag_BORU = 22, tag_BXORU = 23,
 154       tag_CALLB = 24, tag_CALLD = 25, tag_CALLF = 26, tag_CALLI = 27,
 155       tag_CALLV = 28, tag_CNSTC = 29, tag_CNSTD = 30, tag_CNSTF = 31,
 156       tag_CNSTI = 32, tag_CNSTP = 33, tag_CNSTS = 34, tag_CNSTU = 35,
 157       tag_CVCI = 36, tag_CVCU = 37, tag_CVDF = 38, tag_CVDI = 39,
 158       tag_CVFD = 40, tag_CVIC = 41, tag_CVID = 42, tag_CVIS = 43,
 159       tag_CVIU = 44, tag_CVPU = 45, tag_CVSI = 46, tag_CVSU = 47,
 160       tag_CVUC = 48, tag_CVUI = 49, tag_CVUP = 50, tag_CVUS = 51,
 161       tag_DIVD = 52, tag_DIVF = 53, tag_DIVI = 54, tag_DIVU = 55,
 162       tag_EQD = 56, tag_EQF = 57, tag_EQI = 58, tag_GED = 59,
 163       tag_GEF = 60, tag_GEI = 61, tag_GEU = 62, tag_GTD = 63,
 164       tag_GTF = 64, tag_GTI = 65, tag_GTU = 66, tag_INDIRB = 67,
 165       tag_INDIRC = 68, tag_INDIRD = 69, tag_INDIRF = 70, tag_INDIRI = 71,
 166       tag_INDIRP = 72, tag_INDIRS = 73, tag_JUMPV = 74, tag_LABELV = 75,
 167       tag_LED = 76, tag_LEF = 77, tag_LEI = 78, tag_LEU = 79,
 168       tag_LOADB = 80, tag_LOADC = 81, tag_LOADD = 82, tag_LOADF = 83,
 169       tag_LOADI = 84, tag_LOADP = 85, tag_LOADS = 86, tag_LOADU = 87,
 170       tag_LSHI = 88, tag_LSHU = 89, tag_LTD = 90, tag_LTF = 91,
 171       tag_LTI = 92, tag_LTU = 93, tag_MODI = 94, tag_MODU = 95,
 172       tag_MULD = 96, tag_MULF = 97, tag_MULI = 98, tag_MULU = 99,
 173       tag_NED = 100, tag_NEF = 101, tag_NEI = 102, tag_NEGD = 103,
 174       tag_NEGF = 104, tag_NEGI = 105, tag_RETD = 106, tag_RETF = 107,
 175       tag_RETI = 108, tag_RSHI = 109, tag_RSHU = 110, tag_SUBD = 111,
 176       tag_SUBF = 112, tag_SUBI = 113, tag_SUBP = 114, tag_SUBU = 115,
 177       tag_VREGP = 116
 178    };
 179
 180 protected:
 181    const Tag_Inst _tag_;
 182    inline a_Inst(Tag_Inst _t_) : _tag_(_t_) {}
 183 public:
 184    inline int untag() const { return _tag_; }
 185    inline friend int boxed(const a_Inst * x) { return 1; }
 186    inline friend int untag(const a_Inst * x) { return x->_tag_; }
 187    ////////////////////////////////////////////////////////////////////////////
 188    // Downcasting functions for Inst
 189    ////////////////////////////////////////////////////////////////////////////
 190    inline friend Inst_ADDD * _ADDD(Inst _x_) { return (Inst_ADDD *)_x_; }
 191    inline friend Inst_ADDF * _ADDF(Inst _x_) { return (Inst_ADDF *)_x_; }
 192    inline friend Inst_ADDI * _ADDI(Inst _x_) { return (Inst_ADDI *)_x_; }
 193    inline friend Inst_ADDP * _ADDP(Inst _x_) { return (Inst_ADDP *)_x_; }
 194    inline friend Inst_ADDU * _ADDU(Inst _x_) { return (Inst_ADDU *)_x_; }
 195    inline friend Inst_ADDRFP * _ADDRFP(Inst _x_) { return (Inst_ADDRFP *)_x_; }
 196    inline friend Inst_ADDRGP * _ADDRGP(Inst _x_) { return (Inst_ADDRGP *)_x_; }
 197    inline friend Inst_ADDRLP * _ADDRLP(Inst _x_) { return (Inst_ADDRLP *)_x_; }
 198    inline friend Inst_ARGB * _ARGB(Inst _x_) { return (Inst_ARGB *)_x_; }
 199    inline friend Inst_ARGD * _ARGD(Inst _x_) { return (Inst_ARGD *)_x_; }
 200    inline friend Inst_ARGF * _ARGF(Inst _x_) { return (Inst_ARGF *)_x_; }
 201    inline friend Inst_ARGI * _ARGI(Inst _x_) { return (Inst_ARGI *)_x_; }
 202    inline friend Inst_ARGP * _ARGP(Inst _x_) { return (Inst_ARGP *)_x_; }
 203    inline friend Inst_ASGNB * _ASGNB(Inst _x_) { return (Inst_ASGNB *)_x_; }
 204    inline friend Inst_ASGNC * _ASGNC(Inst _x_) { return (Inst_ASGNC *)_x_; }
 205    inline friend Inst_ASGND * _ASGND(Inst _x_) { return (Inst_ASGND *)_x_; }
 206    inline friend Inst_ASGNF * _ASGNF(Inst _x_) { return (Inst_ASGNF *)_x_; }
 207    inline friend Inst_ASGNI * _ASGNI(Inst _x_) { return (Inst_ASGNI *)_x_; }
 208    inline friend Inst_ASGNP * _ASGNP(Inst _x_) { return (Inst_ASGNP *)_x_; }
 209    inline friend Inst_ASGNS * _ASGNS(Inst _x_) { return (Inst_ASGNS *)_x_; }
 210    inline friend Inst_BANDU * _BANDU(Inst _x_) { return (Inst_BANDU *)_x_; }
 211    inline friend Inst_BCOMU * _BCOMU(Inst _x_) { return (Inst_BCOMU *)_x_; }
 212    inline friend Inst_BORU * _BORU(Inst _x_) { return (Inst_BORU *)_x_; }
 213    inline friend Inst_BXORU * _BXORU(Inst _x_) { return (Inst_BXORU *)_x_; }
 214    inline friend Inst_CALLB * _CALLB(Inst _x_) { return (Inst_CALLB *)_x_; }
 215    inline friend Inst_CALLD * _CALLD(Inst _x_) { return (Inst_CALLD *)_x_; }
 216    inline friend Inst_CALLF * _CALLF(Inst _x_) { return (Inst_CALLF *)_x_; }
 217    inline friend Inst_CALLI * _CALLI(Inst _x_) { return (Inst_CALLI *)_x_; }
 218    inline friend Inst_CALLV * _CALLV(Inst _x_) { return (Inst_CALLV *)_x_; }
 219    inline friend Inst_CNSTC * _CNSTC(Inst _x_) { return (Inst_CNSTC *)_x_; }
 220    inline friend Inst_CNSTD * _CNSTD(Inst _x_) { return (Inst_CNSTD *)_x_; }
 221    inline friend Inst_CNSTF * _CNSTF(Inst _x_) { return (Inst_CNSTF *)_x_; }
 222    inline friend Inst_CNSTI * _CNSTI(Inst _x_) { return (Inst_CNSTI *)_x_; }
 223    inline friend Inst_CNSTP * _CNSTP(Inst _x_) { return (Inst_CNSTP *)_x_; }
 224    inline friend Inst_CNSTS * _CNSTS(Inst _x_) { return (Inst_CNSTS *)_x_; }
 225    inline friend Inst_CNSTU * _CNSTU(Inst _x_) { return (Inst_CNSTU *)_x_; }
 226    inline friend Inst_CVCI * _CVCI(Inst _x_) { return (Inst_CVCI *)_x_; }
 227    inline friend Inst_CVCU * _CVCU(Inst _x_) { return (Inst_CVCU *)_x_; }
 228    inline friend Inst_CVDF * _CVDF(Inst _x_) { return (Inst_CVDF *)_x_; }
 229    inline friend Inst_CVDI * _CVDI(Inst _x_) { return (Inst_CVDI *)_x_; }
 230    inline friend Inst_CVFD * _CVFD(Inst _x_) { return (Inst_CVFD *)_x_; }
 231    inline friend Inst_CVIC * _CVIC(Inst _x_) { return (Inst_CVIC *)_x_; }
 232    inline friend Inst_CVID * _CVID(Inst _x_) { return (Inst_CVID *)_x_; }
 233    inline friend Inst_CVIS * _CVIS(Inst _x_) { return (Inst_CVIS *)_x_; }
 234    inline friend Inst_CVIU * _CVIU(Inst _x_) { return (Inst_CVIU *)_x_; }
 235    inline friend Inst_CVPU * _CVPU(Inst _x_) { return (Inst_CVPU *)_x_; }
 236    inline friend Inst_CVSI * _CVSI(Inst _x_) { return (Inst_CVSI *)_x_; }
 237    inline friend Inst_CVSU * _CVSU(Inst _x_) { return (Inst_CVSU *)_x_; }
 238    inline friend Inst_CVUC * _CVUC(Inst _x_) { return (Inst_CVUC *)_x_; }
 239    inline friend Inst_CVUI * _CVUI(Inst _x_) { return (Inst_CVUI *)_x_; }
 240    inline friend Inst_CVUP * _CVUP(Inst _x_) { return (Inst_CVUP *)_x_; }
 241    inline friend Inst_CVUS * _CVUS(Inst _x_) { return (Inst_CVUS *)_x_; }
 242    inline friend Inst_DIVD * _DIVD(Inst _x_) { return (Inst_DIVD *)_x_; }
 243    inline friend Inst_DIVF * _DIVF(Inst _x_) { return (Inst_DIVF *)_x_; }
 244    inline friend Inst_DIVI * _DIVI(Inst _x_) { return (Inst_DIVI *)_x_; }
 245    inline friend Inst_DIVU * _DIVU(Inst _x_) { return (Inst_DIVU *)_x_; }
 246    inline friend Inst_EQD * _EQD(Inst _x_) { return (Inst_EQD *)_x_; }
 247    inline friend Inst_EQF * _EQF(Inst _x_) { return (Inst_EQF *)_x_; }
 248    inline friend Inst_EQI * _EQI(Inst _x_) { return (Inst_EQI *)_x_; }
 249    inline friend Inst_GED * _GED(Inst _x_) { return (Inst_GED *)_x_; }
 250    inline friend Inst_GEF * _GEF(Inst _x_) { return (Inst_GEF *)_x_; }
 251    inline friend Inst_GEI * _GEI(Inst _x_) { return (Inst_GEI *)_x_; }
 252    inline friend Inst_GEU * _GEU(Inst _x_) { return (Inst_GEU *)_x_; }
 253    inline friend Inst_GTD * _GTD(Inst _x_) { return (Inst_GTD *)_x_; }
 254    inline friend Inst_GTF * _GTF(Inst _x_) { return (Inst_GTF *)_x_; }
 255    inline friend Inst_GTI * _GTI(Inst _x_) { return (Inst_GTI *)_x_; }
 256    inline friend Inst_GTU * _GTU(Inst _x_) { return (Inst_GTU *)_x_; }
 257    inline friend Inst_INDIRB * _INDIRB(Inst _x_) { return (Inst_INDIRB *)_x_; }
 258    inline friend Inst_INDIRC * _INDIRC(Inst _x_) { return (Inst_INDIRC *)_x_; }
 259    inline friend Inst_INDIRD * _INDIRD(Inst _x_) { return (Inst_INDIRD *)_x_; }
 260    inline friend Inst_INDIRF * _INDIRF(Inst _x_) { return (Inst_INDIRF *)_x_; }
 261    inline friend Inst_INDIRI * _INDIRI(Inst _x_) { return (Inst_INDIRI *)_x_; }
 262    inline friend Inst_INDIRP * _INDIRP(Inst _x_) { return (Inst_INDIRP *)_x_; }
 263    inline friend Inst_INDIRS * _INDIRS(Inst _x_) { return (Inst_INDIRS *)_x_; }
 264    inline friend Inst_JUMPV * _JUMPV(Inst _x_) { return (Inst_JUMPV *)_x_; }
 265    inline friend Inst_LABELV * _LABELV(Inst _x_) { return (Inst_LABELV *)_x_; }
 266    inline friend Inst_LED * _LED(Inst _x_) { return (Inst_LED *)_x_; }
 267    inline friend Inst_LEF * _LEF(Inst _x_) { return (Inst_LEF *)_x_; }
 268    inline friend Inst_LEI * _LEI(Inst _x_) { return (Inst_LEI *)_x_; }
 269    inline friend Inst_LEU * _LEU(Inst _x_) { return (Inst_LEU *)_x_; }
 270    inline friend Inst_LOADB * _LOADB(Inst _x_) { return (Inst_LOADB *)_x_; }
 271    inline friend Inst_LOADC * _LOADC(Inst _x_) { return (Inst_LOADC *)_x_; }
 272    inline friend Inst_LOADD * _LOADD(Inst _x_) { return (Inst_LOADD *)_x_; }
 273    inline friend Inst_LOADF * _LOADF(Inst _x_) { return (Inst_LOADF *)_x_; }
 274    inline friend Inst_LOADI * _LOADI(Inst _x_) { return (Inst_LOADI *)_x_; }
 275    inline friend Inst_LOADP * _LOADP(Inst _x_) { return (Inst_LOADP *)_x_; }
 276    inline friend Inst_LOADS * _LOADS(Inst _x_) { return (Inst_LOADS *)_x_; }
 277    inline friend Inst_LOADU * _LOADU(Inst _x_) { return (Inst_LOADU *)_x_; }
 278    inline friend Inst_LSHI * _LSHI(Inst _x_) { return (Inst_LSHI *)_x_; }
 279    inline friend Inst_LSHU * _LSHU(Inst _x_) { return (Inst_LSHU *)_x_; }
 280    inline friend Inst_LTD * _LTD(Inst _x_) { return (Inst_LTD *)_x_; }
 281    inline friend Inst_LTF * _LTF(Inst _x_) { return (Inst_LTF *)_x_; }
 282    inline friend Inst_LTI * _LTI(Inst _x_) { return (Inst_LTI *)_x_; }
 283    inline friend Inst_LTU * _LTU(Inst _x_) { return (Inst_LTU *)_x_; }
 284    inline friend Inst_MODI * _MODI(Inst _x_) { return (Inst_MODI *)_x_; }
 285    inline friend Inst_MODU * _MODU(Inst _x_) { return (Inst_MODU *)_x_; }
 286    inline friend Inst_MULD * _MULD(Inst _x_) { return (Inst_MULD *)_x_; }
 287    inline friend Inst_MULF * _MULF(Inst _x_) { return (Inst_MULF *)_x_; }
 288    inline friend Inst_MULI * _MULI(Inst _x_) { return (Inst_MULI *)_x_; }
 289    inline friend Inst_MULU * _MULU(Inst _x_) { return (Inst_MULU *)_x_; }
 290    inline friend Inst_NED * _NED(Inst _x_) { return (Inst_NED *)_x_; }
 291    inline friend Inst_NEF * _NEF(Inst _x_) { return (Inst_NEF *)_x_; }
 292    inline friend Inst_NEI * _NEI(Inst _x_) { return (Inst_NEI *)_x_; }
 293    inline friend Inst_NEGD * _NEGD(Inst _x_) { return (Inst_NEGD *)_x_; }
 294    inline friend Inst_NEGF * _NEGF(Inst _x_) { return (Inst_NEGF *)_x_; }
 295    inline friend Inst_NEGI * _NEGI(Inst _x_) { return (Inst_NEGI *)_x_; }
 296    inline friend Inst_RETD * _RETD(Inst _x_) { return (Inst_RETD *)_x_; }
 297    inline friend Inst_RETF * _RETF(Inst _x_) { return (Inst_RETF *)_x_; }
 298    inline friend Inst_RETI * _RETI(Inst _x_) { return (Inst_RETI *)_x_; }
 299    inline friend Inst_RSHI * _RSHI(Inst _x_) { return (Inst_RSHI *)_x_; }
 300    inline friend Inst_RSHU * _RSHU(Inst _x_) { return (Inst_RSHU *)_x_; }
 301    inline friend Inst_SUBD * _SUBD(Inst _x_) { return (Inst_SUBD *)_x_; }
 302    inline friend Inst_SUBF * _SUBF(Inst _x_) { return (Inst_SUBF *)_x_; }
 303    inline friend Inst_SUBI * _SUBI(Inst _x_) { return (Inst_SUBI *)_x_; }
 304    inline friend Inst_SUBP * _SUBP(Inst _x_) { return (Inst_SUBP *)_x_; }
 305    inline friend Inst_SUBU * _SUBU(Inst _x_) { return (Inst_SUBU *)_x_; }
 306    inline friend Inst_VREGP * _VREGP(Inst _x_) { return (Inst_VREGP *)_x_; }
 307 };
 308
 309 ///////////////////////////////////////////////////////////////////////////////
 310 // class for constructor 'Inst::ADDD (Inst, Inst)'
 311 ///////////////////////////////////////////////////////////////////////////////
 312 class Inst_ADDD : public a_Inst {
 313 public:
 314 #line 1 "sparc.pC"
 315    Inst _1; Inst _2;
 316    inline Inst_ADDD (Inst _x1, Inst _x2)
 317       : a_Inst(a_Inst::tag_ADDD), _1(_x1), _2(_x2) {}
 318    inline friend a_Inst * ADDD (Inst _x1, Inst _x2)
 319       { return new Inst_ADDD (_x1, _x2); }
 320 };
 321
 322 ///////////////////////////////////////////////////////////////////////////////
 323 // class for constructor 'Inst::ADDF (Inst, Inst)'
 324 ///////////////////////////////////////////////////////////////////////////////
 325 class Inst_ADDF : public a_Inst {
 326 public:
 327 #line 2 "sparc.pC"
 328    Inst _1; Inst _2;
 329    inline Inst_ADDF (Inst _x1, Inst _x2)
 330       : a_Inst(a_Inst::tag_ADDF), _1(_x1), _2(_x2) {}
 331    inline friend a_Inst * ADDF (Inst _x1, Inst _x2)
 332       { return new Inst_ADDF (_x1, _x2); }
 333 };
 334
 335 ///////////////////////////////////////////////////////////////////////////////
 336 // class for constructor 'Inst::ADDI (Inst, Inst)'
 337 ///////////////////////////////////////////////////////////////////////////////
 338 class Inst_ADDI : public a_Inst {
 339 public:
 340 #line 2 "sparc.pC"
 341    Inst _1; Inst _2;
 342    inline Inst_ADDI (Inst _x1, Inst _x2)
 343       : a_Inst(a_Inst::tag_ADDI), _1(_x1), _2(_x2) {}
 344    inline friend a_Inst * ADDI (Inst _x1, Inst _x2)
 345       { return new Inst_ADDI (_x1, _x2); }
 346 };
 347
 348 ///////////////////////////////////////////////////////////////////////////////
 349 // class for constructor 'Inst::ADDP (Inst, Inst)'
 350 ///////////////////////////////////////////////////////////////////////////////
 351 class Inst_ADDP : public a_Inst {
 352 public:
 353 #line 3 "sparc.pC"
 354    Inst _1; Inst _2;
 355    inline Inst_ADDP (Inst _x1, Inst _x2)
 356       : a_Inst(a_Inst::tag_ADDP), _1(_x1), _2(_x2) {}
 357    inline friend a_Inst * ADDP (Inst _x1, Inst _x2)
 358       { return new Inst_ADDP (_x1, _x2); }
 359 };
 360
 361 ///////////////////////////////////////////////////////////////////////////////
 362 // class for constructor 'Inst::ADDU (Inst, Inst)'
 363 ///////////////////////////////////////////////////////////////////////////////
 364 class Inst_ADDU : public a_Inst {
 365 public:
 366 #line 3 "sparc.pC"
 367    Inst _1; Inst _2;
 368    inline Inst_ADDU (Inst _x1, Inst _x2)
 369       : a_Inst(a_Inst::tag_ADDU), _1(_x1), _2(_x2) {}
 370    inline friend a_Inst * ADDU (Inst _x1, Inst _x2)
 371       { return new Inst_ADDU (_x1, _x2); }
 372 };
 373
 374 ///////////////////////////////////////////////////////////////////////////////
 375 // class for constructor 'Inst::ADDRFP ()'
 376 ///////////////////////////////////////////////////////////////////////////////
 377 class Inst_ADDRFP : public a_Inst {
 378 public:
 379 #line 4 "sparc.pC"
 380
 381    inline Inst_ADDRFP ()
 382       : a_Inst(a_Inst::tag_ADDRFP) {}
 383    inline friend a_Inst * ADDRFP ()
 384       { return new Inst_ADDRFP ; }
 385 };
 386
 387 ///////////////////////////////////////////////////////////////////////////////
 388 // class for constructor 'Inst::ADDRGP ()'
 389 ///////////////////////////////////////////////////////////////////////////////
 390 class Inst_ADDRGP : public a_Inst {
 391 public:
 392 #line 4 "sparc.pC"
 393
 394    inline Inst_ADDRGP ()
 395       : a_Inst(a_Inst::tag_ADDRGP) {}
 396    inline friend a_Inst * ADDRGP ()
 397       { return new Inst_ADDRGP ; }
 398 };
 399
 400 ///////////////////////////////////////////////////////////////////////////////
 401 // class for constructor 'Inst::ADDRLP ()'
 402 ///////////////////////////////////////////////////////////////////////////////
 403 class Inst_ADDRLP : public a_Inst {
 404 public:
 405 #line 4 "sparc.pC"
 406
 407    inline Inst_ADDRLP ()
 408       : a_Inst(a_Inst::tag_ADDRLP) {}
 409    inline friend a_Inst * ADDRLP ()
 410       { return new Inst_ADDRLP ; }
 411 };
 412
 413 ///////////////////////////////////////////////////////////////////////////////
 414 // class for constructor 'Inst::ARGB Inst'
 415 ///////////////////////////////////////////////////////////////////////////////
 416 class Inst_ARGB : public a_Inst {
 417 public:
 418 #line 5 "sparc.pC"
 419    Inst ARGB;
 420    inline Inst_ARGB (Inst _xARGB)
 421       : a_Inst(a_Inst::tag_ARGB), ARGB(_xARGB) {}
 422    inline friend a_Inst * ARGB (Inst _xARGB)
 423       { return new Inst_ARGB (_xARGB); }
 424 };
 425
 426 ///////////////////////////////////////////////////////////////////////////////
 427 // class for constructor 'Inst::ARGD Inst'
 428 ///////////////////////////////////////////////////////////////////////////////
 429 class Inst_ARGD : public a_Inst {
 430 public:
 431 #line 5 "sparc.pC"
 432    Inst ARGD;
 433    inline Inst_ARGD (Inst _xARGD)
 434       : a_Inst(a_Inst::tag_ARGD), ARGD(_xARGD) {}
 435    inline friend a_Inst * ARGD (Inst _xARGD)
 436       { return new Inst_ARGD (_xARGD); }
 437 };
 438
 439 ///////////////////////////////////////////////////////////////////////////////
 440 // class for constructor 'Inst::ARGF Inst'
 441 ///////////////////////////////////////////////////////////////////////////////
 442 class Inst_ARGF : public a_Inst {
 443 public:
 444 #line 5 "sparc.pC"
 445    Inst ARGF;
 446    inline Inst_ARGF (Inst _xARGF)
 447       : a_Inst(a_Inst::tag_ARGF), ARGF(_xARGF) {}
 448    inline friend a_Inst * ARGF (Inst _xARGF)
 449       { return new Inst_ARGF (_xARGF); }
 450 };
 451
 452 ///////////////////////////////////////////////////////////////////////////////
 453 // class for constructor 'Inst::ARGI Inst'
 454 ///////////////////////////////////////////////////////////////////////////////
 455 class Inst_ARGI : public a_Inst {
 456 public:
 457 #line 5 "sparc.pC"
 458    Inst ARGI;
 459    inline Inst_ARGI (Inst _xARGI)
 460       : a_Inst(a_Inst::tag_ARGI), ARGI(_xARGI) {}
 461    inline friend a_Inst * ARGI (Inst _xARGI)
 462       { return new Inst_ARGI (_xARGI); }
 463 };
 464
 465 ///////////////////////////////////////////////////////////////////////////////
 466 // class for constructor 'Inst::ARGP Inst'
 467 ///////////////////////////////////////////////////////////////////////////////
 468 class Inst_ARGP : public a_Inst {
 469 public:
 470 #line 5 "sparc.pC"
 471    Inst ARGP;
 472    inline Inst_ARGP (Inst _xARGP)
 473       : a_Inst(a_Inst::tag_ARGP), ARGP(_xARGP) {}
 474    inline friend a_Inst * ARGP (Inst _xARGP)
 475       { return new Inst_ARGP (_xARGP); }
 476 };
 477
 478 ///////////////////////////////////////////////////////////////////////////////
 479 // class for constructor 'Inst::ASGNB (Inst, Inst)'
 480 ///////////////////////////////////////////////////////////////////////////////
 481 class Inst_ASGNB : public a_Inst {
 482 public:
 483 #line 6 "sparc.pC"
 484    Inst _1; Inst _2;
 485    inline Inst_ASGNB (Inst _x1, Inst _x2)
 486       : a_Inst(a_Inst::tag_ASGNB), _1(_x1), _2(_x2) {}
 487    inline friend a_Inst * ASGNB (Inst _x1, Inst _x2)
 488       { return new Inst_ASGNB (_x1, _x2); }
 489 };
 490
 491 ///////////////////////////////////////////////////////////////////////////////
 492 // class for constructor 'Inst::ASGNC (Inst, Inst)'
 493 ///////////////////////////////////////////////////////////////////////////////
 494 class Inst_ASGNC : public a_Inst {
 495 public:
 496 #line 6 "sparc.pC"
 497    Inst _1; Inst _2;
 498    inline Inst_ASGNC (Inst _x1, Inst _x2)
 499       : a_Inst(a_Inst::tag_ASGNC), _1(_x1), _2(_x2) {}
 500    inline friend a_Inst * ASGNC (Inst _x1, Inst _x2)
 501       { return new Inst_ASGNC (_x1, _x2); }
 502 };
 503
 504 ///////////////////////////////////////////////////////////////////////////////
 505 // class for constructor 'Inst::ASGND (Inst, Inst)'
 506 ///////////////////////////////////////////////////////////////////////////////
 507 class Inst_ASGND : public a_Inst {
 508 public:
 509 #line 6 "sparc.pC"
 510    Inst _1; Inst _2;
 511    inline Inst_ASGND (Inst _x1, Inst _x2)
 512       : a_Inst(a_Inst::tag_ASGND), _1(_x1), _2(_x2) {}
 513    inline friend a_Inst * ASGND (Inst _x1, Inst _x2)
 514       { return new Inst_ASGND (_x1, _x2); }
 515 };
 516
 517 ///////////////////////////////////////////////////////////////////////////////
 518 // class for constructor 'Inst::ASGNF (Inst, Inst)'
 519 ///////////////////////////////////////////////////////////////////////////////
 520 class Inst_ASGNF : public a_Inst {
 521 public:
 522 #line 7 "sparc.pC"
 523    Inst _1; Inst _2;
 524    inline Inst_ASGNF (Inst _x1, Inst _x2)
 525       : a_Inst(a_Inst::tag_ASGNF), _1(_x1), _2(_x2) {}
 526    inline friend a_Inst * ASGNF (Inst _x1, Inst _x2)
 527       { return new Inst_ASGNF (_x1, _x2); }
 528 };
 529
 530 ///////////////////////////////////////////////////////////////////////////////
 531 // class for constructor 'Inst::ASGNI (Inst, Inst)'
 532 ///////////////////////////////////////////////////////////////////////////////
 533 class Inst_ASGNI : public a_Inst {
 534 public:
 535 #line 7 "sparc.pC"
 536    Inst _1; Inst _2;
 537    inline Inst_ASGNI (Inst _x1, Inst _x2)
 538       : a_Inst(a_Inst::tag_ASGNI), _1(_x1), _2(_x2) {}
 539    inline friend a_Inst * ASGNI (Inst _x1, Inst _x2)
 540       { return new Inst_ASGNI (_x1, _x2); }
 541 };
 542
 543 ///////////////////////////////////////////////////////////////////////////////
 544 // class for constructor 'Inst::ASGNP (Inst, Inst)'
 545 ///////////////////////////////////////////////////////////////////////////////
 546 class Inst_ASGNP : public a_Inst {
 547 public:
 548 #line 7 "sparc.pC"
 549    Inst _1; Inst _2;
 550    inline Inst_ASGNP (Inst _x1, Inst _x2)
 551       : a_Inst(a_Inst::tag_ASGNP), _1(_x1), _2(_x2) {}
 552    inline friend a_Inst * ASGNP (Inst _x1, Inst _x2)
 553       { return new Inst_ASGNP (_x1, _x2); }
 554 };
 555
 556 ///////////////////////////////////////////////////////////////////////////////
 557 // class for constructor 'Inst::ASGNS (Inst, Inst)'
 558 ///////////////////////////////////////////////////////////////////////////////
 559 class Inst_ASGNS : public a_Inst {
 560 public:
 561 #line 7 "sparc.pC"
 562    Inst _1; Inst _2;
 563    inline Inst_ASGNS (Inst _x1, Inst _x2)
 564       : a_Inst(a_Inst::tag_ASGNS), _1(_x1), _2(_x2) {}
 565    inline friend a_Inst * ASGNS (Inst _x1, Inst _x2)
 566       { return new Inst_ASGNS (_x1, _x2); }
 567 };
 568
 569 ///////////////////////////////////////////////////////////////////////////////
 570 // class for constructor 'Inst::BANDU (Inst, Inst)'
 571 ///////////////////////////////////////////////////////////////////////////////
 572 class Inst_BANDU : public a_Inst {
 573 public:
 574 #line 8 "sparc.pC"
 575    Inst _1; Inst _2;
 576    inline Inst_BANDU (Inst _x1, Inst _x2)
 577       : a_Inst(a_Inst::tag_BANDU), _1(_x1), _2(_x2) {}
 578    inline friend a_Inst * BANDU (Inst _x1, Inst _x2)
 579       { return new Inst_BANDU (_x1, _x2); }
 580 };
 581
 582 ///////////////////////////////////////////////////////////////////////////////
 583 // class for constructor 'Inst::BCOMU Inst'
 584 ///////////////////////////////////////////////////////////////////////////////
 585 class Inst_BCOMU : public a_Inst {
 586 public:
 587 #line 8 "sparc.pC"
 588    Inst BCOMU;
 589    inline Inst_BCOMU (Inst _xBCOMU)
 590       : a_Inst(a_Inst::tag_BCOMU), BCOMU(_xBCOMU) {}
 591    inline friend a_Inst * BCOMU (Inst _xBCOMU)
 592       { return new Inst_BCOMU (_xBCOMU); }
 593 };
 594
 595 ///////////////////////////////////////////////////////////////////////////////
 596 // class for constructor 'Inst::BORU (Inst, Inst)'
 597 ///////////////////////////////////////////////////////////////////////////////
 598 class Inst_BORU : public a_Inst {
 599 public:
 600 #line 8 "sparc.pC"
 601    Inst _1; Inst _2;
 602    inline Inst_BORU (Inst _x1, Inst _x2)
 603       : a_Inst(a_Inst::tag_BORU), _1(_x1), _2(_x2) {}
 604    inline friend a_Inst * BORU (Inst _x1, Inst _x2)
 605       { return new Inst_BORU (_x1, _x2); }
 606 };
 607
 608 ///////////////////////////////////////////////////////////////////////////////
 609 // class for constructor 'Inst::BXORU (Inst, Inst)'
 610 ///////////////////////////////////////////////////////////////////////////////
 611 class Inst_BXORU : public a_Inst {
 612 public:
 613 #line 8 "sparc.pC"
 614    Inst _1; Inst _2;
 615    inline Inst_BXORU (Inst _x1, Inst _x2)
 616       : a_Inst(a_Inst::tag_BXORU), _1(_x1), _2(_x2) {}
 617    inline friend a_Inst * BXORU (Inst _x1, Inst _x2)
 618       { return new Inst_BXORU (_x1, _x2); }
 619 };
 620
 621 ///////////////////////////////////////////////////////////////////////////////
 622 // class for constructor 'Inst::CALLB (Inst, Inst)'
 623 ///////////////////////////////////////////////////////////////////////////////
 624 class Inst_CALLB : public a_Inst {
 625 public:
 626 #line 9 "sparc.pC"
 627    Inst _1; Inst _2;
 628    inline Inst_CALLB (Inst _x1, Inst _x2)
 629       : a_Inst(a_Inst::tag_CALLB), _1(_x1), _2(_x2) {}
 630    inline friend a_Inst * CALLB (Inst _x1, Inst _x2)
 631       { return new Inst_CALLB (_x1, _x2); }
 632 };
 633
 634 ///////////////////////////////////////////////////////////////////////////////
 635 // class for constructor 'Inst::CALLD Inst'
 636 ///////////////////////////////////////////////////////////////////////////////
 637 class Inst_CALLD : public a_Inst {
 638 public:
 639 #line 9 "sparc.pC"
 640    Inst CALLD;
 641    inline Inst_CALLD (Inst _xCALLD)
 642       : a_Inst(a_Inst::tag_CALLD), CALLD(_xCALLD) {}
 643    inline friend a_Inst * CALLD (Inst _xCALLD)
 644       { return new Inst_CALLD (_xCALLD); }
 645 };
 646
 647 ///////////////////////////////////////////////////////////////////////////////
 648 // class for constructor 'Inst::CALLF Inst'
 649 ///////////////////////////////////////////////////////////////////////////////
 650 class Inst_CALLF : public a_Inst {
 651 public:
 652 #line 9 "sparc.pC"
 653    Inst CALLF;
 654    inline Inst_CALLF (Inst _xCALLF)
 655       : a_Inst(a_Inst::tag_CALLF), CALLF(_xCALLF) {}
 656    inline friend a_Inst * CALLF (Inst _xCALLF)
 657       { return new Inst_CALLF (_xCALLF); }
 658 };
 659
 660 ///////////////////////////////////////////////////////////////////////////////
 661 // class for constructor 'Inst::CALLI Inst'
 662 ///////////////////////////////////////////////////////////////////////////////
 663 class Inst_CALLI : public a_Inst {
 664 public:
 665 #line 9 "sparc.pC"
 666    Inst CALLI;
 667    inline Inst_CALLI (Inst _xCALLI)
 668       : a_Inst(a_Inst::tag_CALLI), CALLI(_xCALLI) {}
 669    inline friend a_Inst * CALLI (Inst _xCALLI)
 670       { return new Inst_CALLI (_xCALLI); }
 671 };
 672
 673 ///////////////////////////////////////////////////////////////////////////////
 674 // class for constructor 'Inst::CALLV Inst'
 675 ///////////////////////////////////////////////////////////////////////////////
 676 class Inst_CALLV : public a_Inst {
 677 public:
 678 #line 9 "sparc.pC"
 679    Inst CALLV;
 680    inline Inst_CALLV (Inst _xCALLV)
 681       : a_Inst(a_Inst::tag_CALLV), CALLV(_xCALLV) {}
 682    inline friend a_Inst * CALLV (Inst _xCALLV)
 683       { return new Inst_CALLV (_xCALLV); }
 684 };
 685
 686 ///////////////////////////////////////////////////////////////////////////////
 687 // class for constructor 'Inst::CNSTC ()'
 688 ///////////////////////////////////////////////////////////////////////////////
 689 class Inst_CNSTC : public a_Inst {
 690 public:
 691 #line 10 "sparc.pC"
 692
 693    inline Inst_CNSTC ()
 694       : a_Inst(a_Inst::tag_CNSTC) {}
 695    inline friend a_Inst * CNSTC ()
 696       { return new Inst_CNSTC ; }
 697 };
 698
 699 ///////////////////////////////////////////////////////////////////////////////
 700 // class for constructor 'Inst::CNSTD ()'
 701 ///////////////////////////////////////////////////////////////////////////////
 702 class Inst_CNSTD : public a_Inst {
 703 public:
 704 #line 10 "sparc.pC"
 705
 706    inline Inst_CNSTD ()
 707       : a_Inst(a_Inst::tag_CNSTD) {}
 708    inline friend a_Inst * CNSTD ()
 709       { return new Inst_CNSTD ; }
 710 };
 711
 712 ///////////////////////////////////////////////////////////////////////////////
 713 // class for constructor 'Inst::CNSTF ()'
 714 ///////////////////////////////////////////////////////////////////////////////
 715 class Inst_CNSTF : public a_Inst {
 716 public:
 717 #line 10 "sparc.pC"
 718
 719    inline Inst_CNSTF ()
 720       : a_Inst(a_Inst::tag_CNSTF) {}
 721    inline friend a_Inst * CNSTF ()
 722       { return new Inst_CNSTF ; }
 723 };
 724
 725 ///////////////////////////////////////////////////////////////////////////////
 726 // class for constructor 'Inst::CNSTI ()'
 727 ///////////////////////////////////////////////////////////////////////////////
 728 class Inst_CNSTI : public a_Inst {
 729 public:
 730 #line 10 "sparc.pC"
 731
 732    inline Inst_CNSTI ()
 733       : a_Inst(a_Inst::tag_CNSTI) {}
 734    inline friend a_Inst * CNSTI ()
 735       { return new Inst_CNSTI ; }
 736 };
 737
 738 ///////////////////////////////////////////////////////////////////////////////
 739 // class for constructor 'Inst::CNSTP ()'
 740 ///////////////////////////////////////////////////////////////////////////////
 741 class Inst_CNSTP : public a_Inst {
 742 public:
 743 #line 10 "sparc.pC"
 744
 745    inline Inst_CNSTP ()
 746       : a_Inst(a_Inst::tag_CNSTP) {}
 747    inline friend a_Inst * CNSTP ()
 748       { return new Inst_CNSTP ; }
 749 };
 750
 751 ///////////////////////////////////////////////////////////////////////////////
 752 // class for constructor 'Inst::CNSTS ()'
 753 ///////////////////////////////////////////////////////////////////////////////
 754 class Inst_CNSTS : public a_Inst {
 755 public:
 756 #line 10 "sparc.pC"
 757
 758    inline Inst_CNSTS ()
 759       : a_Inst(a_Inst::tag_CNSTS) {}
 760    inline friend a_Inst * CNSTS ()
 761       { return new Inst_CNSTS ; }
 762 };
 763
 764 ///////////////////////////////////////////////////////////////////////////////
 765 // class for constructor 'Inst::CNSTU ()'
 766 ///////////////////////////////////////////////////////////////////////////////
 767 class Inst_CNSTU : public a_Inst {
 768 public:
 769 #line 10 "sparc.pC"
 770
 771    inline Inst_CNSTU ()
 772       : a_Inst(a_Inst::tag_CNSTU) {}
 773    inline friend a_Inst * CNSTU ()
 774       { return new Inst_CNSTU ; }
 775 };
 776
 777 ///////////////////////////////////////////////////////////////////////////////
 778 // class for constructor 'Inst::CVCI Inst'
 779 ///////////////////////////////////////////////////////////////////////////////
 780 class Inst_CVCI : public a_Inst {
 781 public:
 782 #line 11 "sparc.pC"
 783    Inst CVCI;
 784    inline Inst_CVCI (Inst _xCVCI)
 785       : a_Inst(a_Inst::tag_CVCI), CVCI(_xCVCI) {}
 786    inline friend a_Inst * CVCI (Inst _xCVCI)
 787       { return new Inst_CVCI (_xCVCI); }
 788 };
 789
 790 ///////////////////////////////////////////////////////////////////////////////
 791 // class for constructor 'Inst::CVCU Inst'
 792 ///////////////////////////////////////////////////////////////////////////////
 793 class Inst_CVCU : public a_Inst {
 794 public:
 795 #line 11 "sparc.pC"
 796    Inst CVCU;
 797    inline Inst_CVCU (Inst _xCVCU)
 798       : a_Inst(a_Inst::tag_CVCU), CVCU(_xCVCU) {}
 799    inline friend a_Inst * CVCU (Inst _xCVCU)
 800       { return new Inst_CVCU (_xCVCU); }
 801 };
 802
 803 ///////////////////////////////////////////////////////////////////////////////
 804 // class for constructor 'Inst::CVDF Inst'
 805 ///////////////////////////////////////////////////////////////////////////////
 806 class Inst_CVDF : public a_Inst {
 807 public:
 808 #line 11 "sparc.pC"
 809    Inst CVDF;
 810    inline Inst_CVDF (Inst _xCVDF)
 811       : a_Inst(a_Inst::tag_CVDF), CVDF(_xCVDF) {}
 812    inline friend a_Inst * CVDF (Inst _xCVDF)
 813       { return new Inst_CVDF (_xCVDF); }
 814 };
 815
 816 ///////////////////////////////////////////////////////////////////////////////
 817 // class for constructor 'Inst::CVDI Inst'
 818 ///////////////////////////////////////////////////////////////////////////////
 819 class Inst_CVDI : public a_Inst {
 820 public:
 821 #line 11 "sparc.pC"
 822    Inst CVDI;
 823    inline Inst_CVDI (Inst _xCVDI)
 824       : a_Inst(a_Inst::tag_CVDI), CVDI(_xCVDI) {}
 825    inline friend a_Inst * CVDI (Inst _xCVDI)
 826       { return new Inst_CVDI (_xCVDI); }
 827 };
 828
 829 ///////////////////////////////////////////////////////////////////////////////
 830 // class for constructor 'Inst::CVFD Inst'
 831 ///////////////////////////////////////////////////////////////////////////////
 832 class Inst_CVFD : public a_Inst {
 833 public:
 834 #line 11 "sparc.pC"
 835    Inst CVFD;
 836    inline Inst_CVFD (Inst _xCVFD)
 837       : a_Inst(a_Inst::tag_CVFD), CVFD(_xCVFD) {}
 838    inline friend a_Inst * CVFD (Inst _xCVFD)
 839       { return new Inst_CVFD (_xCVFD); }
 840 };
 841
 842 ///////////////////////////////////////////////////////////////////////////////
 843 // class for constructor 'Inst::CVIC Inst'
 844 ///////////////////////////////////////////////////////////////////////////////
 845 class Inst_CVIC : public a_Inst {
 846 public:
 847 #line 12 "sparc.pC"
 848    Inst CVIC;
 849    inline Inst_CVIC (Inst _xCVIC)
 850       : a_Inst(a_Inst::tag_CVIC), CVIC(_xCVIC) {}
 851    inline friend a_Inst * CVIC (Inst _xCVIC)
 852       { return new Inst_CVIC (_xCVIC); }
 853 };
 854
 855 ///////////////////////////////////////////////////////////////////////////////
 856 // class for constructor 'Inst::CVID Inst'
 857 ///////////////////////////////////////////////////////////////////////////////
 858 class Inst_CVID : public a_Inst {
 859 public:
 860 #line 12 "sparc.pC"
 861    Inst CVID;
 862    inline Inst_CVID (Inst _xCVID)
 863       : a_Inst(a_Inst::tag_CVID), CVID(_xCVID) {}
 864    inline friend a_Inst * CVID (Inst _xCVID)
 865       { return new Inst_CVID (_xCVID); }
 866 };
 867
 868 ///////////////////////////////////////////////////////////////////////////////
 869 // class for constructor 'Inst::CVIS Inst'
 870 ///////////////////////////////////////////////////////////////////////////////
 871 class Inst_CVIS : public a_Inst {
 872 public:
 873 #line 12 "sparc.pC"
 874    Inst CVIS;
 875    inline Inst_CVIS (Inst _xCVIS)
 876       : a_Inst(a_Inst::tag_CVIS), CVIS(_xCVIS) {}
 877    inline friend a_Inst * CVIS (Inst _xCVIS)
 878       { return new Inst_CVIS (_xCVIS); }
 879 };
 880
 881 ///////////////////////////////////////////////////////////////////////////////
 882 // class for constructor 'Inst::CVIU Inst'
 883 ///////////////////////////////////////////////////////////////////////////////
 884 class Inst_CVIU : public a_Inst {
 885 public:
 886 #line 12 "sparc.pC"
 887    Inst CVIU;
 888    inline Inst_CVIU (Inst _xCVIU)
 889       : a_Inst(a_Inst::tag_CVIU), CVIU(_xCVIU) {}
 890    inline friend a_Inst * CVIU (Inst _xCVIU)
 891       { return new Inst_CVIU (_xCVIU); }
 892 };
 893
 894 ///////////////////////////////////////////////////////////////////////////////
 895 // class for constructor 'Inst::CVPU Inst'
 896 ///////////////////////////////////////////////////////////////////////////////
 897 class Inst_CVPU : public a_Inst {
 898 public:
 899 #line 12 "sparc.pC"
 900    Inst CVPU;
 901    inline Inst_CVPU (Inst _xCVPU)
 902       : a_Inst(a_Inst::tag_CVPU), CVPU(_xCVPU) {}
 903    inline friend a_Inst * CVPU (Inst _xCVPU)
 904       { return new Inst_CVPU (_xCVPU); }
 905 };
 906
 907 ///////////////////////////////////////////////////////////////////////////////
 908 // class for constructor 'Inst::CVSI Inst'
 909 ///////////////////////////////////////////////////////////////////////////////
 910 class Inst_CVSI : public a_Inst {
 911 public:
 912 #line 13 "sparc.pC"
 913    Inst CVSI;
 914    inline Inst_CVSI (Inst _xCVSI)
 915       : a_Inst(a_Inst::tag_CVSI), CVSI(_xCVSI) {}
 916    inline friend a_Inst * CVSI (Inst _xCVSI)
 917       { return new Inst_CVSI (_xCVSI); }
 918 };
 919
 920 ///////////////////////////////////////////////////////////////////////////////
 921 // class for constructor 'Inst::CVSU Inst'
 922 ///////////////////////////////////////////////////////////////////////////////
 923 class Inst_CVSU : public a_Inst {
 924 public:
 925 #line 13 "sparc.pC"
 926    Inst CVSU;
 927    inline Inst_CVSU (Inst _xCVSU)
 928       : a_Inst(a_Inst::tag_CVSU), CVSU(_xCVSU) {}
 929    inline friend a_Inst * CVSU (Inst _xCVSU)
 930       { return new Inst_CVSU (_xCVSU); }
 931 };
 932
 933 ///////////////////////////////////////////////////////////////////////////////
 934 // class for constructor 'Inst::CVUC Inst'
 935 ///////////////////////////////////////////////////////////////////////////////
 936 class Inst_CVUC : public a_Inst {
 937 public:
 938 #line 14 "sparc.pC"
 939    Inst CVUC;
 940    inline Inst_CVUC (Inst _xCVUC)
 941       : a_Inst(a_Inst::tag_CVUC), CVUC(_xCVUC) {}
 942    inline friend a_Inst * CVUC (Inst _xCVUC)
 943       { return new Inst_CVUC (_xCVUC); }
 944 };
 945
 946 ///////////////////////////////////////////////////////////////////////////////
 947 // class for constructor 'Inst::CVUI Inst'
 948 ///////////////////////////////////////////////////////////////////////////////
 949 class Inst_CVUI : public a_Inst {
 950 public:
 951 #line 14 "sparc.pC"
 952    Inst CVUI;
 953    inline Inst_CVUI (Inst _xCVUI)
 954       : a_Inst(a_Inst::tag_CVUI), CVUI(_xCVUI) {}
 955    inline friend a_Inst * CVUI (Inst _xCVUI)
 956       { return new Inst_CVUI (_xCVUI); }
 957 };
 958
 959 ///////////////////////////////////////////////////////////////////////////////
 960 // class for constructor 'Inst::CVUP Inst'
 961 ///////////////////////////////////////////////////////////////////////////////
 962 class Inst_CVUP : public a_Inst {
 963 public:
 964 #line 14 "sparc.pC"
 965    Inst CVUP;
 966    inline Inst_CVUP (Inst _xCVUP)
 967       : a_Inst(a_Inst::tag_CVUP), CVUP(_xCVUP) {}
 968    inline friend a_Inst * CVUP (Inst _xCVUP)
 969       { return new Inst_CVUP (_xCVUP); }
 970 };
 971
 972 ///////////////////////////////////////////////////////////////////////////////
 973 // class for constructor 'Inst::CVUS Inst'
 974 ///////////////////////////////////////////////////////////////////////////////
 975 class Inst_CVUS : public a_Inst {
 976 public:
 977 #line 14 "sparc.pC"
 978    Inst CVUS;
 979    inline Inst_CVUS (Inst _xCVUS)
 980       : a_Inst(a_Inst::tag_CVUS), CVUS(_xCVUS) {}
 981    inline friend a_Inst * CVUS (Inst _xCVUS)
 982       { return new Inst_CVUS (_xCVUS); }
 983 };
 984
 985 ///////////////////////////////////////////////////////////////////////////////
 986 // class for constructor 'Inst::DIVD (Inst, Inst)'
 987 ///////////////////////////////////////////////////////////////////////////////
 988 class Inst_DIVD : public a_Inst {
 989 public:
 990 #line 15 "sparc.pC"
 991    Inst _1; Inst _2;
 992    inline Inst_DIVD (Inst _x1, Inst _x2)
 993       : a_Inst(a_Inst::tag_DIVD), _1(_x1), _2(_x2) {}
 994    inline friend a_Inst * DIVD (Inst _x1, Inst _x2)
 995       { return new Inst_DIVD (_x1, _x2); }
 996 };
 997
 998 ///////////////////////////////////////////////////////////////////////////////
 999 // class for constructor 'Inst::DIVF (Inst, Inst)'
1000 ///////////////////////////////////////////////////////////////////////////////
1001 class Inst_DIVF : public a_Inst {
1002 public:
1003 #line 15 "sparc.pC"
1004    Inst _1; Inst _2;
1005    inline Inst_DIVF (Inst _x1, Inst _x2)
1006       : a_Inst(a_Inst::tag_DIVF), _1(_x1), _2(_x2) {}
1007    inline friend a_Inst * DIVF (Inst _x1, Inst _x2)
1008       { return new Inst_DIVF (_x1, _x2); }
1009 };
1010
1011 ///////////////////////////////////////////////////////////////////////////////
1012 // class for constructor 'Inst::DIVI (Inst, Inst)'
1013 ///////////////////////////////////////////////////////////////////////////////
1014 class Inst_DIVI : public a_Inst {
1015 public:
1016 #line 15 "sparc.pC"
1017    Inst _1; Inst _2;
1018    inline Inst_DIVI (Inst _x1, Inst _x2)
1019       : a_Inst(a_Inst::tag_DIVI), _1(_x1), _2(_x2) {}
1020    inline friend a_Inst * DIVI (Inst _x1, Inst _x2)
1021       { return new Inst_DIVI (_x1, _x2); }
1022 };
1023
1024 ///////////////////////////////////////////////////////////////////////////////
1025 // class for constructor 'Inst::DIVU (Inst, Inst)'
1026 ///////////////////////////////////////////////////////////////////////////////
1027 class Inst_DIVU : public a_Inst {
1028 public:
1029 #line 15 "sparc.pC"
1030    Inst _1; Inst _2;
1031    inline Inst_DIVU (Inst _x1, Inst _x2)
1032       : a_Inst(a_Inst::tag_DIVU), _1(_x1), _2(_x2) {}
1033    inline friend a_Inst * DIVU (Inst _x1, Inst _x2)
1034       { return new Inst_DIVU (_x1, _x2); }
1035 };
1036
1037 ///////////////////////////////////////////////////////////////////////////////
1038 // class for constructor 'Inst::EQD (Inst, Inst)'
1039 ///////////////////////////////////////////////////////////////////////////////
1040 class Inst_EQD : public a_Inst {
1041 public:
1042 #line 16 "sparc.pC"
1043    Inst _1; Inst _2;
1044    inline Inst_EQD (Inst _x1, Inst _x2)
1045       : a_Inst(a_Inst::tag_EQD), _1(_x1), _2(_x2) {}
1046    inline friend a_Inst * EQD (Inst _x1, Inst _x2)
1047       { return new Inst_EQD (_x1, _x2); }
1048 };
1049
1050 ///////////////////////////////////////////////////////////////////////////////
1051 // class for constructor 'Inst::EQF (Inst, Inst)'
1052 ///////////////////////////////////////////////////////////////////////////////
1053 class Inst_EQF : public a_Inst {
1054 public:
1055 #line 16 "sparc.pC"
1056    Inst _1; Inst _2;
1057    inline Inst_EQF (Inst _x1, Inst _x2)
1058       : a_Inst(a_Inst::tag_EQF), _1(_x1), _2(_x2) {}
1059    inline friend a_Inst * EQF (Inst _x1, Inst _x2)
1060       { return new Inst_EQF (_x1, _x2); }
1061 };
1062
1063 ///////////////////////////////////////////////////////////////////////////////
1064 // class for constructor 'Inst::EQI (Inst, Inst)'
1065 ///////////////////////////////////////////////////////////////////////////////
1066 class Inst_EQI : public a_Inst {
1067 public:
1068 #line 16 "sparc.pC"
1069    Inst _1; Inst _2;
1070    inline Inst_EQI (Inst _x1, Inst _x2)
1071       : a_Inst(a_Inst::tag_EQI), _1(_x1), _2(_x2) {}
1072    inline friend a_Inst * EQI (Inst _x1, Inst _x2)
1073       { return new Inst_EQI (_x1, _x2); }
1074 };
1075
1076 ///////////////////////////////////////////////////////////////////////////////
1077 // class for constructor 'Inst::GED (Inst, Inst)'
1078 ///////////////////////////////////////////////////////////////////////////////
1079 class Inst_GED : public a_Inst {
1080 public:
1081 #line 17 "sparc.pC"
1082    Inst _1; Inst _2;
1083    inline Inst_GED (Inst _x1, Inst _x2)
1084       : a_Inst(a_Inst::tag_GED), _1(_x1), _2(_x2) {}
1085    inline friend a_Inst * GED (Inst _x1, Inst _x2)
1086       { return new Inst_GED (_x1, _x2); }
1087 };
1088
1089 ///////////////////////////////////////////////////////////////////////////////
1090 // class for constructor 'Inst::GEF (Inst, Inst)'
1091 ///////////////////////////////////////////////////////////////////////////////
1092 class Inst_GEF : public a_Inst {
1093 public:
1094 #line 17 "sparc.pC"
1095    Inst _1; Inst _2;
1096    inline Inst_GEF (Inst _x1, Inst _x2)
1097       : a_Inst(a_Inst::tag_GEF), _1(_x1), _2(_x2) {}
1098    inline friend a_Inst * GEF (Inst _x1, Inst _x2)
1099       { return new Inst_GEF (_x1, _x2); }
1100 };
1101
1102 ///////////////////////////////////////////////////////////////////////////////
1103 // class for constructor 'Inst::GEI (Inst, Inst)'
1104 ///////////////////////////////////////////////////////////////////////////////
1105 class Inst_GEI : public a_Inst {
1106 public:
1107 #line 17 "sparc.pC"
1108    Inst _1; Inst _2;
1109    inline Inst_GEI (Inst _x1, Inst _x2)
1110       : a_Inst(a_Inst::tag_GEI), _1(_x1), _2(_x2) {}
1111    inline friend a_Inst * GEI (Inst _x1, Inst _x2)
1112       { return new Inst_GEI (_x1, _x2); }
1113 };
1114
1115 ///////////////////////////////////////////////////////////////////////////////
1116 // class for constructor 'Inst::GEU (Inst, Inst)'
1117 ///////////////////////////////////////////////////////////////////////////////
1118 class Inst_GEU : public a_Inst {
1119 public:
1120 #line 17 "sparc.pC"
1121    Inst _1; Inst _2;
1122    inline Inst_GEU (Inst _x1, Inst _x2)
1123       : a_Inst(a_Inst::tag_GEU), _1(_x1), _2(_x2) {}
1124    inline friend a_Inst * GEU (Inst _x1, Inst _x2)
1125       { return new Inst_GEU (_x1, _x2); }
1126 };
1127
1128 ///////////////////////////////////////////////////////////////////////////////
1129 // class for constructor 'Inst::GTD (Inst, Inst)'
1130 ///////////////////////////////////////////////////////////////////////////////
1131 class Inst_GTD : public a_Inst {
1132 public:
1133 #line 18 "sparc.pC"
1134    Inst _1; Inst _2;
1135    inline Inst_GTD (Inst _x1, Inst _x2)
1136       : a_Inst(a_Inst::tag_GTD), _1(_x1), _2(_x2) {}
1137    inline friend a_Inst * GTD (Inst _x1, Inst _x2)
1138       { return new Inst_GTD (_x1, _x2); }
1139 };
1140
1141 ///////////////////////////////////////////////////////////////////////////////
1142 // class for constructor 'Inst::GTF (Inst, Inst)'
1143 ///////////////////////////////////////////////////////////////////////////////
1144 class Inst_GTF : public a_Inst {
1145 public:
1146 #line 18 "sparc.pC"
1147    Inst _1; Inst _2;
1148    inline Inst_GTF (Inst _x1, Inst _x2)
1149       : a_Inst(a_Inst::tag_GTF), _1(_x1), _2(_x2) {}
1150    inline friend a_Inst * GTF (Inst _x1, Inst _x2)
1151       { return new Inst_GTF (_x1, _x2); }
1152 };
1153
1154 ///////////////////////////////////////////////////////////////////////////////
1155 // class for constructor 'Inst::GTI (Inst, Inst)'
1156 ///////////////////////////////////////////////////////////////////////////////
1157 class Inst_GTI : public a_Inst {
1158 public:
1159 #line 18 "sparc.pC"
1160    Inst _1; Inst _2;
1161    inline Inst_GTI (Inst _x1, Inst _x2)
1162       : a_Inst(a_Inst::tag_GTI), _1(_x1), _2(_x2) {}
1163    inline friend a_Inst * GTI (Inst _x1, Inst _x2)
1164       { return new Inst_GTI (_x1, _x2); }
1165 };
1166
1167 ///////////////////////////////////////////////////////////////////////////////
1168 // class for constructor 'Inst::GTU (Inst, Inst)'
1169 ///////////////////////////////////////////////////////////////////////////////
1170 class Inst_GTU : public a_Inst {
1171 public:
1172 #line 18 "sparc.pC"
1173    Inst _1; Inst _2;
1174    inline Inst_GTU (Inst _x1, Inst _x2)
1175       : a_Inst(a_Inst::tag_GTU), _1(_x1), _2(_x2) {}
1176    inline friend a_Inst * GTU (Inst _x1, Inst _x2)
1177       { return new Inst_GTU (_x1, _x2); }
1178 };
1179
1180 ///////////////////////////////////////////////////////////////////////////////
1181 // class for constructor 'Inst::INDIRB Inst'
1182 ///////////////////////////////////////////////////////////////////////////////
1183 class Inst_INDIRB : public a_Inst {
1184 public:
1185 #line 19 "sparc.pC"
1186    Inst INDIRB;
1187    inline Inst_INDIRB (Inst _xINDIRB)
1188       : a_Inst(a_Inst::tag_INDIRB), INDIRB(_xINDIRB) {}
1189    inline friend a_Inst * INDIRB (Inst _xINDIRB)
1190       { return new Inst_INDIRB (_xINDIRB); }
1191 };
1192
1193 ///////////////////////////////////////////////////////////////////////////////
1194 // class for constructor 'Inst::INDIRC Inst'
1195 ///////////////////////////////////////////////////////////////////////////////
1196 class Inst_INDIRC : public a_Inst {
1197 public:
1198 #line 19 "sparc.pC"
1199    Inst INDIRC;
1200    inline Inst_INDIRC (Inst _xINDIRC)
1201       : a_Inst(a_Inst::tag_INDIRC), INDIRC(_xINDIRC) {}
1202    inline friend a_Inst * INDIRC (Inst _xINDIRC)
1203       { return new Inst_INDIRC (_xINDIRC); }
1204 };
1205
1206 ///////////////////////////////////////////////////////////////////////////////
1207 // class for constructor 'Inst::INDIRD Inst'
1208 ///////////////////////////////////////////////////////////////////////////////
1209 class Inst_INDIRD : public a_Inst {
1210 public:
1211 #line 19 "sparc.pC"
1212    Inst INDIRD;
1213    inline Inst_INDIRD (Inst _xINDIRD)
1214       : a_Inst(a_Inst::tag_INDIRD), INDIRD(_xINDIRD) {}
1215    inline friend a_Inst * INDIRD (Inst _xINDIRD)
1216       { return new Inst_INDIRD (_xINDIRD); }
1217 };
1218
1219 ///////////////////////////////////////////////////////////////////////////////
1220 // class for constructor 'Inst::INDIRF Inst'
1221 ///////////////////////////////////////////////////////////////////////////////
1222 class Inst_INDIRF : public a_Inst {
1223 public:
1224 #line 19 "sparc.pC"
1225    Inst INDIRF;
1226    inline Inst_INDIRF (Inst _xINDIRF)
1227       : a_Inst(a_Inst::tag_INDIRF), INDIRF(_xINDIRF) {}
1228    inline friend a_Inst * INDIRF (Inst _xINDIRF)
1229       { return new Inst_INDIRF (_xINDIRF); }
1230 };
1231
1232 ///////////////////////////////////////////////////////////////////////////////
1233 // class for constructor 'Inst::INDIRI Inst'
1234 ///////////////////////////////////////////////////////////////////////////////
1235 class Inst_INDIRI : public a_Inst {
1236 public:
1237 #line 20 "sparc.pC"
1238    Inst INDIRI;
1239    inline Inst_INDIRI (Inst _xINDIRI)
1240       : a_Inst(a_Inst::tag_INDIRI), INDIRI(_xINDIRI) {}
1241    inline friend a_Inst * INDIRI (Inst _xINDIRI)
1242       { return new Inst_INDIRI (_xINDIRI); }
1243 };
1244
1245 ///////////////////////////////////////////////////////////////////////////////
1246 // class for constructor 'Inst::INDIRP Inst'
1247 ///////////////////////////////////////////////////////////////////////////////
1248 class Inst_INDIRP : public a_Inst {
1249 public:
1250 #line 20 "sparc.pC"
1251    Inst INDIRP;
1252    inline Inst_INDIRP (Inst _xINDIRP)
1253       : a_Inst(a_Inst::tag_INDIRP), INDIRP(_xINDIRP) {}
1254    inline friend a_Inst * INDIRP (Inst _xINDIRP)
1255       { return new Inst_INDIRP (_xINDIRP); }
1256 };
1257
1258 ///////////////////////////////////////////////////////////////////////////////
1259 // class for constructor 'Inst::INDIRS Inst'
1260 ///////////////////////////////////////////////////////////////////////////////
1261 class Inst_INDIRS : public a_Inst {
1262 public:
1263 #line 20 "sparc.pC"
1264    Inst INDIRS;
1265    inline Inst_INDIRS (Inst _xINDIRS)
1266       : a_Inst(a_Inst::tag_INDIRS), INDIRS(_xINDIRS) {}
1267    inline friend a_Inst * INDIRS (Inst _xINDIRS)
1268       { return new Inst_INDIRS (_xINDIRS); }
1269 };
1270
1271 ///////////////////////////////////////////////////////////////////////////////
1272 // class for constructor 'Inst::JUMPV Inst'
1273 ///////////////////////////////////////////////////////////////////////////////
1274 class Inst_JUMPV : public a_Inst {
1275 public:
1276 #line 21 "sparc.pC"
1277    Inst JUMPV;
1278    inline Inst_JUMPV (Inst _xJUMPV)
1279       : a_Inst(a_Inst::tag_JUMPV), JUMPV(_xJUMPV) {}
1280    inline friend a_Inst * JUMPV (Inst _xJUMPV)
1281       { return new Inst_JUMPV (_xJUMPV); }
1282 };
1283
1284 ///////////////////////////////////////////////////////////////////////////////
1285 // class for constructor 'Inst::LABELV ()'
1286 ///////////////////////////////////////////////////////////////////////////////
1287 class Inst_LABELV : public a_Inst {
1288 public:
1289 #line 21 "sparc.pC"
1290
1291    inline Inst_LABELV ()
1292       : a_Inst(a_Inst::tag_LABELV) {}
1293    inline friend a_Inst * LABELV ()
1294       { return new Inst_LABELV ; }
1295 };
1296
1297 ///////////////////////////////////////////////////////////////////////////////
1298 // class for constructor 'Inst::LED (Inst, Inst)'
1299 ///////////////////////////////////////////////////////////////////////////////
1300 class Inst_LED : public a_Inst {
1301 public:
1302 #line 22 "sparc.pC"
1303    Inst _1; Inst _2;
1304    inline Inst_LED (Inst _x1, Inst _x2)
1305       : a_Inst(a_Inst::tag_LED), _1(_x1), _2(_x2) {}
1306    inline friend a_Inst * LED (Inst _x1, Inst _x2)
1307       { return new Inst_LED (_x1, _x2); }
1308 };
1309
1310 ///////////////////////////////////////////////////////////////////////////////
1311 // class for constructor 'Inst::LEF (Inst, Inst)'
1312 ///////////////////////////////////////////////////////////////////////////////
1313 class Inst_LEF : public a_Inst {
1314 public:
1315 #line 22 "sparc.pC"
1316    Inst _1; Inst _2;
1317    inline Inst_LEF (Inst _x1, Inst _x2)
1318       : a_Inst(a_Inst::tag_LEF), _1(_x1), _2(_x2) {}
1319    inline friend a_Inst * LEF (Inst _x1, Inst _x2)
1320       { return new Inst_LEF (_x1, _x2); }
1321 };
1322
1323 ///////////////////////////////////////////////////////////////////////////////
1324 // class for constructor 'Inst::LEI (Inst, Inst)'
1325 ///////////////////////////////////////////////////////////////////////////////
1326 class Inst_LEI : public a_Inst {
1327 public:
1328 #line 22 "sparc.pC"
1329    Inst _1; Inst _2;
1330    inline Inst_LEI (Inst _x1, Inst _x2)
1331       : a_Inst(a_Inst::tag_LEI), _1(_x1), _2(_x2) {}
1332    inline friend a_Inst * LEI (Inst _x1, Inst _x2)
1333       { return new Inst_LEI (_x1, _x2); }
1334 };
1335
1336 ///////////////////////////////////////////////////////////////////////////////
1337 // class for constructor 'Inst::LEU (Inst, Inst)'
1338 ///////////////////////////////////////////////////////////////////////////////
1339 class Inst_LEU : public a_Inst {
1340 public:
1341 #line 22 "sparc.pC"
1342    Inst _1; Inst _2;
1343    inline Inst_LEU (Inst _x1, Inst _x2)
1344       : a_Inst(a_Inst::tag_LEU), _1(_x1), _2(_x2) {}
1345    inline friend a_Inst * LEU (Inst _x1, Inst _x2)
1346       { return new Inst_LEU (_x1, _x2); }
1347 };
1348
1349 ///////////////////////////////////////////////////////////////////////////////
1350 // class for constructor 'Inst::LOADB Inst'
1351 ///////////////////////////////////////////////////////////////////////////////
1352 class Inst_LOADB : public a_Inst {
1353 public:
1354 #line 23 "sparc.pC"
1355    Inst LOADB;
1356    inline Inst_LOADB (Inst _xLOADB)
1357       : a_Inst(a_Inst::tag_LOADB), LOADB(_xLOADB) {}
1358    inline friend a_Inst * LOADB (Inst _xLOADB)
1359       { return new Inst_LOADB (_xLOADB); }
1360 };
1361
1362 ///////////////////////////////////////////////////////////////////////////////
1363 // class for constructor 'Inst::LOADC Inst'
1364 ///////////////////////////////////////////////////////////////////////////////
1365 class Inst_LOADC : public a_Inst {
1366 public:
1367 #line 23 "sparc.pC"
1368    Inst LOADC;
1369    inline Inst_LOADC (Inst _xLOADC)
1370       : a_Inst(a_Inst::tag_LOADC), LOADC(_xLOADC) {}
1371    inline friend a_Inst * LOADC (Inst _xLOADC)
1372       { return new Inst_LOADC (_xLOADC); }
1373 };
1374
1375 ///////////////////////////////////////////////////////////////////////////////
1376 // class for constructor 'Inst::LOADD Inst'
1377 ///////////////////////////////////////////////////////////////////////////////
1378 class Inst_LOADD : public a_Inst {
1379 public:
1380 #line 23 "sparc.pC"
1381    Inst LOADD;
1382    inline Inst_LOADD (Inst _xLOADD)
1383       : a_Inst(a_Inst::tag_LOADD), LOADD(_xLOADD) {}
1384    inline friend a_Inst * LOADD (Inst _xLOADD)
1385       { return new Inst_LOADD (_xLOADD); }
1386 };
1387
1388 ///////////////////////////////////////////////////////////////////////////////
1389 // class for constructor 'Inst::LOADF Inst'
1390 ///////////////////////////////////////////////////////////////////////////////
1391 class Inst_LOADF : public a_Inst {
1392 public:
1393 #line 23 "sparc.pC"
1394    Inst LOADF;
1395    inline Inst_LOADF (Inst _xLOADF)
1396       : a_Inst(a_Inst::tag_LOADF), LOADF(_xLOADF) {}
1397    inline friend a_Inst * LOADF (Inst _xLOADF)
1398       { return new Inst_LOADF (_xLOADF); }
1399 };
1400
1401 ///////////////////////////////////////////////////////////////////////////////
1402 // class for constructor 'Inst::LOADI Inst'
1403 ///////////////////////////////////////////////////////////////////////////////
1404 class Inst_LOADI : public a_Inst {
1405 public:
1406 #line 24 "sparc.pC"
1407    Inst LOADI;
1408    inline Inst_LOADI (Inst _xLOADI)
1409       : a_Inst(a_Inst::tag_LOADI), LOADI(_xLOADI) {}
1410    inline friend a_Inst * LOADI (Inst _xLOADI)
1411       { return new Inst_LOADI (_xLOADI); }
1412 };
1413
1414 ///////////////////////////////////////////////////////////////////////////////
1415 // class for constructor 'Inst::LOADP Inst'
1416 ///////////////////////////////////////////////////////////////////////////////
1417 class Inst_LOADP : public a_Inst {
1418 public:
1419 #line 24 "sparc.pC"
1420    Inst LOADP;
1421    inline Inst_LOADP (Inst _xLOADP)
1422       : a_Inst(a_Inst::tag_LOADP), LOADP(_xLOADP) {}
1423    inline friend a_Inst * LOADP (Inst _xLOADP)
1424       { return new Inst_LOADP (_xLOADP); }
1425 };
1426
1427 ///////////////////////////////////////////////////////////////////////////////
1428 // class for constructor 'Inst::LOADS Inst'
1429 ///////////////////////////////////////////////////////////////////////////////
1430 class Inst_LOADS : public a_Inst {
1431 public:
1432 #line 24 "sparc.pC"
1433    Inst LOADS;
1434    inline Inst_LOADS (Inst _xLOADS)
1435       : a_Inst(a_Inst::tag_LOADS), LOADS(_xLOADS) {}
1436    inline friend a_Inst * LOADS (Inst _xLOADS)
1437       { return new Inst_LOADS (_xLOADS); }
1438 };
1439
1440 ///////////////////////////////////////////////////////////////////////////////
1441 // class for constructor 'Inst::LOADU Inst'
1442 ///////////////////////////////////////////////////////////////////////////////
1443 class Inst_LOADU : public a_Inst {
1444 public:
1445 #line 24 "sparc.pC"
1446    Inst LOADU;
1447    inline Inst_LOADU (Inst _xLOADU)
1448       : a_Inst(a_Inst::tag_LOADU), LOADU(_xLOADU) {}
1449    inline friend a_Inst * LOADU (Inst _xLOADU)
1450       { return new Inst_LOADU (_xLOADU); }
1451 };
1452
1453 ///////////////////////////////////////////////////////////////////////////////
1454 // class for constructor 'Inst::LSHI (Inst, Inst)'
1455 ///////////////////////////////////////////////////////////////////////////////
1456 class Inst_LSHI : public a_Inst {
1457 public:
1458 #line 25 "sparc.pC"
1459    Inst _1; Inst _2;
1460    inline Inst_LSHI (Inst _x1, Inst _x2)
1461       : a_Inst(a_Inst::tag_LSHI), _1(_x1), _2(_x2) {}
1462    inline friend a_Inst * LSHI (Inst _x1, Inst _x2)
1463       { return new Inst_LSHI (_x1, _x2); }
1464 };
1465
1466 ///////////////////////////////////////////////////////////////////////////////
1467 // class for constructor 'Inst::LSHU (Inst, Inst)'
1468 ///////////////////////////////////////////////////////////////////////////////
1469 class Inst_LSHU : public a_Inst {
1470 public:
1471 #line 25 "sparc.pC"
1472    Inst _1; Inst _2;
1473    inline Inst_LSHU (Inst _x1, Inst _x2)
1474       : a_Inst(a_Inst::tag_LSHU), _1(_x1), _2(_x2) {}
1475    inline friend a_Inst * LSHU (Inst _x1, Inst _x2)
1476       { return new Inst_LSHU (_x1, _x2); }
1477 };
1478
1479 ///////////////////////////////////////////////////////////////////////////////
1480 // class for constructor 'Inst::LTD (Inst, Inst)'
1481 ///////////////////////////////////////////////////////////////////////////////
1482 class Inst_LTD : public a_Inst {
1483 public:
1484 #line 26 "sparc.pC"
1485    Inst _1; Inst _2;
1486    inline Inst_LTD (Inst _x1, Inst _x2)
1487       : a_Inst(a_Inst::tag_LTD), _1(_x1), _2(_x2) {}
1488    inline friend a_Inst * LTD (Inst _x1, Inst _x2)
1489       { return new Inst_LTD (_x1, _x2); }
1490 };
1491
1492 ///////////////////////////////////////////////////////////////////////////////
1493 // class for constructor 'Inst::LTF (Inst, Inst)'
1494 ///////////////////////////////////////////////////////////////////////////////
1495 class Inst_LTF : public a_Inst {
1496 public:
1497 #line 26 "sparc.pC"
1498    Inst _1; Inst _2;
1499    inline Inst_LTF (Inst _x1, Inst _x2)
1500       : a_Inst(a_Inst::tag_LTF), _1(_x1), _2(_x2) {}
1501    inline friend a_Inst * LTF (Inst _x1, Inst _x2)
1502       { return new Inst_LTF (_x1, _x2); }
1503 };
1504
1505 ///////////////////////////////////////////////////////////////////////////////
1506 // class for constructor 'Inst::LTI (Inst, Inst)'
1507 ///////////////////////////////////////////////////////////////////////////////
1508 class Inst_LTI : public a_Inst {
1509 public:
1510 #line 26 "sparc.pC"
1511    Inst _1; Inst _2;
1512    inline Inst_LTI (Inst _x1, Inst _x2)
1513       : a_Inst(a_Inst::tag_LTI), _1(_x1), _2(_x2) {}
1514    inline friend a_Inst * LTI (Inst _x1, Inst _x2)
1515       { return new Inst_LTI (_x1, _x2); }
1516 };
1517
1518 ///////////////////////////////////////////////////////////////////////////////
1519 // class for constructor 'Inst::LTU (Inst, Inst)'
1520 ///////////////////////////////////////////////////////////////////////////////
1521 class Inst_LTU : public a_Inst {
1522 public:
1523 #line 26 "sparc.pC"
1524    Inst _1; Inst _2;
1525    inline Inst_LTU (Inst _x1, Inst _x2)
1526       : a_Inst(a_Inst::tag_LTU), _1(_x1), _2(_x2) {}
1527    inline friend a_Inst * LTU (Inst _x1, Inst _x2)
1528       { return new Inst_LTU (_x1, _x2); }
1529 };
1530
1531 ///////////////////////////////////////////////////////////////////////////////
1532 // class for constructor 'Inst::MODI (Inst, Inst)'
1533 ///////////////////////////////////////////////////////////////////////////////
1534 class Inst_MODI : public a_Inst {
1535 public:
1536 #line 27 "sparc.pC"
1537    Inst _1; Inst _2;
1538    inline Inst_MODI (Inst _x1, Inst _x2)
1539       : a_Inst(a_Inst::tag_MODI), _1(_x1), _2(_x2) {}
1540    inline friend a_Inst * MODI (Inst _x1, Inst _x2)
1541       { return new Inst_MODI (_x1, _x2); }
1542 };
1543
1544 ///////////////////////////////////////////////////////////////////////////////
1545 // class for constructor 'Inst::MODU (Inst, Inst)'
1546 ///////////////////////////////////////////////////////////////////////////////
1547 class Inst_MODU : public a_Inst {
1548 public:
1549 #line 27 "sparc.pC"
1550    Inst _1; Inst _2;
1551    inline Inst_MODU (Inst _x1, Inst _x2)
1552       : a_Inst(a_Inst::tag_MODU), _1(_x1), _2(_x2) {}
1553    inline friend a_Inst * MODU (Inst _x1, Inst _x2)
1554       { return new Inst_MODU (_x1, _x2); }
1555 };
1556
1557 ///////////////////////////////////////////////////////////////////////////////
1558 // class for constructor 'Inst::MULD (Inst, Inst)'
1559 ///////////////////////////////////////////////////////////////////////////////
1560 class Inst_MULD : public a_Inst {
1561 public:
1562 #line 28 "sparc.pC"
1563    Inst _1; Inst _2;
1564    inline Inst_MULD (Inst _x1, Inst _x2)
1565       : a_Inst(a_Inst::tag_MULD), _1(_x1), _2(_x2) {}
1566    inline friend a_Inst * MULD (Inst _x1, Inst _x2)
1567       { return new Inst_MULD (_x1, _x2); }
1568 };
1569
1570 ///////////////////////////////////////////////////////////////////////////////
1571 // class for constructor 'Inst::MULF (Inst, Inst)'
1572 ///////////////////////////////////////////////////////////////////////////////
1573 class Inst_MULF : public a_Inst {
1574 public:
1575 #line 28 "sparc.pC"
1576    Inst _1; Inst _2;
1577    inline Inst_MULF (Inst _x1, Inst _x2)
1578       : a_Inst(a_Inst::tag_MULF), _1(_x1), _2(_x2) {}
1579    inline friend a_Inst * MULF (Inst _x1, Inst _x2)
1580       { return new Inst_MULF (_x1, _x2); }
1581 };
1582
1583 ///////////////////////////////////////////////////////////////////////////////
1584 // class for constructor 'Inst::MULI (Inst, Inst)'
1585 ///////////////////////////////////////////////////////////////////////////////
1586 class Inst_MULI : public a_Inst {
1587 public:
1588 #line 28 "sparc.pC"
1589    Inst _1; Inst _2;
1590    inline Inst_MULI (Inst _x1, Inst _x2)
1591       : a_Inst(a_Inst::tag_MULI), _1(_x1), _2(_x2) {}
1592    inline friend a_Inst * MULI (Inst _x1, Inst _x2)
1593       { return new Inst_MULI (_x1, _x2); }
1594 };
1595
1596 ///////////////////////////////////////////////////////////////////////////////
1597 // class for constructor 'Inst::MULU (Inst, Inst)'
1598 ///////////////////////////////////////////////////////////////////////////////
1599 class Inst_MULU : public a_Inst {
1600 public:
1601 #line 28 "sparc.pC"
1602    Inst _1; Inst _2;
1603    inline Inst_MULU (Inst _x1, Inst _x2)
1604       : a_Inst(a_Inst::tag_MULU), _1(_x1), _2(_x2) {}
1605    inline friend a_Inst * MULU (Inst _x1, Inst _x2)
1606       { return new Inst_MULU (_x1, _x2); }
1607 };
1608
1609 ///////////////////////////////////////////////////////////////////////////////
1610 // class for constructor 'Inst::NED (Inst, Inst)'
1611 ///////////////////////////////////////////////////////////////////////////////
1612 class Inst_NED : public a_Inst {
1613 public:
1614 #line 29 "sparc.pC"
1615    Inst _1; Inst _2;
1616    inline Inst_NED (Inst _x1, Inst _x2)
1617       : a_Inst(a_Inst::tag_NED), _1(_x1), _2(_x2) {}
1618    inline friend a_Inst * NED (Inst _x1, Inst _x2)
1619       { return new Inst_NED (_x1, _x2); }
1620 };
1621
1622 ///////////////////////////////////////////////////////////////////////////////
1623 // class for constructor 'Inst::NEF (Inst, Inst)'
1624 ///////////////////////////////////////////////////////////////////////////////
1625 class Inst_NEF : public a_Inst {
1626 public:
1627 #line 29 "sparc.pC"
1628    Inst _1; Inst _2;
1629    inline Inst_NEF (Inst _x1, Inst _x2)
1630       : a_Inst(a_Inst::tag_NEF), _1(_x1), _2(_x2) {}
1631    inline friend a_Inst * NEF (Inst _x1, Inst _x2)
1632       { return new Inst_NEF (_x1, _x2); }
1633 };
1634
1635 ///////////////////////////////////////////////////////////////////////////////
1636 // class for constructor 'Inst::NEI (Inst, Inst)'
1637 ///////////////////////////////////////////////////////////////////////////////
1638 class Inst_NEI : public a_Inst {
1639 public:
1640 #line 29 "sparc.pC"
1641    Inst _1; Inst _2;
1642    inline Inst_NEI (Inst _x1, Inst _x2)
1643       : a_Inst(a_Inst::tag_NEI), _1(_x1), _2(_x2) {}
1644    inline friend a_Inst * NEI (Inst _x1, Inst _x2)
1645       { return new Inst_NEI (_x1, _x2); }
1646 };
1647
1648 ///////////////////////////////////////////////////////////////////////////////
1649 // class for constructor 'Inst::NEGD Inst'
1650 ///////////////////////////////////////////////////////////////////////////////
1651 class Inst_NEGD : public a_Inst {
1652 public:
1653 #line 30 "sparc.pC"
1654    Inst NEGD;
1655    inline Inst_NEGD (Inst _xNEGD)
1656       : a_Inst(a_Inst::tag_NEGD), NEGD(_xNEGD) {}
1657    inline friend a_Inst * NEGD (Inst _xNEGD)
1658       { return new Inst_NEGD (_xNEGD); }
1659 };
1660
1661 ///////////////////////////////////////////////////////////////////////////////
1662 // class for constructor 'Inst::NEGF Inst'
1663 ///////////////////////////////////////////////////////////////////////////////
1664 class Inst_NEGF : public a_Inst {
1665 public:
1666 #line 30 "sparc.pC"
1667    Inst NEGF;
1668    inline Inst_NEGF (Inst _xNEGF)
1669       : a_Inst(a_Inst::tag_NEGF), NEGF(_xNEGF) {}
1670    inline friend a_Inst * NEGF (Inst _xNEGF)
1671       { return new Inst_NEGF (_xNEGF); }
1672 };
1673
1674 ///////////////////////////////////////////////////////////////////////////////
1675 // class for constructor 'Inst::NEGI Inst'
1676 ///////////////////////////////////////////////////////////////////////////////
1677 class Inst_NEGI : public a_Inst {
1678 public:
1679 #line 30 "sparc.pC"
1680    Inst NEGI;
1681    inline Inst_NEGI (Inst _xNEGI)
1682       : a_Inst(a_Inst::tag_NEGI), NEGI(_xNEGI) {}
1683    inline friend a_Inst * NEGI (Inst _xNEGI)
1684       { return new Inst_NEGI (_xNEGI); }
1685 };
1686
1687 ///////////////////////////////////////////////////////////////////////////////
1688 // class for constructor 'Inst::RETD Inst'
1689 ///////////////////////////////////////////////////////////////////////////////
1690 class Inst_RETD : public a_Inst {
1691 public:
1692 #line 31 "sparc.pC"
1693    Inst RETD;
1694    inline Inst_RETD (Inst _xRETD)
1695       : a_Inst(a_Inst::tag_RETD), RETD(_xRETD) {}
1696    inline friend a_Inst * RETD (Inst _xRETD)
1697       { return new Inst_RETD (_xRETD); }
1698 };
1699
1700 ///////////////////////////////////////////////////////////////////////////////
1701 // class for constructor 'Inst::RETF Inst'
1702 ///////////////////////////////////////////////////////////////////////////////
1703 class Inst_RETF : public a_Inst {
1704 public:
1705 #line 31 "sparc.pC"
1706    Inst RETF;
1707    inline Inst_RETF (Inst _xRETF)
1708       : a_Inst(a_Inst::tag_RETF), RETF(_xRETF) {}
1709    inline friend a_Inst * RETF (Inst _xRETF)
1710       { return new Inst_RETF (_xRETF); }
1711 };
1712
1713 ///////////////////////////////////////////////////////////////////////////////
1714 // class for constructor 'Inst::RETI Inst'
1715 ///////////////////////////////////////////////////////////////////////////////
1716 class Inst_RETI : public a_Inst {
1717 public:
1718 #line 31 "sparc.pC"
1719    Inst RETI;
1720    inline Inst_RETI (Inst _xRETI)
1721       : a_Inst(a_Inst::tag_RETI), RETI(_xRETI) {}
1722    inline friend a_Inst * RETI (Inst _xRETI)
1723       { return new Inst_RETI (_xRETI); }
1724 };
1725
1726 ///////////////////////////////////////////////////////////////////////////////
1727 // class for constructor 'Inst::RSHI (Inst, Inst)'
1728 ///////////////////////////////////////////////////////////////////////////////
1729 class Inst_RSHI : public a_Inst {
1730 public:
1731 #line 32 "sparc.pC"
1732    Inst _1; Inst _2;
1733    inline Inst_RSHI (Inst _x1, Inst _x2)
1734       : a_Inst(a_Inst::tag_RSHI), _1(_x1), _2(_x2) {}
1735    inline friend a_Inst * RSHI (Inst _x1, Inst _x2)
1736       { return new Inst_RSHI (_x1, _x2); }
1737 };
1738
1739 ///////////////////////////////////////////////////////////////////////////////
1740 // class for constructor 'Inst::RSHU (Inst, Inst)'
1741 ///////////////////////////////////////////////////////////////////////////////
1742 class Inst_RSHU : public a_Inst {
1743 public:
1744 #line 32 "sparc.pC"
1745    Inst _1; Inst _2;
1746    inline Inst_RSHU (Inst _x1, Inst _x2)
1747       : a_Inst(a_Inst::tag_RSHU), _1(_x1), _2(_x2) {}
1748    inline friend a_Inst * RSHU (Inst _x1, Inst _x2)
1749       { return new Inst_RSHU (_x1, _x2); }
1750 };
1751
1752 ///////////////////////////////////////////////////////////////////////////////
1753 // class for constructor 'Inst::SUBD (Inst, Inst)'
1754 ///////////////////////////////////////////////////////////////////////////////
1755 class Inst_SUBD : public a_Inst {
1756 public:
1757 #line 33 "sparc.pC"
1758    Inst _1; Inst _2;
1759    inline Inst_SUBD (Inst _x1, Inst _x2)
1760       : a_Inst(a_Inst::tag_SUBD), _1(_x1), _2(_x2) {}
1761    inline friend a_Inst * SUBD (Inst _x1, Inst _x2)
1762       { return new Inst_SUBD (_x1, _x2); }
1763 };
1764
1765 ///////////////////////////////////////////////////////////////////////////////
1766 // class for constructor 'Inst::SUBF (Inst, Inst)'
1767 ///////////////////////////////////////////////////////////////////////////////
1768 class Inst_SUBF : public a_Inst {
1769 public:
1770 #line 33 "sparc.pC"
1771    Inst _1; Inst _2;
1772    inline Inst_SUBF (Inst _x1, Inst _x2)
1773       : a_Inst(a_Inst::tag_SUBF), _1(_x1), _2(_x2) {}
1774    inline friend a_Inst * SUBF (Inst _x1, Inst _x2)
1775       { return new Inst_SUBF (_x1, _x2); }
1776 };
1777
1778 ///////////////////////////////////////////////////////////////////////////////
1779 // class for constructor 'Inst::SUBI (Inst, Inst)'
1780 ///////////////////////////////////////////////////////////////////////////////
1781 class Inst_SUBI : public a_Inst {
1782 public:
1783 #line 33 "sparc.pC"
1784    Inst _1; Inst _2;
1785    inline Inst_SUBI (Inst _x1, Inst _x2)
1786       : a_Inst(a_Inst::tag_SUBI), _1(_x1), _2(_x2) {}
1787    inline friend a_Inst * SUBI (Inst _x1, Inst _x2)
1788       { return new Inst_SUBI (_x1, _x2); }
1789 };
1790
1791 ///////////////////////////////////////////////////////////////////////////////
1792 // class for constructor 'Inst::SUBP (Inst, Inst)'
1793 ///////////////////////////////////////////////////////////////////////////////
1794 class Inst_SUBP : public a_Inst {
1795 public:
1796 #line 34 "sparc.pC"
1797    Inst _1; Inst _2;
1798    inline Inst_SUBP (Inst _x1, Inst _x2)
1799       : a_Inst(a_Inst::tag_SUBP), _1(_x1), _2(_x2) {}
1800    inline friend a_Inst * SUBP (Inst _x1, Inst _x2)
1801       { return new Inst_SUBP (_x1, _x2); }
1802 };
1803
1804 ///////////////////////////////////////////////////////////////////////////////
1805 // class for constructor 'Inst::SUBU (Inst, Inst)'
1806 ///////////////////////////////////////////////////////////////////////////////
1807 class Inst_SUBU : public a_Inst {
1808 public:
1809 #line 34 "sparc.pC"
1810    Inst _1; Inst _2;
1811    inline Inst_SUBU (Inst _x1, Inst _x2)
1812       : a_Inst(a_Inst::tag_SUBU), _1(_x1), _2(_x2) {}
1813    inline friend a_Inst * SUBU (Inst _x1, Inst _x2)
1814       { return new Inst_SUBU (_x1, _x2); }
1815 };
1816
1817 ///////////////////////////////////////////////////////////////////////////////
1818 // class for constructor 'Inst::VREGP ()'
1819 ///////////////////////////////////////////////////////////////////////////////
1820 class Inst_VREGP : public a_Inst {
1821 public:
1822 #line 35 "sparc.pC"
1823
1824    inline Inst_VREGP ()
1825       : a_Inst(a_Inst::tag_VREGP) {}
1826    inline friend a_Inst * VREGP ()
1827       { return new Inst_VREGP ; }
1828 };
1829
1830 #line 36 "sparc.pC"
1831 #line 36 "sparc.pC"
1832
1833
1834 extern int move(Inst);
1835 extern int range(Inst,int,int);
1836 extern int imm(Inst);
1837 extern int notarget(Inst);
1838
1839 void compile (Inst e)
1840 {
1841 #line 45 "sparc.pC"
1842 #line 230 "sparc.pC"
1843    extern void  _s_p_a_r_cco_X1_rewrite(Inst & );
1844    _s_p_a_r_cco_X1_rewrite(e);
1845 #line 231 "sparc.pC"
1846 #line 231 "sparc.pC"
1847
1848 }
1849 #line 233 "sparc.pC"
1850 class _s_p_a_r_cco_X1 : public BURS {
1851 private:
1852    _s_p_a_r_cco_X1(const _s_p_a_r_cco_X1&);               // no copy constructor
1853    void operator = (const _s_p_a_r_cco_X1&); // no assignment
1854 public:
1855    struct _s_p_a_r_cco_X1_StateRec * stack__, * stack_top__;
1856           void labeler(Inst redex);
1857    inline virtual void operator () (Inst redex) { labeler(redex); }
1858           void  reduce(Inst redex,int lhs = 1);
1859 private:
1860    public:
1861       inline _s_p_a_r_cco_X1() {}
1862 };
1863 void  _s_p_a_r_cco_X1_rewrite(Inst &  _x_)
1864 {  _s_p_a_r_cco_X1 _r_;
1865    _r_(_x_); _r_.reduce(_x_);
1866 }
1867
1868
1869 ///////////////////////////////////////////////////////////////////////////////
1870 // State record for rewrite class _s_p_a_r_cco_X1
1871 ///////////////////////////////////////////////////////////////////////////////
1872 struct _s_p_a_r_cco_X1_StateRec {
1873    TreeTables::Cost cost[16]; // cost for each non-terminal
1874    struct { // accept rule number
1875       unsigned int _call : 2;
1876       unsigned int _stk : 2;
1877       unsigned int _rc5 : 2;
1878       unsigned int _rc : 2;
1879       unsigned int _addrg : 2;
1880       unsigned int _addrl : 2;
1881       unsigned int _stk13 : 2;
1882       unsigned int _addr : 3;
1883       unsigned int _con13 : 3;
1884       unsigned int _stmt : 6;
1885       unsigned int _con : 3;
1886       unsigned int _reg : 7;
1887       unsigned int _spill : 2;
1888       unsigned int _rel : 4;
1889       unsigned int _base : 3;
1890    } rule;
1891 };
1892
1893 ///////////////////////////////////////////////////////////////////////////////
1894 // Accept rules tables for rewrite class _s_p_a_r_cco_X1
1895 ///////////////////////////////////////////////////////////////////////////////
1896 const char _s_p_a_r_cco_X1_base_accept[] = { -1, 40, 39, 38, 37, 36, 35 };
1897
1898 const short _s_p_a_r_cco_X1_call_accept[] = { -1, 136, 135 };
1899
1900 const char _s_p_a_r_cco_X1_rc5_accept[] = { -1, 107, 106 };
1901
1902 const char _s_p_a_r_cco_X1_rc_accept[] = { -1, 96, 95 };
1903
1904 const char _s_p_a_r_cco_X1_addrg_accept[] = { -1, 121 };
1905
1906 const char _s_p_a_r_cco_X1_addrl_accept[] = { -1, 56 };
1907
1908 const char _s_p_a_r_cco_X1_stk13_accept[] = { -1, 24, 23 };
1909
1910 const char _s_p_a_r_cco_X1_addr_accept[] = { -1, 45, 44, 43, 42, 41 };
1911
1912 const char _s_p_a_r_cco_X1_con13_accept[] = { -1, 34, 33, 32, 31, 30 };
1913
1914 const short _s_p_a_r_cco_X1_stmt_accept[] = { -1, 184, 181, 148, 147, 146, 145, 144, 143, 142, 141, 140, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 67, 66, 65, 64, 63, 62, 60, 58, 55, 54, 53, 52, 51, 17, 11, 10, 9, 8, 7, 6 };
1915
1916 const char _s_p_a_r_cco_X1_con_accept[] = { -1, 16, 15, 14, 13, 12 };
1917
1918 const short _s_p_a_r_cco_X1_reg_accept[] = { -1, 183, 182, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 139, 138, 137, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 105, 104, 103, 102, 101, 100, 99, 98, 97, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 59, 57, 50, 49, 48, 47, 46, 29, 28, 25, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0 };
1919
1920 const char _s_p_a_r_cco_X1_spill_accept[] = { -1, 61 };
1921
1922 const short _s_p_a_r_cco_X1_rel_accept[] = { -1, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169 };
1923
1924 const char _s_p_a_r_cco_X1_stk_accept[] = { -1, 27, 26 };
1925
1926 ///////////////////////////////////////////////////////////////////////////////
1927 // Closure methods for rewrite class _s_p_a_r_cco_X1
1928 ///////////////////////////////////////////////////////////////////////////////
1929 static void _s_p_a_r_cco_X1_stk_closure(Inst redex,int cost);
1930 static void _s_p_a_r_cco_X1_stk13_closure(Inst redex,int cost);
1931 static void _s_p_a_r_cco_X1_addr_closure(Inst redex,int cost);
1932 static void _s_p_a_r_cco_X1_con13_closure(Inst redex,int cost);
1933 static void _s_p_a_r_cco_X1_con_closure(Inst redex,int cost);
1934 static void _s_p_a_r_cco_X1_reg_closure(Inst redex,int cost);
1935 static void _s_p_a_r_cco_X1_rel_closure(Inst redex,int cost);
1936 static void _s_p_a_r_cco_X1_base_closure(Inst redex,int cost);
1937
1938 static void _s_p_a_r_cco_X1_stk_closure(Inst redex,int cost__)
1939 {
1940    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1941    if (cost__ + 0 < _state_rec->cost[8])
1942    {  _state_rec->cost[8] = cost__ + 0;
1943       _state_rec->rule._addr = 1;
1944       _s_p_a_r_cco_X1_addr_closure(redex,cost__ + 0);
1945    }
1946 }
1947
1948 static void _s_p_a_r_cco_X1_stk13_closure(Inst redex,int cost__)
1949 {
1950    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1951    if (cost__ + 1 < _state_rec->cost[1])
1952    {  _state_rec->cost[1] = cost__ + 1;
1953       _state_rec->rule._reg = 1;
1954       _s_p_a_r_cco_X1_reg_closure(redex,cost__ + 1);
1955    }
1956    if (cost__ + 0 < _state_rec->cost[7])
1957    {  _state_rec->cost[7] = cost__ + 0;
1958       _state_rec->rule._base = 2;
1959       _s_p_a_r_cco_X1_base_closure(redex,cost__ + 0);
1960    }
1961 }
1962
1963 static void _s_p_a_r_cco_X1_addr_closure(Inst redex,int cost__)
1964 {
1965    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1966    if (cost__ + 0 < _state_rec->cost[14])
1967    {  _state_rec->cost[14] = cost__ + 0;
1968       _state_rec->rule._call = 1;
1969    }
1970 }
1971
1972 static void _s_p_a_r_cco_X1_con13_closure(Inst redex,int cost__)
1973 {
1974    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1975    if (cost__ + 0 < _state_rec->cost[7])
1976    {  _state_rec->cost[7] = cost__ + 0;
1977       _state_rec->rule._base = 1;
1978       _s_p_a_r_cco_X1_base_closure(redex,cost__ + 0);
1979    }
1980    if (cost__ + 0 < _state_rec->cost[11])
1981    {  _state_rec->cost[11] = cost__ + 0;
1982       _state_rec->rule._rc = 2;
1983    }
1984 }
1985
1986 static void _s_p_a_r_cco_X1_con_closure(Inst redex,int cost__)
1987 {
1988    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1989    if (cost__ + 1 < _state_rec->cost[1])
1990    {  _state_rec->cost[1] = cost__ + 1;
1991       _state_rec->rule._reg = 1;
1992       _s_p_a_r_cco_X1_reg_closure(redex,cost__ + 1);
1993    }
1994 }
1995
1996 static void _s_p_a_r_cco_X1_reg_closure(Inst redex,int cost__)
1997 {
1998    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
1999    if (cost__ + 0 < _state_rec->cost[2])
2000    {  _state_rec->cost[2] = cost__ + 0;
2001       _state_rec->rule._stmt = 1;
2002    }
2003    if (cost__ + 0 < _state_rec->cost[7])
2004    {  _state_rec->cost[7] = cost__ + 0;
2005       _state_rec->rule._base = 2;
2006       _s_p_a_r_cco_X1_base_closure(redex,cost__ + 0);
2007    }
2008    if (cost__ + 0 < _state_rec->cost[11])
2009    {  _state_rec->cost[11] = cost__ + 0;
2010       _state_rec->rule._rc = 3;
2011    }
2012    if (cost__ + 0 < _state_rec->cost[12])
2013    {  _state_rec->cost[12] = cost__ + 0;
2014       _state_rec->rule._rc5 = 4;
2015    }
2016 }
2017
2018 static void _s_p_a_r_cco_X1_rel_closure(Inst redex,int cost__)
2019 {
2020    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
2021    if (cost__ + 4 < _state_rec->cost[2])
2022    {  _state_rec->cost[2] = cost__ + 4;
2023       _state_rec->rule._stmt = 1;
2024    }
2025 }
2026
2027 static void _s_p_a_r_cco_X1_base_closure(Inst redex,int cost__)
2028 {
2029    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
2030    if (cost__ + 0 < _state_rec->cost[8])
2031    {  _state_rec->cost[8] = cost__ + 0;
2032       _state_rec->rule._addr = 1;
2033       _s_p_a_r_cco_X1_addr_closure(redex,cost__ + 0);
2034    }
2035 }
2036
2037 void _s_p_a_r_cco_X1::labeler (Inst redex)
2038 {
2039    int cost__;
2040    _s_p_a_r_cco_X1_StateRec * _state_rec = (_s_p_a_r_cco_X1_StateRec *)mem[sizeof(_s_p_a_r_cco_X1_StateRec)];
2041    redex->set_state_rec(_state_rec);
2042    _state_rec->cost[0] = 0;
2043    _state_rec->cost[1] =
2044    _state_rec->cost[2] =
2045    _state_rec->cost[3] =
2046    _state_rec->cost[4] =
2047    _state_rec->cost[5] =
2048    _state_rec->cost[6] =
2049    _state_rec->cost[7] =
2050    _state_rec->cost[8] =
2051    _state_rec->cost[9] =
2052    _state_rec->cost[10] =
2053    _state_rec->cost[11] =
2054    _state_rec->cost[12] =
2055    _state_rec->cost[13] =
2056    _state_rec->cost[14] =
2057    _state_rec->cost[15] = 32767;
2058    {
2059       switch (redex->untag()) {
2060          case a_Inst::tag_ADDD: {
2061             labeler(_ADDD(redex)->_1);
2062             labeler(_ADDD(redex)->_2);
2063             // reg -> ADDD (reg, reg) \ 1: ...
2064             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ADDD(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_ADDD(redex)->_2->get_state_rec())->cost[1] + 1));
2065             if (cost__ < _state_rec->cost[1])
2066             {   _state_rec->cost[1] = cost__;
2067                 _state_rec->rule._reg = 16;
2068                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2069             }} break;
2070          case a_Inst::tag_ADDF: {
2071             labeler(_ADDF(redex)->_1);
2072             labeler(_ADDF(redex)->_2);
2073             // reg -> ADDF (reg, reg) \ 1: ...
2074             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ADDF(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_ADDF(redex)->_2->get_state_rec())->cost[1] + 1));
2075             if (cost__ < _state_rec->cost[1])
2076             {   _state_rec->cost[1] = cost__;
2077                 _state_rec->rule._reg = 15;
2078                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2079             }} break;
2080          case a_Inst::tag_ADDI: {
2081             labeler(_ADDI(redex)->_1);
2082             labeler(_ADDI(redex)->_2);
2083             // base -> ADDI (reg, con13): ...
2084             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_1->get_state_rec())->cost[7] + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_2->get_state_rec())->cost[7] + 1));
2085             if (cost__ < _state_rec->cost[7])
2086             {   _state_rec->cost[7] = cost__;
2087                 _state_rec->rule._base = 6;
2088                _s_p_a_r_cco_X1_base_closure(redex, cost__);
2089             }
2090             // addr -> ADDI (reg, reg): ...
2091             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_1->get_state_rec())->cost[8] + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_2->get_state_rec())->cost[8] + 1));
2092             if (cost__ < _state_rec->cost[8])
2093             {   _state_rec->cost[8] = cost__;
2094                 _state_rec->rule._addr = 4;
2095                _s_p_a_r_cco_X1_addr_closure(redex, cost__);
2096             }
2097             // reg -> ADDI (reg, rc) \ 1: ...
2098             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_ADDI(redex)->_2->get_state_rec())->cost[1] + 1));
2099             if (cost__ < _state_rec->cost[1])
2100             {   _state_rec->cost[1] = cost__;
2101                 _state_rec->rule._reg = 47;
2102                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2103             }} break;
2104          case a_Inst::tag_ADDP: {
2105             labeler(_ADDP(redex)->_1);
2106             labeler(_ADDP(redex)->_2);
2107             // base -> ADDP (reg, con13): ...
2108             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_1->get_state_rec())->cost[7] + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_2->get_state_rec())->cost[7] + 1));
2109             if (cost__ < _state_rec->cost[7])
2110             {   _state_rec->cost[7] = cost__;
2111                 _state_rec->rule._base = 5;
2112                _s_p_a_r_cco_X1_base_closure(redex, cost__);
2113             }
2114             // addr -> ADDP (reg, reg): ...
2115             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_1->get_state_rec())->cost[8] + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_2->get_state_rec())->cost[8] + 1));
2116             if (cost__ < _state_rec->cost[8])
2117             {   _state_rec->cost[8] = cost__;
2118                 _state_rec->rule._addr = 3;
2119                _s_p_a_r_cco_X1_addr_closure(redex, cost__);
2120             }
2121             // reg -> ADDP (reg, rc) \ 1: ...
2122             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_ADDP(redex)->_2->get_state_rec())->cost[1] + 1));
2123             if (cost__ < _state_rec->cost[1])
2124             {   _state_rec->cost[1] = cost__;
2125                 _state_rec->rule._reg = 46;
2126                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2127             }} break;
2128          case a_Inst::tag_ADDU: {
2129             labeler(_ADDU(redex)->_1);
2130             labeler(_ADDU(redex)->_2);
2131             // base -> ADDU (reg, con13): ...
2132             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_1->get_state_rec())->cost[7] + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_2->get_state_rec())->cost[7] + 1));
2133             if (cost__ < _state_rec->cost[7])
2134             {   _state_rec->cost[7] = cost__;
2135                 _state_rec->rule._base = 4;
2136                _s_p_a_r_cco_X1_base_closure(redex, cost__);
2137             }
2138             // addr -> ADDU (reg, reg): ...
2139             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_1->get_state_rec())->cost[8] + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_2->get_state_rec())->cost[8] + 1));
2140             if (cost__ < _state_rec->cost[8])
2141             {   _state_rec->cost[8] = cost__;
2142                 _state_rec->rule._addr = 2;
2143                _s_p_a_r_cco_X1_addr_closure(redex, cost__);
2144             }
2145             // reg -> ADDU (reg, rc) \ 1: ...
2146             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_ADDU(redex)->_2->get_state_rec())->cost[1] + 1));
2147             if (cost__ < _state_rec->cost[1])
2148             {   _state_rec->cost[1] = cost__;
2149                 _state_rec->rule._reg = 45;
2150                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2151             }} break;
2152          case a_Inst::tag_ADDRFP: {
2153             // stk13 -> ADDRFP (): ...
2154             cost__ = 0 + 1;
2155             if (cost__ < _state_rec->cost[4])
2156             {   _state_rec->cost[4] = cost__;
2157                 _state_rec->rule._stk13 = 2;
2158                _s_p_a_r_cco_X1_stk13_closure(redex, cost__);
2159             }
2160             // stk -> ADDRFP () \ 2: ...
2161             cost__ = 2 + 1;
2162             if (cost__ < _state_rec->cost[5])
2163             {   _state_rec->cost[5] = cost__;
2164                 _state_rec->rule._stk = 2;
2165                _s_p_a_r_cco_X1_stk_closure(redex, cost__);
2166             }
2167             // reg -> ADDRFP () \ 3: ...
2168             cost__ = 3 + 1;
2169             if (cost__ < _state_rec->cost[1])
2170             {   _state_rec->cost[1] = cost__;
2171                 _state_rec->rule._reg = 83;
2172                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2173             }} break;
2174          case a_Inst::tag_ADDRGP: {
2175             // reg -> ADDRGP (): ...
2176             cost__ = 0 + 1;
2177             if (cost__ < _state_rec->cost[1])
2178             {   _state_rec->cost[1] = cost__;
2179                 _state_rec->rule._reg = 85;
2180                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2181             }
2182             // addrg -> ADDRGP (): ...
2183             cost__ = 0 + 1;
2184             if (cost__ < _state_rec->cost[13])
2185             {   _state_rec->cost[13] = cost__;
2186                 _state_rec->rule._addrg = 1;
2187             }
2188             // call -> ADDRGP (): ...
2189             cost__ = 0 + 1;
2190             if (cost__ < _state_rec->cost[14])
2191             {   _state_rec->cost[14] = cost__;
2192                 _state_rec->rule._call = 2;
2193             }} break;
2194          case a_Inst::tag_ADDRLP: {
2195             // stk13 -> ADDRLP (): ...
2196             cost__ = 0 + 1;
2197             if (cost__ < _state_rec->cost[4])
2198             {   _state_rec->cost[4] = cost__;
2199                 _state_rec->rule._stk13 = 1;
2200                _s_p_a_r_cco_X1_stk13_closure(redex, cost__);
2201             }
2202             // stk -> ADDRLP () \ 2: ...
2203             cost__ = 2 + 1;
2204             if (cost__ < _state_rec->cost[5])
2205             {   _state_rec->cost[5] = cost__;
2206                 _state_rec->rule._stk = 1;
2207                _s_p_a_r_cco_X1_stk_closure(redex, cost__);
2208             }
2209             // reg -> ADDRLP () \ 3: ...
2210             cost__ = 3 + 1;
2211             if (cost__ < _state_rec->cost[1])
2212             {   _state_rec->cost[1] = cost__;
2213                 _state_rec->rule._reg = 82;
2214                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2215             }
2216             // addrl -> ADDRLP () \ imm(redex): ...
2217             int _X2 = imm(redex);
2218             cost__ = _X2 + 1;
2219             if (cost__ < _state_rec->cost[9])
2220             {   _state_rec->cost[9] = cost__;
2221                 _state_rec->rule._addrl = 1;
2222             }
2223             // spill -> ADDRLP () \ (! imm(redex)): ...
2224             int _X3 = (! imm(redex));
2225             cost__ = _X3 + 1;
2226             if (cost__ < _state_rec->cost[10])
2227             {   _state_rec->cost[10] = cost__;
2228                 _state_rec->rule._spill = 1;
2229             }} break;
2230          case a_Inst::tag_ARGB: {
2231             labeler(_ARGB(redex)->ARGB);} break;
2232          case a_Inst::tag_ARGD: {
2233             labeler(_ARGD(redex)->ARGD);
2234             // stmt -> ARGD reg \ 1: ...
2235             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ARGD(redex)->ARGD->get_state_rec())->cost[2] + 1);
2236             if (cost__ < _state_rec->cost[2])
2237             {   _state_rec->cost[2] = cost__;
2238                 _state_rec->rule._stmt = 4;
2239             }} break;
2240          case a_Inst::tag_ARGF: {
2241             labeler(_ARGF(redex)->ARGF);
2242             // stmt -> ARGF reg \ 1: ...
2243             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ARGF(redex)->ARGF->get_state_rec())->cost[2] + 1);
2244             if (cost__ < _state_rec->cost[2])
2245             {   _state_rec->cost[2] = cost__;
2246                 _state_rec->rule._stmt = 3;
2247             }} break;
2248          case a_Inst::tag_ARGI: {
2249             labeler(_ARGI(redex)->ARGI);
2250             // stmt -> ARGI reg \ 1: ...
2251             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ARGI(redex)->ARGI->get_state_rec())->cost[2] + 1);
2252             if (cost__ < _state_rec->cost[2])
2253             {   _state_rec->cost[2] = cost__;
2254                 _state_rec->rule._stmt = 6;
2255             }} break;
2256          case a_Inst::tag_ARGP: {
2257             labeler(_ARGP(redex)->ARGP);
2258             // stmt -> ARGP reg \ 1: ...
2259             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ARGP(redex)->ARGP->get_state_rec())->cost[2] + 1);
2260             if (cost__ < _state_rec->cost[2])
2261             {   _state_rec->cost[2] = cost__;
2262                 _state_rec->rule._stmt = 5;
2263             }} break;
2264          case a_Inst::tag_ASGNB: {
2265             labeler(_ASGNB(redex)->_1);
2266             labeler(_ASGNB(redex)->_2);
2267             switch (_ASGNB(redex)->_2->untag()) {
2268                case a_Inst::tag_INDIRB: {
2269                   // stmt -> ASGNB (reg, INDIRB reg): ...
2270                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNB(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_INDIRB(_ASGNB(redex)->_2)->INDIRB->get_state_rec())->cost[2] + 1));
2271                   if (cost__ < _state_rec->cost[2])
2272                   {   _state_rec->cost[2] = cost__;
2273                       _state_rec->rule._stmt = 1;
2274                   }} break;
2275                default: {} break;
2276             }
2277             } break;
2278          case a_Inst::tag_ASGNC: {
2279             labeler(_ASGNC(redex)->_1);
2280             labeler(_ASGNC(redex)->_2);
2281             switch (_ASGNC(redex)->_1->untag()) {
2282                case a_Inst::tag_VREGP: {
2283                   // stmt -> ASGNC (VREGP (), reg): ...
2284                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNC(redex)->_2->get_state_rec())->cost[2] + 1);
2285                   if (cost__ < _state_rec->cost[2])
2286                   {   _state_rec->cost[2] = cost__;
2287                       _state_rec->rule._stmt = 44;
2288                   }} break;
2289                default: {} break;
2290             }
2291             // stmt -> ASGNC (addr, reg) \ 1: ...
2292             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNC(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNC(redex)->_2->get_state_rec())->cost[2] + 1));
2293             if (cost__ < _state_rec->cost[2])
2294             {   _state_rec->cost[2] = cost__;
2295                 _state_rec->rule._stmt = 37;
2296             }
2297             // stmt -> ASGNC (spill, reg): ...
2298             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNC(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNC(redex)->_2->get_state_rec())->cost[2] + 1));
2299             if (cost__ < _state_rec->cost[2])
2300             {   _state_rec->cost[2] = cost__;
2301                 _state_rec->rule._stmt = 30;
2302             }} break;
2303          case a_Inst::tag_ASGND: {
2304             labeler(_ASGND(redex)->_1);
2305             labeler(_ASGND(redex)->_2);
2306             switch (_ASGND(redex)->_1->untag()) {
2307                case a_Inst::tag_VREGP: {
2308                   // stmt -> ASGND (VREGP (), reg): ...
2309                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_2->get_state_rec())->cost[2] + 1);
2310                   if (cost__ < _state_rec->cost[2])
2311                   {   _state_rec->cost[2] = cost__;
2312                       _state_rec->rule._stmt = 43;
2313                   }} break;
2314                default: {} break;
2315             }
2316             // stmt -> ASGND (addrl, reg) \ 1: ...
2317             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_2->get_state_rec())->cost[2] + 1));
2318             if (cost__ < _state_rec->cost[2])
2319             {   _state_rec->cost[2] = cost__;
2320                 _state_rec->rule._stmt = 32;
2321             }
2322             // stmt -> ASGND (base, reg) \ 2: ...
2323             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_2->get_state_rec())->cost[2] + 1));
2324             if (cost__ < _state_rec->cost[2])
2325             {   _state_rec->cost[2] = cost__;
2326                 _state_rec->rule._stmt = 31;
2327             }
2328             // stmt -> ASGND (spill, reg): ...
2329             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGND(redex)->_2->get_state_rec())->cost[2] + 1));
2330             if (cost__ < _state_rec->cost[2])
2331             {   _state_rec->cost[2] = cost__;
2332                 _state_rec->rule._stmt = 25;
2333             }} break;
2334          case a_Inst::tag_ASGNF: {
2335             labeler(_ASGNF(redex)->_1);
2336             labeler(_ASGNF(redex)->_2);
2337             switch (_ASGNF(redex)->_1->untag()) {
2338                case a_Inst::tag_VREGP: {
2339                   // stmt -> ASGNF (VREGP (), reg): ...
2340                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNF(redex)->_2->get_state_rec())->cost[2] + 1);
2341                   if (cost__ < _state_rec->cost[2])
2342                   {   _state_rec->cost[2] = cost__;
2343                       _state_rec->rule._stmt = 42;
2344                   }} break;
2345                default: {} break;
2346             }
2347             // stmt -> ASGNF (addr, reg) \ 1: ...
2348             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNF(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNF(redex)->_2->get_state_rec())->cost[2] + 1));
2349             if (cost__ < _state_rec->cost[2])
2350             {   _state_rec->cost[2] = cost__;
2351                 _state_rec->rule._stmt = 33;
2352             }
2353             // stmt -> ASGNF (spill, reg): ...
2354             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNF(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNF(redex)->_2->get_state_rec())->cost[2] + 1));
2355             if (cost__ < _state_rec->cost[2])
2356             {   _state_rec->cost[2] = cost__;
2357                 _state_rec->rule._stmt = 26;
2358             }} break;
2359          case a_Inst::tag_ASGNI: {
2360             labeler(_ASGNI(redex)->_1);
2361             labeler(_ASGNI(redex)->_2);
2362             switch (_ASGNI(redex)->_1->untag()) {
2363                case a_Inst::tag_VREGP: {
2364                   // stmt -> ASGNI (VREGP (), reg): ...
2365                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNI(redex)->_2->get_state_rec())->cost[2] + 1);
2366                   if (cost__ < _state_rec->cost[2])
2367                   {   _state_rec->cost[2] = cost__;
2368                       _state_rec->rule._stmt = 41;
2369                   }} break;
2370                default: {} break;
2371             }
2372             // stmt -> ASGNI (addr, reg) \ 1: ...
2373             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNI(redex)->_2->get_state_rec())->cost[2] + 1));
2374             if (cost__ < _state_rec->cost[2])
2375             {   _state_rec->cost[2] = cost__;
2376                 _state_rec->rule._stmt = 35;
2377             }
2378             // stmt -> ASGNI (spill, reg): ...
2379             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNI(redex)->_2->get_state_rec())->cost[2] + 1));
2380             if (cost__ < _state_rec->cost[2])
2381             {   _state_rec->cost[2] = cost__;
2382                 _state_rec->rule._stmt = 28;
2383             }} break;
2384          case a_Inst::tag_ASGNP: {
2385             labeler(_ASGNP(redex)->_1);
2386             labeler(_ASGNP(redex)->_2);
2387             switch (_ASGNP(redex)->_1->untag()) {
2388                case a_Inst::tag_VREGP: {
2389                   // stmt -> ASGNP (VREGP (), reg): ...
2390                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNP(redex)->_2->get_state_rec())->cost[2] + 1);
2391                   if (cost__ < _state_rec->cost[2])
2392                   {   _state_rec->cost[2] = cost__;
2393                       _state_rec->rule._stmt = 40;
2394                   }} break;
2395                default: {} break;
2396             }
2397             // stmt -> ASGNP (addr, reg) \ 1: ...
2398             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNP(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNP(redex)->_2->get_state_rec())->cost[2] + 1));
2399             if (cost__ < _state_rec->cost[2])
2400             {   _state_rec->cost[2] = cost__;
2401                 _state_rec->rule._stmt = 34;
2402             }
2403             // stmt -> ASGNP (spill, reg): ...
2404             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNP(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNP(redex)->_2->get_state_rec())->cost[2] + 1));
2405             if (cost__ < _state_rec->cost[2])
2406             {   _state_rec->cost[2] = cost__;
2407                 _state_rec->rule._stmt = 27;
2408             }} break;
2409          case a_Inst::tag_ASGNS: {
2410             labeler(_ASGNS(redex)->_1);
2411             labeler(_ASGNS(redex)->_2);
2412             switch (_ASGNS(redex)->_1->untag()) {
2413                case a_Inst::tag_VREGP: {
2414                   // stmt -> ASGNS (VREGP (), reg): ...
2415                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNS(redex)->_2->get_state_rec())->cost[2] + 1);
2416                   if (cost__ < _state_rec->cost[2])
2417                   {   _state_rec->cost[2] = cost__;
2418                       _state_rec->rule._stmt = 39;
2419                   }} break;
2420                default: {} break;
2421             }
2422             // stmt -> ASGNS (addr, reg) \ 1: ...
2423             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNS(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNS(redex)->_2->get_state_rec())->cost[2] + 1));
2424             if (cost__ < _state_rec->cost[2])
2425             {   _state_rec->cost[2] = cost__;
2426                 _state_rec->rule._stmt = 36;
2427             }
2428             // stmt -> ASGNS (spill, reg): ...
2429             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_ASGNS(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_ASGNS(redex)->_2->get_state_rec())->cost[2] + 1));
2430             if (cost__ < _state_rec->cost[2])
2431             {   _state_rec->cost[2] = cost__;
2432                 _state_rec->rule._stmt = 29;
2433             }} break;
2434          case a_Inst::tag_BANDU: {
2435             labeler(_BANDU(redex)->_1);
2436             labeler(_BANDU(redex)->_2);
2437             switch (_BANDU(redex)->_2->untag()) {
2438                case a_Inst::tag_BCOMU: {
2439                   // reg -> BANDU (reg, BCOMU rc) \ 1: ...
2440                   cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BANDU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BCOMU(_BANDU(redex)->_2)->BCOMU->get_state_rec())->cost[1] + 1));
2441                   if (cost__ < _state_rec->cost[1])
2442                   {   _state_rec->cost[1] = cost__;
2443                       _state_rec->rule._reg = 34;
2444                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2445                   }} break;
2446                default: {} break;
2447             }
2448             // reg -> BANDU (reg, rc) \ 1: ...
2449             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BANDU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BANDU(redex)->_2->get_state_rec())->cost[1] + 1));
2450             if (cost__ < _state_rec->cost[1])
2451             {   _state_rec->cost[1] = cost__;
2452                 _state_rec->rule._reg = 44;
2453                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2454             }} break;
2455          case a_Inst::tag_BCOMU: {
2456             labeler(_BCOMU(redex)->BCOMU);
2457             // reg -> BCOMU reg \ 1: ...
2458             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BCOMU(redex)->BCOMU->get_state_rec())->cost[1] + 1);
2459             if (cost__ < _state_rec->cost[1])
2460             {   _state_rec->cost[1] = cost__;
2461                 _state_rec->rule._reg = 30;
2462                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2463             }} break;
2464          case a_Inst::tag_BORU: {
2465             labeler(_BORU(redex)->_1);
2466             labeler(_BORU(redex)->_2);
2467             switch (_BORU(redex)->_2->untag()) {
2468                case a_Inst::tag_BCOMU: {
2469                   // reg -> BORU (reg, BCOMU rc) \ 1: ...
2470                   cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BORU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BCOMU(_BORU(redex)->_2)->BCOMU->get_state_rec())->cost[1] + 1));
2471                   if (cost__ < _state_rec->cost[1])
2472                   {   _state_rec->cost[1] = cost__;
2473                       _state_rec->rule._reg = 33;
2474                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2475                   }} break;
2476                default: {} break;
2477             }
2478             // reg -> BORU (reg, rc) \ 1: ...
2479             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BORU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BORU(redex)->_2->get_state_rec())->cost[1] + 1));
2480             if (cost__ < _state_rec->cost[1])
2481             {   _state_rec->cost[1] = cost__;
2482                 _state_rec->rule._reg = 43;
2483                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2484             }} break;
2485          case a_Inst::tag_BXORU: {
2486             labeler(_BXORU(redex)->_1);
2487             labeler(_BXORU(redex)->_2);
2488             switch (_BXORU(redex)->_2->untag()) {
2489                case a_Inst::tag_BCOMU: {
2490                   // reg -> BXORU (reg, BCOMU rc) \ 1: ...
2491                   cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BXORU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BCOMU(_BXORU(redex)->_2)->BCOMU->get_state_rec())->cost[1] + 1));
2492                   if (cost__ < _state_rec->cost[1])
2493                   {   _state_rec->cost[1] = cost__;
2494                       _state_rec->rule._reg = 32;
2495                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2496                   }} break;
2497                default: {} break;
2498             }
2499             // reg -> BXORU (reg, rc) \ 1: ...
2500             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_BXORU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_BXORU(redex)->_2->get_state_rec())->cost[1] + 1));
2501             if (cost__ < _state_rec->cost[1])
2502             {   _state_rec->cost[1] = cost__;
2503                 _state_rec->rule._reg = 42;
2504                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2505             }} break;
2506          case a_Inst::tag_CALLB: {
2507             labeler(_CALLB(redex)->_1);
2508             labeler(_CALLB(redex)->_2);
2509             // stmt -> CALLB (call, reg) \ 2: ...
2510             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CALLB(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_CALLB(redex)->_2->get_state_rec())->cost[2] + 1));
2511             if (cost__ < _state_rec->cost[2])
2512             {   _state_rec->cost[2] = cost__;
2513                 _state_rec->rule._stmt = 10;
2514             }} break;
2515          case a_Inst::tag_CALLD: {
2516             labeler(_CALLD(redex)->CALLD);
2517             // reg -> CALLD call \ 2: ...
2518             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CALLD(redex)->CALLD->get_state_rec())->cost[1] + 1);
2519             if (cost__ < _state_rec->cost[1])
2520             {   _state_rec->cost[1] = cost__;
2521                 _state_rec->rule._reg = 25;
2522                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2523             }} break;
2524          case a_Inst::tag_CALLF: {
2525             labeler(_CALLF(redex)->CALLF);
2526             // reg -> CALLF call \ 2: ...
2527             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CALLF(redex)->CALLF->get_state_rec())->cost[1] + 1);
2528             if (cost__ < _state_rec->cost[1])
2529             {   _state_rec->cost[1] = cost__;
2530                 _state_rec->rule._reg = 24;
2531                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2532             }} break;
2533          case a_Inst::tag_CALLI: {
2534             labeler(_CALLI(redex)->CALLI);
2535             // reg -> CALLI call \ 2: ...
2536             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CALLI(redex)->CALLI->get_state_rec())->cost[1] + 1);
2537             if (cost__ < _state_rec->cost[1])
2538             {   _state_rec->cost[1] = cost__;
2539                 _state_rec->rule._reg = 23;
2540                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2541             }} break;
2542          case a_Inst::tag_CALLV: {
2543             labeler(_CALLV(redex)->CALLV);
2544             // stmt -> CALLV call \ 2: ...
2545             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CALLV(redex)->CALLV->get_state_rec())->cost[2] + 1);
2546             if (cost__ < _state_rec->cost[2])
2547             {   _state_rec->cost[2] = cost__;
2548                 _state_rec->rule._stmt = 11;
2549             }} break;
2550          case a_Inst::tag_CNSTC: {
2551             // con -> CNSTC (): ...
2552             cost__ = 0 + 1;
2553             if (cost__ < _state_rec->cost[3])
2554             {   _state_rec->cost[3] = cost__;
2555                 _state_rec->rule._con = 5;
2556                _s_p_a_r_cco_X1_con_closure(redex, cost__);
2557             }
2558             // con13 -> CNSTC () \ imm(redex): ...
2559             int _X4 = imm(redex);
2560             cost__ = _X4 + 1;
2561             if (cost__ < _state_rec->cost[6])
2562             {   _state_rec->cost[6] = cost__;
2563                 _state_rec->rule._con13 = 5;
2564                _s_p_a_r_cco_X1_con13_closure(redex, cost__);
2565             }
2566             // reg -> CNSTC () \ range(redex,0,0): ...
2567             int _X5 = range(redex,0,0);
2568             cost__ = _X5 + 1;
2569             if (cost__ < _state_rec->cost[1])
2570             {   _state_rec->cost[1] = cost__;
2571                 _state_rec->rule._reg = 53;
2572                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2573             }} break;
2574          case a_Inst::tag_CNSTD: {} break;
2575          case a_Inst::tag_CNSTF: {} break;
2576          case a_Inst::tag_CNSTI: {
2577             // con -> CNSTI (): ...
2578             cost__ = 0 + 1;
2579             if (cost__ < _state_rec->cost[3])
2580             {   _state_rec->cost[3] = cost__;
2581                 _state_rec->rule._con = 4;
2582                _s_p_a_r_cco_X1_con_closure(redex, cost__);
2583             }
2584             // con13 -> CNSTI () \ imm(redex): ...
2585             int _X6 = imm(redex);
2586             cost__ = _X6 + 1;
2587             if (cost__ < _state_rec->cost[6])
2588             {   _state_rec->cost[6] = cost__;
2589                 _state_rec->rule._con13 = 4;
2590                _s_p_a_r_cco_X1_con13_closure(redex, cost__);
2591             }
2592             // reg -> CNSTI () \ range(redex,0,0): ...
2593             int _X7 = range(redex,0,0);
2594             cost__ = _X7 + 1;
2595             if (cost__ < _state_rec->cost[1])
2596             {   _state_rec->cost[1] = cost__;
2597                 _state_rec->rule._reg = 52;
2598                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2599             }
2600             // rc5 -> CNSTI () \ range(redex,0,31): ...
2601             int _X8 = range(redex,0,31);
2602             cost__ = _X8 + 1;
2603             if (cost__ < _state_rec->cost[12])
2604             {   _state_rec->cost[12] = cost__;
2605                 _state_rec->rule._rc5 = 2;
2606             }} break;
2607          case a_Inst::tag_CNSTP: {
2608             // con -> CNSTP (): ...
2609             cost__ = 0 + 1;
2610             if (cost__ < _state_rec->cost[3])
2611             {   _state_rec->cost[3] = cost__;
2612                 _state_rec->rule._con = 3;
2613                _s_p_a_r_cco_X1_con_closure(redex, cost__);
2614             }
2615             // con13 -> CNSTP () \ imm(redex): ...
2616             int _X9 = imm(redex);
2617             cost__ = _X9 + 1;
2618             if (cost__ < _state_rec->cost[6])
2619             {   _state_rec->cost[6] = cost__;
2620                 _state_rec->rule._con13 = 3;
2621                _s_p_a_r_cco_X1_con13_closure(redex, cost__);
2622             }
2623             // reg -> CNSTP () \ range(redex,0,0): ...
2624             int _X10 = range(redex,0,0);
2625             cost__ = _X10 + 1;
2626             if (cost__ < _state_rec->cost[1])
2627             {   _state_rec->cost[1] = cost__;
2628                 _state_rec->rule._reg = 51;
2629                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2630             }} break;
2631          case a_Inst::tag_CNSTS: {
2632             // con -> CNSTS (): ...
2633             cost__ = 0 + 1;
2634             if (cost__ < _state_rec->cost[3])
2635             {   _state_rec->cost[3] = cost__;
2636                 _state_rec->rule._con = 2;
2637                _s_p_a_r_cco_X1_con_closure(redex, cost__);
2638             }
2639             // con13 -> CNSTS () \ imm(redex): ...
2640             int _X11 = imm(redex);
2641             cost__ = _X11 + 1;
2642             if (cost__ < _state_rec->cost[6])
2643             {   _state_rec->cost[6] = cost__;
2644                 _state_rec->rule._con13 = 2;
2645                _s_p_a_r_cco_X1_con13_closure(redex, cost__);
2646             }
2647             // reg -> CNSTS () \ range(redex,0,0): ...
2648             int _X12 = range(redex,0,0);
2649             cost__ = _X12 + 1;
2650             if (cost__ < _state_rec->cost[1])
2651             {   _state_rec->cost[1] = cost__;
2652                 _state_rec->rule._reg = 50;
2653                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2654             }} break;
2655          case a_Inst::tag_CNSTU: {
2656             // con -> CNSTU (): ...
2657             cost__ = 0 + 1;
2658             if (cost__ < _state_rec->cost[3])
2659             {   _state_rec->cost[3] = cost__;
2660                 _state_rec->rule._con = 1;
2661                _s_p_a_r_cco_X1_con_closure(redex, cost__);
2662             }
2663             // con13 -> CNSTU () \ imm(redex): ...
2664             int _X13 = imm(redex);
2665             cost__ = _X13 + 1;
2666             if (cost__ < _state_rec->cost[6])
2667             {   _state_rec->cost[6] = cost__;
2668                 _state_rec->rule._con13 = 1;
2669                _s_p_a_r_cco_X1_con13_closure(redex, cost__);
2670             }
2671             // reg -> CNSTU () \ range(redex,0,0): ...
2672             int _X14 = range(redex,0,0);
2673             cost__ = _X14 + 1;
2674             if (cost__ < _state_rec->cost[1])
2675             {   _state_rec->cost[1] = cost__;
2676                 _state_rec->rule._reg = 49;
2677                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2678             }} break;
2679          case a_Inst::tag_CVCI: {
2680             labeler(_CVCI(redex)->CVCI);
2681             switch (_CVCI(redex)->CVCI->untag()) {
2682                case a_Inst::tag_INDIRC: {
2683                   // reg -> CVCI INDIRC addr: ...
2684                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRC(_CVCI(redex)->CVCI)->INDIRC->get_state_rec())->cost[1] + 1);
2685                   if (cost__ < _state_rec->cost[1])
2686                   {   _state_rec->cost[1] = cost__;
2687                       _state_rec->rule._reg = 74;
2688                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2689                   }} break;
2690                default: {} break;
2691             }
2692             // reg -> CVCI reg \ 2: ...
2693             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CVCI(redex)->CVCI->get_state_rec())->cost[1] + 1);
2694             if (cost__ < _state_rec->cost[1])
2695             {   _state_rec->cost[1] = cost__;
2696                 _state_rec->rule._reg = 29;
2697                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2698             }} break;
2699          case a_Inst::tag_CVCU: {
2700             labeler(_CVCU(redex)->CVCU);
2701             switch (_CVCU(redex)->CVCU->untag()) {
2702                case a_Inst::tag_INDIRC: {
2703                   // reg -> CVCU INDIRC addr: ...
2704                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRC(_CVCU(redex)->CVCU)->INDIRC->get_state_rec())->cost[1] + 1);
2705                   if (cost__ < _state_rec->cost[1])
2706                   {   _state_rec->cost[1] = cost__;
2707                       _state_rec->rule._reg = 72;
2708                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2709                   }} break;
2710                default: {} break;
2711             }
2712             // reg -> CVCU reg \ 1: ...
2713             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_CVCU(redex)->CVCU->get_state_rec())->cost[1] + 1);
2714             if (cost__ < _state_rec->cost[1])
2715             {   _state_rec->cost[1] = cost__;
2716                 _state_rec->rule._reg = 27;
2717                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2718             }} break;
2719          case a_Inst::tag_CVDF: {
2720             labeler(_CVDF(redex)->CVDF);
2721             // reg -> CVDF reg \ 1: ...
2722             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_CVDF(redex)->CVDF->get_state_rec())->cost[1] + 1);
2723             if (cost__ < _state_rec->cost[1])
2724             {   _state_rec->cost[1] = cost__;
2725                 _state_rec->rule._reg = 6;
2726                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2727             }} break;
2728          case a_Inst::tag_CVDI: {
2729             labeler(_CVDI(redex)->CVDI);
2730             // reg -> CVDI reg \ 3: ...
2731             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_CVDI(redex)->CVDI->get_state_rec())->cost[1] + 1);
2732             if (cost__ < _state_rec->cost[1])
2733             {   _state_rec->cost[1] = cost__;
2734                 _state_rec->rule._reg = 4;
2735                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2736             }} break;
2737          case a_Inst::tag_CVFD: {
2738             labeler(_CVFD(redex)->CVFD);
2739             // reg -> CVFD reg \ 1: ...
2740             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_CVFD(redex)->CVFD->get_state_rec())->cost[1] + 1);
2741             if (cost__ < _state_rec->cost[1])
2742             {   _state_rec->cost[1] = cost__;
2743                 _state_rec->rule._reg = 5;
2744                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2745             }} break;
2746          case a_Inst::tag_CVIC: {
2747             labeler(_CVIC(redex)->CVIC);
2748             // reg -> CVIC reg \ move(redex): ...
2749             int _X15 = move(redex);
2750             cost__ = _X15 + (((_s_p_a_r_cco_X1_StateRec *)_CVIC(redex)->CVIC->get_state_rec())->cost[1] + 1);
2751             if (cost__ < _state_rec->cost[1])
2752             {   _state_rec->cost[1] = cost__;
2753                 _state_rec->rule._reg = 70;
2754                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2755             }
2756             // reg -> CVIC reg \ notarget(redex): ...
2757             int _X16 = notarget(redex);
2758             cost__ = _X16 + (((_s_p_a_r_cco_X1_StateRec *)_CVIC(redex)->CVIC->get_state_rec())->cost[1] + 1);
2759             if (cost__ < _state_rec->cost[1])
2760             {   _state_rec->cost[1] = cost__;
2761                 _state_rec->rule._reg = 62;
2762                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2763             }} break;
2764          case a_Inst::tag_CVID: {
2765             labeler(_CVID(redex)->CVID);
2766             // reg -> CVID reg \ 3: ...
2767             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_CVID(redex)->CVID->get_state_rec())->cost[1] + 1);
2768             if (cost__ < _state_rec->cost[1])
2769             {   _state_rec->cost[1] = cost__;
2770                 _state_rec->rule._reg = 3;
2771                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2772             }} break;
2773          case a_Inst::tag_CVIS: {
2774             labeler(_CVIS(redex)->CVIS);
2775             // reg -> CVIS reg \ move(redex): ...
2776             int _X17 = move(redex);
2777             cost__ = _X17 + (((_s_p_a_r_cco_X1_StateRec *)_CVIS(redex)->CVIS->get_state_rec())->cost[1] + 1);
2778             if (cost__ < _state_rec->cost[1])
2779             {   _state_rec->cost[1] = cost__;
2780                 _state_rec->rule._reg = 69;
2781                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2782             }
2783             // reg -> CVIS reg \ notarget(redex): ...
2784             int _X18 = notarget(redex);
2785             cost__ = _X18 + (((_s_p_a_r_cco_X1_StateRec *)_CVIS(redex)->CVIS->get_state_rec())->cost[1] + 1);
2786             if (cost__ < _state_rec->cost[1])
2787             {   _state_rec->cost[1] = cost__;
2788                 _state_rec->rule._reg = 61;
2789                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2790             }} break;
2791          case a_Inst::tag_CVIU: {
2792             labeler(_CVIU(redex)->CVIU);
2793             // reg -> CVIU reg \ notarget(redex): ...
2794             int _X19 = notarget(redex);
2795             cost__ = _X19 + (((_s_p_a_r_cco_X1_StateRec *)_CVIU(redex)->CVIU->get_state_rec())->cost[1] + 1);
2796             if (cost__ < _state_rec->cost[1])
2797             {   _state_rec->cost[1] = cost__;
2798                 _state_rec->rule._reg = 89;
2799                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2800             }
2801             // reg -> CVIU reg \ move(redex): ...
2802             int _X20 = move(redex);
2803             cost__ = _X20 + (((_s_p_a_r_cco_X1_StateRec *)_CVIU(redex)->CVIU->get_state_rec())->cost[1] + 1);
2804             if (cost__ < _state_rec->cost[1])
2805             {   _state_rec->cost[1] = cost__;
2806                 _state_rec->rule._reg = 68;
2807                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2808             }} break;
2809          case a_Inst::tag_CVPU: {
2810             labeler(_CVPU(redex)->CVPU);
2811             // reg -> CVPU reg \ notarget(redex): ...
2812             int _X21 = notarget(redex);
2813             cost__ = _X21 + (((_s_p_a_r_cco_X1_StateRec *)_CVPU(redex)->CVPU->get_state_rec())->cost[1] + 1);
2814             if (cost__ < _state_rec->cost[1])
2815             {   _state_rec->cost[1] = cost__;
2816                 _state_rec->rule._reg = 88;
2817                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2818             }
2819             // reg -> CVPU reg \ move(redex): ...
2820             int _X22 = move(redex);
2821             cost__ = _X22 + (((_s_p_a_r_cco_X1_StateRec *)_CVPU(redex)->CVPU->get_state_rec())->cost[1] + 1);
2822             if (cost__ < _state_rec->cost[1])
2823             {   _state_rec->cost[1] = cost__;
2824                 _state_rec->rule._reg = 67;
2825                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2826             }} break;
2827          case a_Inst::tag_CVSI: {
2828             labeler(_CVSI(redex)->CVSI);
2829             switch (_CVSI(redex)->CVSI->untag()) {
2830                case a_Inst::tag_INDIRS: {
2831                   // reg -> CVSI INDIRS addr: ...
2832                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRS(_CVSI(redex)->CVSI)->INDIRS->get_state_rec())->cost[1] + 1);
2833                   if (cost__ < _state_rec->cost[1])
2834                   {   _state_rec->cost[1] = cost__;
2835                       _state_rec->rule._reg = 73;
2836                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2837                   }} break;
2838                default: {} break;
2839             }
2840             // reg -> CVSI reg \ 2: ...
2841             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CVSI(redex)->CVSI->get_state_rec())->cost[1] + 1);
2842             if (cost__ < _state_rec->cost[1])
2843             {   _state_rec->cost[1] = cost__;
2844                 _state_rec->rule._reg = 28;
2845                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2846             }} break;
2847          case a_Inst::tag_CVSU: {
2848             labeler(_CVSU(redex)->CVSU);
2849             switch (_CVSU(redex)->CVSU->untag()) {
2850                case a_Inst::tag_INDIRS: {
2851                   // reg -> CVSU INDIRS addr: ...
2852                   cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRS(_CVSU(redex)->CVSU)->INDIRS->get_state_rec())->cost[1] + 1);
2853                   if (cost__ < _state_rec->cost[1])
2854                   {   _state_rec->cost[1] = cost__;
2855                       _state_rec->rule._reg = 71;
2856                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2857                   }} break;
2858                default: {} break;
2859             }
2860             // reg -> CVSU reg \ 2: ...
2861             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_CVSU(redex)->CVSU->get_state_rec())->cost[1] + 1);
2862             if (cost__ < _state_rec->cost[1])
2863             {   _state_rec->cost[1] = cost__;
2864                 _state_rec->rule._reg = 26;
2865                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2866             }} break;
2867          case a_Inst::tag_CVUC: {
2868             labeler(_CVUC(redex)->CVUC);
2869             // reg -> CVUC reg \ move(redex): ...
2870             int _X23 = move(redex);
2871             cost__ = _X23 + (((_s_p_a_r_cco_X1_StateRec *)_CVUC(redex)->CVUC->get_state_rec())->cost[1] + 1);
2872             if (cost__ < _state_rec->cost[1])
2873             {   _state_rec->cost[1] = cost__;
2874                 _state_rec->rule._reg = 66;
2875                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2876             }
2877             // reg -> CVUC reg \ notarget(redex): ...
2878             int _X24 = notarget(redex);
2879             cost__ = _X24 + (((_s_p_a_r_cco_X1_StateRec *)_CVUC(redex)->CVUC->get_state_rec())->cost[1] + 1);
2880             if (cost__ < _state_rec->cost[1])
2881             {   _state_rec->cost[1] = cost__;
2882                 _state_rec->rule._reg = 60;
2883                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2884             }} break;
2885          case a_Inst::tag_CVUI: {
2886             labeler(_CVUI(redex)->CVUI);
2887             // reg -> CVUI reg \ notarget(redex): ...
2888             int _X25 = notarget(redex);
2889             cost__ = _X25 + (((_s_p_a_r_cco_X1_StateRec *)_CVUI(redex)->CVUI->get_state_rec())->cost[1] + 1);
2890             if (cost__ < _state_rec->cost[1])
2891             {   _state_rec->cost[1] = cost__;
2892                 _state_rec->rule._reg = 87;
2893                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2894             }
2895             // reg -> CVUI reg \ move(redex): ...
2896             int _X26 = move(redex);
2897             cost__ = _X26 + (((_s_p_a_r_cco_X1_StateRec *)_CVUI(redex)->CVUI->get_state_rec())->cost[1] + 1);
2898             if (cost__ < _state_rec->cost[1])
2899             {   _state_rec->cost[1] = cost__;
2900                 _state_rec->rule._reg = 65;
2901                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2902             }} break;
2903          case a_Inst::tag_CVUP: {
2904             labeler(_CVUP(redex)->CVUP);
2905             // reg -> CVUP reg \ notarget(redex): ...
2906             int _X27 = notarget(redex);
2907             cost__ = _X27 + (((_s_p_a_r_cco_X1_StateRec *)_CVUP(redex)->CVUP->get_state_rec())->cost[1] + 1);
2908             if (cost__ < _state_rec->cost[1])
2909             {   _state_rec->cost[1] = cost__;
2910                 _state_rec->rule._reg = 86;
2911                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2912             }
2913             // reg -> CVUP reg \ move(redex): ...
2914             int _X28 = move(redex);
2915             cost__ = _X28 + (((_s_p_a_r_cco_X1_StateRec *)_CVUP(redex)->CVUP->get_state_rec())->cost[1] + 1);
2916             if (cost__ < _state_rec->cost[1])
2917             {   _state_rec->cost[1] = cost__;
2918                 _state_rec->rule._reg = 64;
2919                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2920             }} break;
2921          case a_Inst::tag_CVUS: {
2922             labeler(_CVUS(redex)->CVUS);
2923             // reg -> CVUS reg \ move(redex): ...
2924             int _X29 = move(redex);
2925             cost__ = _X29 + (((_s_p_a_r_cco_X1_StateRec *)_CVUS(redex)->CVUS->get_state_rec())->cost[1] + 1);
2926             if (cost__ < _state_rec->cost[1])
2927             {   _state_rec->cost[1] = cost__;
2928                 _state_rec->rule._reg = 63;
2929                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2930             }
2931             // reg -> CVUS reg \ notarget(redex): ...
2932             int _X30 = notarget(redex);
2933             cost__ = _X30 + (((_s_p_a_r_cco_X1_StateRec *)_CVUS(redex)->CVUS->get_state_rec())->cost[1] + 1);
2934             if (cost__ < _state_rec->cost[1])
2935             {   _state_rec->cost[1] = cost__;
2936                 _state_rec->rule._reg = 59;
2937                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2938             }} break;
2939          case a_Inst::tag_DIVD: {
2940             labeler(_DIVD(redex)->_1);
2941             labeler(_DIVD(redex)->_2);
2942             // reg -> DIVD (reg, reg) \ 1: ...
2943             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_DIVD(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_DIVD(redex)->_2->get_state_rec())->cost[1] + 1));
2944             if (cost__ < _state_rec->cost[1])
2945             {   _state_rec->cost[1] = cost__;
2946                 _state_rec->rule._reg = 14;
2947                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2948             }} break;
2949          case a_Inst::tag_DIVF: {
2950             labeler(_DIVF(redex)->_1);
2951             labeler(_DIVF(redex)->_2);
2952             // reg -> DIVF (reg, reg) \ 1: ...
2953             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_DIVF(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_DIVF(redex)->_2->get_state_rec())->cost[1] + 1));
2954             if (cost__ < _state_rec->cost[1])
2955             {   _state_rec->cost[1] = cost__;
2956                 _state_rec->rule._reg = 13;
2957                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2958             }} break;
2959          case a_Inst::tag_DIVI: {
2960             labeler(_DIVI(redex)->_1);
2961             labeler(_DIVI(redex)->_2);
2962             // reg -> DIVI (reg, reg) \ 2: ...
2963             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_DIVI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_DIVI(redex)->_2->get_state_rec())->cost[1] + 1));
2964             if (cost__ < _state_rec->cost[1])
2965             {   _state_rec->cost[1] = cost__;
2966                 _state_rec->rule._reg = 22;
2967                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2968             }} break;
2969          case a_Inst::tag_DIVU: {
2970             labeler(_DIVU(redex)->_1);
2971             labeler(_DIVU(redex)->_2);
2972             // reg -> DIVU (reg, reg) \ 2: ...
2973             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_DIVU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_DIVU(redex)->_2->get_state_rec())->cost[1] + 1));
2974             if (cost__ < _state_rec->cost[1])
2975             {   _state_rec->cost[1] = cost__;
2976                 _state_rec->rule._reg = 21;
2977                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
2978             }} break;
2979          case a_Inst::tag_EQD: {
2980             labeler(_EQD(redex)->_1);
2981             labeler(_EQD(redex)->_2);
2982             // rel -> EQD (reg, reg): ...
2983             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_EQD(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_EQD(redex)->_2->get_state_rec())->cost[15] + 1));
2984             if (cost__ < _state_rec->cost[15])
2985             {   _state_rec->cost[15] = cost__;
2986                 _state_rec->rule._rel = 12;
2987                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
2988             }} break;
2989          case a_Inst::tag_EQF: {
2990             labeler(_EQF(redex)->_1);
2991             labeler(_EQF(redex)->_2);
2992             // rel -> EQF (reg, reg): ...
2993             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_EQF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_EQF(redex)->_2->get_state_rec())->cost[15] + 1));
2994             if (cost__ < _state_rec->cost[15])
2995             {   _state_rec->cost[15] = cost__;
2996                 _state_rec->rule._rel = 11;
2997                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
2998             }} break;
2999          case a_Inst::tag_EQI: {
3000             labeler(_EQI(redex)->_1);
3001             labeler(_EQI(redex)->_2);
3002             // stmt -> EQI (reg, rc) \ 3: ...
3003             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_EQI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_EQI(redex)->_2->get_state_rec())->cost[2] + 1));
3004             if (cost__ < _state_rec->cost[2])
3005             {   _state_rec->cost[2] = cost__;
3006                 _state_rec->rule._stmt = 21;
3007             }} break;
3008          case a_Inst::tag_GED: {
3009             labeler(_GED(redex)->_1);
3010             labeler(_GED(redex)->_2);
3011             // rel -> GED (reg, reg): ...
3012             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_GED(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_GED(redex)->_2->get_state_rec())->cost[15] + 1));
3013             if (cost__ < _state_rec->cost[15])
3014             {   _state_rec->cost[15] = cost__;
3015                 _state_rec->rule._rel = 10;
3016                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3017             }} break;
3018          case a_Inst::tag_GEF: {
3019             labeler(_GEF(redex)->_1);
3020             labeler(_GEF(redex)->_2);
3021             // rel -> GEF (reg, reg): ...
3022             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_GEF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_GEF(redex)->_2->get_state_rec())->cost[15] + 1));
3023             if (cost__ < _state_rec->cost[15])
3024             {   _state_rec->cost[15] = cost__;
3025                 _state_rec->rule._rel = 9;
3026                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3027             }} break;
3028          case a_Inst::tag_GEI: {
3029             labeler(_GEI(redex)->_1);
3030             labeler(_GEI(redex)->_2);
3031             // stmt -> GEI (reg, rc) \ 3: ...
3032             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_GEI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_GEI(redex)->_2->get_state_rec())->cost[2] + 1));
3033             if (cost__ < _state_rec->cost[2])
3034             {   _state_rec->cost[2] = cost__;
3035                 _state_rec->rule._stmt = 20;
3036             }} break;
3037          case a_Inst::tag_GEU: {
3038             labeler(_GEU(redex)->_1);
3039             labeler(_GEU(redex)->_2);
3040             // stmt -> GEU (reg, rc) \ 3: ...
3041             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_GEU(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_GEU(redex)->_2->get_state_rec())->cost[2] + 1));
3042             if (cost__ < _state_rec->cost[2])
3043             {   _state_rec->cost[2] = cost__;
3044                 _state_rec->rule._stmt = 19;
3045             }} break;
3046          case a_Inst::tag_GTD: {
3047             labeler(_GTD(redex)->_1);
3048             labeler(_GTD(redex)->_2);
3049             // rel -> GTD (reg, reg): ...
3050             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_GTD(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_GTD(redex)->_2->get_state_rec())->cost[15] + 1));
3051             if (cost__ < _state_rec->cost[15])
3052             {   _state_rec->cost[15] = cost__;
3053                 _state_rec->rule._rel = 8;
3054                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3055             }} break;
3056          case a_Inst::tag_GTF: {
3057             labeler(_GTF(redex)->_1);
3058             labeler(_GTF(redex)->_2);
3059             // rel -> GTF (reg, reg): ...
3060             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_GTF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_GTF(redex)->_2->get_state_rec())->cost[15] + 1));
3061             if (cost__ < _state_rec->cost[15])
3062             {   _state_rec->cost[15] = cost__;
3063                 _state_rec->rule._rel = 7;
3064                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3065             }} break;
3066          case a_Inst::tag_GTI: {
3067             labeler(_GTI(redex)->_1);
3068             labeler(_GTI(redex)->_2);
3069             // stmt -> GTI (reg, rc) \ 3: ...
3070             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_GTI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_GTI(redex)->_2->get_state_rec())->cost[2] + 1));
3071             if (cost__ < _state_rec->cost[2])
3072             {   _state_rec->cost[2] = cost__;
3073                 _state_rec->rule._stmt = 18;
3074             }} break;
3075          case a_Inst::tag_GTU: {
3076             labeler(_GTU(redex)->_1);
3077             labeler(_GTU(redex)->_2);
3078             // stmt -> GTU (reg, rc) \ 3: ...
3079             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_GTU(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_GTU(redex)->_2->get_state_rec())->cost[2] + 1));
3080             if (cost__ < _state_rec->cost[2])
3081             {   _state_rec->cost[2] = cost__;
3082                 _state_rec->rule._stmt = 17;
3083             }} break;
3084          case a_Inst::tag_INDIRB: {
3085             labeler(_INDIRB(redex)->INDIRB);} break;
3086          case a_Inst::tag_INDIRC: {
3087             labeler(_INDIRC(redex)->INDIRC);
3088             switch (_INDIRC(redex)->INDIRC->untag()) {
3089                case a_Inst::tag_VREGP: {
3090                   // reg -> INDIRC VREGP (): ...
3091                   cost__ = 0 + 1;
3092                   if (cost__ < _state_rec->cost[1])
3093                   {   _state_rec->cost[1] = cost__;
3094                       _state_rec->rule._reg = 95;
3095                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3096                   }} break;
3097                default: {} break;
3098             }
3099             // reg -> INDIRC addr \ 1: ...
3100             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRC(redex)->INDIRC->get_state_rec())->cost[1] + 1);
3101             if (cost__ < _state_rec->cost[1])
3102             {   _state_rec->cost[1] = cost__;
3103                 _state_rec->rule._reg = 81;
3104                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3105             }} break;
3106          case a_Inst::tag_INDIRD: {
3107             labeler(_INDIRD(redex)->INDIRD);
3108             switch (_INDIRD(redex)->INDIRD->untag()) {
3109                case a_Inst::tag_VREGP: {
3110                   // reg -> INDIRD VREGP (): ...
3111                   cost__ = 0 + 1;
3112                   if (cost__ < _state_rec->cost[1])
3113                   {   _state_rec->cost[1] = cost__;
3114                       _state_rec->rule._reg = 94;
3115                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3116                   }} break;
3117                default: {} break;
3118             }
3119             // reg -> INDIRD addrl \ 1: ...
3120             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRD(redex)->INDIRD->get_state_rec())->cost[1] + 1);
3121             if (cost__ < _state_rec->cost[1])
3122             {   _state_rec->cost[1] = cost__;
3123                 _state_rec->rule._reg = 76;
3124                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3125             }
3126             // reg -> INDIRD base \ 2: ...
3127             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRD(redex)->INDIRD->get_state_rec())->cost[1] + 1);
3128             if (cost__ < _state_rec->cost[1])
3129             {   _state_rec->cost[1] = cost__;
3130                 _state_rec->rule._reg = 75;
3131                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3132             }} break;
3133          case a_Inst::tag_INDIRF: {
3134             labeler(_INDIRF(redex)->INDIRF);
3135             switch (_INDIRF(redex)->INDIRF->untag()) {
3136                case a_Inst::tag_VREGP: {
3137                   // reg -> INDIRF VREGP (): ...
3138                   cost__ = 0 + 1;
3139                   if (cost__ < _state_rec->cost[1])
3140                   {   _state_rec->cost[1] = cost__;
3141                       _state_rec->rule._reg = 93;
3142                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3143                   }} break;
3144                default: {} break;
3145             }
3146             // reg -> INDIRF addr \ 1: ...
3147             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRF(redex)->INDIRF->get_state_rec())->cost[1] + 1);
3148             if (cost__ < _state_rec->cost[1])
3149             {   _state_rec->cost[1] = cost__;
3150                 _state_rec->rule._reg = 77;
3151                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3152             }} break;
3153          case a_Inst::tag_INDIRI: {
3154             labeler(_INDIRI(redex)->INDIRI);
3155             switch (_INDIRI(redex)->INDIRI->untag()) {
3156                case a_Inst::tag_VREGP: {
3157                   // reg -> INDIRI VREGP (): ...
3158                   cost__ = 0 + 1;
3159                   if (cost__ < _state_rec->cost[1])
3160                   {   _state_rec->cost[1] = cost__;
3161                       _state_rec->rule._reg = 92;
3162                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3163                   }} break;
3164                default: {} break;
3165             }
3166             // reg -> INDIRI addr \ 1: ...
3167             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRI(redex)->INDIRI->get_state_rec())->cost[1] + 1);
3168             if (cost__ < _state_rec->cost[1])
3169             {   _state_rec->cost[1] = cost__;
3170                 _state_rec->rule._reg = 79;
3171                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3172             }} break;
3173          case a_Inst::tag_INDIRP: {
3174             labeler(_INDIRP(redex)->INDIRP);
3175             switch (_INDIRP(redex)->INDIRP->untag()) {
3176                case a_Inst::tag_VREGP: {
3177                   // reg -> INDIRP VREGP (): ...
3178                   cost__ = 0 + 1;
3179                   if (cost__ < _state_rec->cost[1])
3180                   {   _state_rec->cost[1] = cost__;
3181                       _state_rec->rule._reg = 91;
3182                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3183                   }} break;
3184                default: {} break;
3185             }
3186             // reg -> INDIRP addr \ 1: ...
3187             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRP(redex)->INDIRP->get_state_rec())->cost[1] + 1);
3188             if (cost__ < _state_rec->cost[1])
3189             {   _state_rec->cost[1] = cost__;
3190                 _state_rec->rule._reg = 78;
3191                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3192             }} break;
3193          case a_Inst::tag_INDIRS: {
3194             labeler(_INDIRS(redex)->INDIRS);
3195             switch (_INDIRS(redex)->INDIRS->untag()) {
3196                case a_Inst::tag_VREGP: {
3197                   // reg -> INDIRS VREGP (): ...
3198                   cost__ = 0 + 1;
3199                   if (cost__ < _state_rec->cost[1])
3200                   {   _state_rec->cost[1] = cost__;
3201                       _state_rec->rule._reg = 90;
3202                      _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3203                   }} break;
3204                default: {} break;
3205             }
3206             // reg -> INDIRS addr \ 1: ...
3207             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_INDIRS(redex)->INDIRS->get_state_rec())->cost[1] + 1);
3208             if (cost__ < _state_rec->cost[1])
3209             {   _state_rec->cost[1] = cost__;
3210                 _state_rec->rule._reg = 80;
3211                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3212             }} break;
3213          case a_Inst::tag_JUMPV: {
3214             labeler(_JUMPV(redex)->JUMPV);
3215             // stmt -> JUMPV addrg \ 2: ...
3216             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_JUMPV(redex)->JUMPV->get_state_rec())->cost[2] + 1);
3217             if (cost__ < _state_rec->cost[2])
3218             {   _state_rec->cost[2] = cost__;
3219                 _state_rec->rule._stmt = 24;
3220             }
3221             // stmt -> JUMPV addr \ 2: ...
3222             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_JUMPV(redex)->JUMPV->get_state_rec())->cost[2] + 1);
3223             if (cost__ < _state_rec->cost[2])
3224             {   _state_rec->cost[2] = cost__;
3225                 _state_rec->rule._stmt = 23;
3226             }} break;
3227          case a_Inst::tag_LABELV: {
3228             // stmt -> LABELV (): ...
3229             cost__ = 0 + 1;
3230             if (cost__ < _state_rec->cost[2])
3231             {   _state_rec->cost[2] = cost__;
3232                 _state_rec->rule._stmt = 22;
3233             }} break;
3234          case a_Inst::tag_LED: {
3235             labeler(_LED(redex)->_1);
3236             labeler(_LED(redex)->_2);
3237             // rel -> LED (reg, reg): ...
3238             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_LED(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_LED(redex)->_2->get_state_rec())->cost[15] + 1));
3239             if (cost__ < _state_rec->cost[15])
3240             {   _state_rec->cost[15] = cost__;
3241                 _state_rec->rule._rel = 6;
3242                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3243             }} break;
3244          case a_Inst::tag_LEF: {
3245             labeler(_LEF(redex)->_1);
3246             labeler(_LEF(redex)->_2);
3247             // rel -> LEF (reg, reg): ...
3248             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_LEF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_LEF(redex)->_2->get_state_rec())->cost[15] + 1));
3249             if (cost__ < _state_rec->cost[15])
3250             {   _state_rec->cost[15] = cost__;
3251                 _state_rec->rule._rel = 5;
3252                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3253             }} break;
3254          case a_Inst::tag_LEI: {
3255             labeler(_LEI(redex)->_1);
3256             labeler(_LEI(redex)->_2);
3257             // stmt -> LEI (reg, rc) \ 3: ...
3258             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_LEI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_LEI(redex)->_2->get_state_rec())->cost[2] + 1));
3259             if (cost__ < _state_rec->cost[2])
3260             {   _state_rec->cost[2] = cost__;
3261                 _state_rec->rule._stmt = 16;
3262             }} break;
3263          case a_Inst::tag_LEU: {
3264             labeler(_LEU(redex)->_1);
3265             labeler(_LEU(redex)->_2);
3266             // stmt -> LEU (reg, rc) \ 3: ...
3267             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_LEU(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_LEU(redex)->_2->get_state_rec())->cost[2] + 1));
3268             if (cost__ < _state_rec->cost[2])
3269             {   _state_rec->cost[2] = cost__;
3270                 _state_rec->rule._stmt = 15;
3271             }} break;
3272          case a_Inst::tag_LOADB: {
3273             labeler(_LOADB(redex)->LOADB);} break;
3274          case a_Inst::tag_LOADC: {
3275             labeler(_LOADC(redex)->LOADC);
3276             // reg -> LOADC reg \ move(redex): ...
3277             int _X31 = move(redex);
3278             cost__ = _X31 + (((_s_p_a_r_cco_X1_StateRec *)_LOADC(redex)->LOADC->get_state_rec())->cost[1] + 1);
3279             if (cost__ < _state_rec->cost[1])
3280             {   _state_rec->cost[1] = cost__;
3281                 _state_rec->rule._reg = 58;
3282                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3283             }} break;
3284          case a_Inst::tag_LOADD: {
3285             labeler(_LOADD(redex)->LOADD);
3286             // reg -> LOADD reg \ 2: ...
3287             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_LOADD(redex)->LOADD->get_state_rec())->cost[1] + 1);
3288             if (cost__ < _state_rec->cost[1])
3289             {   _state_rec->cost[1] = cost__;
3290                 _state_rec->rule._reg = 2;
3291                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3292             }} break;
3293          case a_Inst::tag_LOADF: {
3294             labeler(_LOADF(redex)->LOADF);
3295             // reg -> LOADF reg \ 1: ...
3296             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_LOADF(redex)->LOADF->get_state_rec())->cost[1] + 1);
3297             if (cost__ < _state_rec->cost[1])
3298             {   _state_rec->cost[1] = cost__;
3299                 _state_rec->rule._reg = 7;
3300                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3301             }} break;
3302          case a_Inst::tag_LOADI: {
3303             labeler(_LOADI(redex)->LOADI);
3304             // reg -> LOADI reg \ move(redex): ...
3305             int _X32 = move(redex);
3306             cost__ = _X32 + (((_s_p_a_r_cco_X1_StateRec *)_LOADI(redex)->LOADI->get_state_rec())->cost[1] + 1);
3307             if (cost__ < _state_rec->cost[1])
3308             {   _state_rec->cost[1] = cost__;
3309                 _state_rec->rule._reg = 57;
3310                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3311             }} break;
3312          case a_Inst::tag_LOADP: {
3313             labeler(_LOADP(redex)->LOADP);
3314             // reg -> LOADP reg \ move(redex): ...
3315             int _X33 = move(redex);
3316             cost__ = _X33 + (((_s_p_a_r_cco_X1_StateRec *)_LOADP(redex)->LOADP->get_state_rec())->cost[1] + 1);
3317             if (cost__ < _state_rec->cost[1])
3318             {   _state_rec->cost[1] = cost__;
3319                 _state_rec->rule._reg = 56;
3320                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3321             }} break;
3322          case a_Inst::tag_LOADS: {
3323             labeler(_LOADS(redex)->LOADS);
3324             // reg -> LOADS reg \ move(redex): ...
3325             int _X34 = move(redex);
3326             cost__ = _X34 + (((_s_p_a_r_cco_X1_StateRec *)_LOADS(redex)->LOADS->get_state_rec())->cost[1] + 1);
3327             if (cost__ < _state_rec->cost[1])
3328             {   _state_rec->cost[1] = cost__;
3329                 _state_rec->rule._reg = 55;
3330                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3331             }} break;
3332          case a_Inst::tag_LOADU: {
3333             labeler(_LOADU(redex)->LOADU);
3334             // reg -> LOADU reg \ move(redex): ...
3335             int _X35 = move(redex);
3336             cost__ = _X35 + (((_s_p_a_r_cco_X1_StateRec *)_LOADU(redex)->LOADU->get_state_rec())->cost[1] + 1);
3337             if (cost__ < _state_rec->cost[1])
3338             {   _state_rec->cost[1] = cost__;
3339                 _state_rec->rule._reg = 54;
3340                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3341             }} break;
3342          case a_Inst::tag_LSHI: {
3343             labeler(_LSHI(redex)->_1);
3344             labeler(_LSHI(redex)->_2);
3345             // reg -> LSHI (reg, rc5) \ 1: ...
3346             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_LSHI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_LSHI(redex)->_2->get_state_rec())->cost[1] + 1));
3347             if (cost__ < _state_rec->cost[1])
3348             {   _state_rec->cost[1] = cost__;
3349                 _state_rec->rule._reg = 38;
3350                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3351             }} break;
3352          case a_Inst::tag_LSHU: {
3353             labeler(_LSHU(redex)->_1);
3354             labeler(_LSHU(redex)->_2);
3355             // reg -> LSHU (reg, rc5) \ 1: ...
3356             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_LSHU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_LSHU(redex)->_2->get_state_rec())->cost[1] + 1));
3357             if (cost__ < _state_rec->cost[1])
3358             {   _state_rec->cost[1] = cost__;
3359                 _state_rec->rule._reg = 37;
3360                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3361             }} break;
3362          case a_Inst::tag_LTD: {
3363             labeler(_LTD(redex)->_1);
3364             labeler(_LTD(redex)->_2);
3365             // rel -> LTD (reg, reg): ...
3366             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_LTD(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_LTD(redex)->_2->get_state_rec())->cost[15] + 1));
3367             if (cost__ < _state_rec->cost[15])
3368             {   _state_rec->cost[15] = cost__;
3369                 _state_rec->rule._rel = 4;
3370                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3371             }} break;
3372          case a_Inst::tag_LTF: {
3373             labeler(_LTF(redex)->_1);
3374             labeler(_LTF(redex)->_2);
3375             // rel -> LTF (reg, reg): ...
3376             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_LTF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_LTF(redex)->_2->get_state_rec())->cost[15] + 1));
3377             if (cost__ < _state_rec->cost[15])
3378             {   _state_rec->cost[15] = cost__;
3379                 _state_rec->rule._rel = 3;
3380                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3381             }} break;
3382          case a_Inst::tag_LTI: {
3383             labeler(_LTI(redex)->_1);
3384             labeler(_LTI(redex)->_2);
3385             // stmt -> LTI (reg, rc) \ 3: ...
3386             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_LTI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_LTI(redex)->_2->get_state_rec())->cost[2] + 1));
3387             if (cost__ < _state_rec->cost[2])
3388             {   _state_rec->cost[2] = cost__;
3389                 _state_rec->rule._stmt = 14;
3390             }} break;
3391          case a_Inst::tag_LTU: {
3392             labeler(_LTU(redex)->_1);
3393             labeler(_LTU(redex)->_2);
3394             // stmt -> LTU (reg, rc) \ 3: ...
3395             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_LTU(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_LTU(redex)->_2->get_state_rec())->cost[2] + 1));
3396             if (cost__ < _state_rec->cost[2])
3397             {   _state_rec->cost[2] = cost__;
3398                 _state_rec->rule._stmt = 13;
3399             }} break;
3400          case a_Inst::tag_MODI: {
3401             labeler(_MODI(redex)->_1);
3402             labeler(_MODI(redex)->_2);
3403             // reg -> MODI (reg, reg) \ 2: ...
3404             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_MODI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MODI(redex)->_2->get_state_rec())->cost[1] + 1));
3405             if (cost__ < _state_rec->cost[1])
3406             {   _state_rec->cost[1] = cost__;
3407                 _state_rec->rule._reg = 20;
3408                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3409             }} break;
3410          case a_Inst::tag_MODU: {
3411             labeler(_MODU(redex)->_1);
3412             labeler(_MODU(redex)->_2);
3413             // reg -> MODU (reg, reg) \ 2: ...
3414             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_MODU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MODU(redex)->_2->get_state_rec())->cost[1] + 1));
3415             if (cost__ < _state_rec->cost[1])
3416             {   _state_rec->cost[1] = cost__;
3417                 _state_rec->rule._reg = 19;
3418                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3419             }} break;
3420          case a_Inst::tag_MULD: {
3421             labeler(_MULD(redex)->_1);
3422             labeler(_MULD(redex)->_2);
3423             // reg -> MULD (reg, reg) \ 1: ...
3424             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_MULD(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MULD(redex)->_2->get_state_rec())->cost[1] + 1));
3425             if (cost__ < _state_rec->cost[1])
3426             {   _state_rec->cost[1] = cost__;
3427                 _state_rec->rule._reg = 12;
3428                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3429             }} break;
3430          case a_Inst::tag_MULF: {
3431             labeler(_MULF(redex)->_1);
3432             labeler(_MULF(redex)->_2);
3433             // reg -> MULF (reg, reg) \ 1: ...
3434             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_MULF(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MULF(redex)->_2->get_state_rec())->cost[1] + 1));
3435             if (cost__ < _state_rec->cost[1])
3436             {   _state_rec->cost[1] = cost__;
3437                 _state_rec->rule._reg = 11;
3438                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3439             }} break;
3440          case a_Inst::tag_MULI: {
3441             labeler(_MULI(redex)->_1);
3442             labeler(_MULI(redex)->_2);
3443             // reg -> MULI (reg, reg) \ 2: ...
3444             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_MULI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MULI(redex)->_2->get_state_rec())->cost[1] + 1));
3445             if (cost__ < _state_rec->cost[1])
3446             {   _state_rec->cost[1] = cost__;
3447                 _state_rec->rule._reg = 18;
3448                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3449             }} break;
3450          case a_Inst::tag_MULU: {
3451             labeler(_MULU(redex)->_1);
3452             labeler(_MULU(redex)->_2);
3453             // reg -> MULU (reg, reg) \ 2: ...
3454             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_MULU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_MULU(redex)->_2->get_state_rec())->cost[1] + 1));
3455             if (cost__ < _state_rec->cost[1])
3456             {   _state_rec->cost[1] = cost__;
3457                 _state_rec->rule._reg = 17;
3458                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3459             }} break;
3460          case a_Inst::tag_NED: {
3461             labeler(_NED(redex)->_1);
3462             labeler(_NED(redex)->_2);
3463             // rel -> NED (reg, reg): ...
3464             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_NED(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_NED(redex)->_2->get_state_rec())->cost[15] + 1));
3465             if (cost__ < _state_rec->cost[15])
3466             {   _state_rec->cost[15] = cost__;
3467                 _state_rec->rule._rel = 2;
3468                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3469             }} break;
3470          case a_Inst::tag_NEF: {
3471             labeler(_NEF(redex)->_1);
3472             labeler(_NEF(redex)->_2);
3473             // rel -> NEF (reg, reg): ...
3474             cost__ = 0 + (((_s_p_a_r_cco_X1_StateRec *)_NEF(redex)->_1->get_state_rec())->cost[15] + (((_s_p_a_r_cco_X1_StateRec *)_NEF(redex)->_2->get_state_rec())->cost[15] + 1));
3475             if (cost__ < _state_rec->cost[15])
3476             {   _state_rec->cost[15] = cost__;
3477                 _state_rec->rule._rel = 1;
3478                _s_p_a_r_cco_X1_rel_closure(redex, cost__);
3479             }} break;
3480          case a_Inst::tag_NEI: {
3481             labeler(_NEI(redex)->_1);
3482             labeler(_NEI(redex)->_2);
3483             // stmt -> NEI (reg, rc) \ 3: ...
3484             cost__ = 3 + (((_s_p_a_r_cco_X1_StateRec *)_NEI(redex)->_1->get_state_rec())->cost[2] + (((_s_p_a_r_cco_X1_StateRec *)_NEI(redex)->_2->get_state_rec())->cost[2] + 1));
3485             if (cost__ < _state_rec->cost[2])
3486             {   _state_rec->cost[2] = cost__;
3487                 _state_rec->rule._stmt = 12;
3488             }} break;
3489          case a_Inst::tag_NEGD: {
3490             labeler(_NEGD(redex)->NEGD);
3491             // reg -> NEGD reg \ 2: ...
3492             cost__ = 2 + (((_s_p_a_r_cco_X1_StateRec *)_NEGD(redex)->NEGD->get_state_rec())->cost[1] + 1);
3493             if (cost__ < _state_rec->cost[1])
3494             {   _state_rec->cost[1] = cost__;
3495                 _state_rec->rule._reg = 1;
3496                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3497             }} break;
3498          case a_Inst::tag_NEGF: {
3499             labeler(_NEGF(redex)->NEGF);
3500             // reg -> NEGF reg \ 1: ...
3501             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_NEGF(redex)->NEGF->get_state_rec())->cost[1] + 1);
3502             if (cost__ < _state_rec->cost[1])
3503             {   _state_rec->cost[1] = cost__;
3504                 _state_rec->rule._reg = 8;
3505                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3506             }} break;
3507          case a_Inst::tag_NEGI: {
3508             labeler(_NEGI(redex)->NEGI);
3509             // reg -> NEGI reg \ 1: ...
3510             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_NEGI(redex)->NEGI->get_state_rec())->cost[1] + 1);
3511             if (cost__ < _state_rec->cost[1])
3512             {   _state_rec->cost[1] = cost__;
3513                 _state_rec->rule._reg = 31;
3514                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3515             }} break;
3516          case a_Inst::tag_RETD: {
3517             labeler(_RETD(redex)->RETD);
3518             // stmt -> RETD reg \ 1: ...
3519             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_RETD(redex)->RETD->get_state_rec())->cost[2] + 1);
3520             if (cost__ < _state_rec->cost[2])
3521             {   _state_rec->cost[2] = cost__;
3522                 _state_rec->rule._stmt = 9;
3523             }} break;
3524          case a_Inst::tag_RETF: {
3525             labeler(_RETF(redex)->RETF);
3526             // stmt -> RETF reg \ 1: ...
3527             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_RETF(redex)->RETF->get_state_rec())->cost[2] + 1);
3528             if (cost__ < _state_rec->cost[2])
3529             {   _state_rec->cost[2] = cost__;
3530                 _state_rec->rule._stmt = 8;
3531             }} break;
3532          case a_Inst::tag_RETI: {
3533             labeler(_RETI(redex)->RETI);
3534             // stmt -> RETI reg \ 1: ...
3535             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_RETI(redex)->RETI->get_state_rec())->cost[2] + 1);
3536             if (cost__ < _state_rec->cost[2])
3537             {   _state_rec->cost[2] = cost__;
3538                 _state_rec->rule._stmt = 7;
3539             }} break;
3540          case a_Inst::tag_RSHI: {
3541             labeler(_RSHI(redex)->_1);
3542             labeler(_RSHI(redex)->_2);
3543             // reg -> RSHI (reg, rc5) \ 1: ...
3544             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_RSHI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_RSHI(redex)->_2->get_state_rec())->cost[1] + 1));
3545             if (cost__ < _state_rec->cost[1])
3546             {   _state_rec->cost[1] = cost__;
3547                 _state_rec->rule._reg = 36;
3548                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3549             }} break;
3550          case a_Inst::tag_RSHU: {
3551             labeler(_RSHU(redex)->_1);
3552             labeler(_RSHU(redex)->_2);
3553             // reg -> RSHU (reg, rc5) \ 1: ...
3554             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_RSHU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_RSHU(redex)->_2->get_state_rec())->cost[1] + 1));
3555             if (cost__ < _state_rec->cost[1])
3556             {   _state_rec->cost[1] = cost__;
3557                 _state_rec->rule._reg = 35;
3558                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3559             }} break;
3560          case a_Inst::tag_SUBD: {
3561             labeler(_SUBD(redex)->_1);
3562             labeler(_SUBD(redex)->_2);
3563             // reg -> SUBD (reg, reg) \ 1: ...
3564             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_SUBD(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_SUBD(redex)->_2->get_state_rec())->cost[1] + 1));
3565             if (cost__ < _state_rec->cost[1])
3566             {   _state_rec->cost[1] = cost__;
3567                 _state_rec->rule._reg = 10;
3568                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3569             }} break;
3570          case a_Inst::tag_SUBF: {
3571             labeler(_SUBF(redex)->_1);
3572             labeler(_SUBF(redex)->_2);
3573             // reg -> SUBF (reg, reg) \ 1: ...
3574             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_SUBF(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_SUBF(redex)->_2->get_state_rec())->cost[1] + 1));
3575             if (cost__ < _state_rec->cost[1])
3576             {   _state_rec->cost[1] = cost__;
3577                 _state_rec->rule._reg = 9;
3578                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3579             }} break;
3580          case a_Inst::tag_SUBI: {
3581             labeler(_SUBI(redex)->_1);
3582             labeler(_SUBI(redex)->_2);
3583             // reg -> SUBI (reg, rc) \ 1: ...
3584             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_SUBI(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_SUBI(redex)->_2->get_state_rec())->cost[1] + 1));
3585             if (cost__ < _state_rec->cost[1])
3586             {   _state_rec->cost[1] = cost__;
3587                 _state_rec->rule._reg = 41;
3588                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3589             }} break;
3590          case a_Inst::tag_SUBP: {
3591             labeler(_SUBP(redex)->_1);
3592             labeler(_SUBP(redex)->_2);
3593             // reg -> SUBP (reg, rc) \ 1: ...
3594             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_SUBP(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_SUBP(redex)->_2->get_state_rec())->cost[1] + 1));
3595             if (cost__ < _state_rec->cost[1])
3596             {   _state_rec->cost[1] = cost__;
3597                 _state_rec->rule._reg = 40;
3598                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3599             }} break;
3600          case a_Inst::tag_SUBU: {
3601             labeler(_SUBU(redex)->_1);
3602             labeler(_SUBU(redex)->_2);
3603             // reg -> SUBU (reg, rc) \ 1: ...
3604             cost__ = 1 + (((_s_p_a_r_cco_X1_StateRec *)_SUBU(redex)->_1->get_state_rec())->cost[1] + (((_s_p_a_r_cco_X1_StateRec *)_SUBU(redex)->_2->get_state_rec())->cost[1] + 1));
3605             if (cost__ < _state_rec->cost[1])
3606             {   _state_rec->cost[1] = cost__;
3607                 _state_rec->rule._reg = 39;
3608                _s_p_a_r_cco_X1_reg_closure(redex, cost__);
3609             }} break;
3610          default: {} break;
3611       }
3612    }
3613
3614 }
3615
3616 void _s_p_a_r_cco_X1::reduce(Inst redex,int lhs)
3617 {
3618    const _s_p_a_r_cco_X1_StateRec * _state_rec = (const _s_p_a_r_cco_X1_StateRec *)(redex->get_state_rec());
3619    int r__;
3620    switch (lhs) {
3621       case 7: r__ = _s_p_a_r_cco_X1_base_accept[_state_rec->rule._base]; break;
3622       case 14: r__ = _s_p_a_r_cco_X1_call_accept[_state_rec->rule._call]; break;
3623       case 12: r__ = _s_p_a_r_cco_X1_rc5_accept[_state_rec->rule._rc5]; break;
3624       case 11: r__ = _s_p_a_r_cco_X1_rc_accept[_state_rec->rule._rc]; break;
3625       case 13: r__ = _s_p_a_r_cco_X1_addrg_accept[_state_rec->rule._addrg]; break;
3626       case 9: r__ = _s_p_a_r_cco_X1_addrl_accept[_state_rec->rule._addrl]; break;
3627       case 4: r__ = _s_p_a_r_cco_X1_stk13_accept[_state_rec->rule._stk13]; break;
3628       case 8: r__ = _s_p_a_r_cco_X1_addr_accept[_state_rec->rule._addr]; break;
3629       case 6: r__ = _s_p_a_r_cco_X1_con13_accept[_state_rec->rule._con13]; break;
3630       case 2: r__ = _s_p_a_r_cco_X1_stmt_accept[_state_rec->rule._stmt]; break;
3631       case 3: r__ = _s_p_a_r_cco_X1_con_accept[_state_rec->rule._con]; break;
3632       case 1: r__ = _s_p_a_r_cco_X1_reg_accept[_state_rec->rule._reg]; break;
3633       case 10: r__ = _s_p_a_r_cco_X1_spill_accept[_state_rec->rule._spill]; break;
3634       case 15: r__ = _s_p_a_r_cco_X1_rel_accept[_state_rec->rule._rel]; break;
3635       case 5: r__ = _s_p_a_r_cco_X1_stk_accept[_state_rec->rule._stk]; break;
3636       default: r__ = -1; break;
3637    }
3638    switch (r__) {
3639       case 184: { // ASGNB (reg, INDIRB reg)
3640          reduce(_ASGNB(redex)->_1,2); // stmt
3641          reduce(_INDIRB(_ASGNB(redex)->_2)->INDIRB,2); // stmt
3642
3643 #line 230 "sparc.pC"
3644         "# ASGNB\n";
3645 #line 230 "sparc.pC"
3646 } break;
3647       case 183: { // NEGD reg
3648          reduce(_NEGD(redex)->NEGD,1); // reg
3649
3650 #line 229 "sparc.pC"
3651         "# NEGD\n";
3652 #line 229 "sparc.pC"
3653 } break;
3654       case 182: { // LOADD reg
3655          reduce(_LOADD(redex)->LOADD,1); // reg
3656
3657 #line 228 "sparc.pC"
3658         "# LOADD\n";
3659 #line 228 "sparc.pC"
3660 } break;
3661       case 181: { // rel
3662          reduce(redex,2); // stmt
3663
3664 #line 227 "sparc.pC"
3665         "%0 %a; nop\n";
3666 #line 227 "sparc.pC"
3667 } break;
3668       case 180: { // NEF (reg, reg)
3669          reduce(_NEF(redex)->_1,15); // rel
3670          reduce(_NEF(redex)->_2,15); // rel
3671
3672 #line 226 "sparc.pC"
3673         "fcmpes %%f%0,%%f%1; nop; fbne";
3674 #line 226 "sparc.pC"
3675 } break;
3676       case 179: { // NED (reg, reg)
3677          reduce(_NED(redex)->_1,15); // rel
3678          reduce(_NED(redex)->_2,15); // rel
3679
3680 #line 225 "sparc.pC"
3681         "fcmped %%f%0,%%f%1; nop; fbne";
3682 #line 225 "sparc.pC"
3683 } break;
3684       case 178: { // LTF (reg, reg)
3685          reduce(_LTF(redex)->_1,15); // rel
3686          reduce(_LTF(redex)->_2,15); // rel
3687
3688 #line 224 "sparc.pC"
3689         "fcmpes %%f%0,%%f%1; nop; fbul";
3690 #line 224 "sparc.pC"
3691 } break;
3692       case 177: { // LTD (reg, reg)
3693          reduce(_LTD(redex)->_1,15); // rel
3694          reduce(_LTD(redex)->_2,15); // rel
3695
3696 #line 223 "sparc.pC"
3697         "fcmped %%f%0,%%f%1; nop; fbul";
3698 #line 223 "sparc.pC"
3699 } break;
3700       case 176: { // LEF (reg, reg)
3701          reduce(_LEF(redex)->_1,15); // rel
3702          reduce(_LEF(redex)->_2,15); // rel
3703
3704 #line 222 "sparc.pC"
3705         "fcmpes %%f%0,%%f%1; nop; fbule";
3706 #line 222 "sparc.pC"
3707 } break;
3708       case 175: { // LED (reg, reg)
3709          reduce(_LED(redex)->_1,15); // rel
3710          reduce(_LED(redex)->_2,15); // rel
3711
3712 #line 221 "sparc.pC"
3713         "fcmped %%f%0,%%f%1; nop; fbule";
3714 #line 221 "sparc.pC"
3715 } break;
3716       case 174: { // GTF (reg, reg)
3717          reduce(_GTF(redex)->_1,15); // rel
3718          reduce(_GTF(redex)->_2,15); // rel
3719
3720 #line 220 "sparc.pC"
3721         "fcmpes %%f%0,%%f%1; nop; fbug";
3722 #line 220 "sparc.pC"
3723 } break;
3724       case 173: { // GTD (reg, reg)
3725          reduce(_GTD(redex)->_1,15); // rel
3726          reduce(_GTD(redex)->_2,15); // rel
3727
3728 #line 219 "sparc.pC"
3729         "fcmped %%f%0,%%f%1; nop; fbug";
3730 #line 219 "sparc.pC"
3731 } break;
3732       case 172: { // GEF (reg, reg)
3733          reduce(_GEF(redex)->_1,15); // rel
3734          reduce(_GEF(redex)->_2,15); // rel
3735
3736 #line 218 "sparc.pC"
3737         "fcmpes %%f%0,%%f%1; nop; fbuge";
3738 #line 218 "sparc.pC"
3739 } break;
3740       case 171: { // GED (reg, reg)
3741          reduce(_GED(redex)->_1,15); // rel
3742          reduce(_GED(redex)->_2,15); // rel
3743
3744 #line 217 "sparc.pC"
3745         "fcmped %%f%0,%%f%1; nop; fbuge";
3746 #line 217 "sparc.pC"
3747 } break;
3748       case 170: { // EQF (reg, reg)
3749          reduce(_EQF(redex)->_1,15); // rel
3750          reduce(_EQF(redex)->_2,15); // rel
3751
3752 #line 216 "sparc.pC"
3753         "fcmpes %%f%0,%%f%1; nop; fbue";
3754 #line 216 "sparc.pC"
3755 } break;
3756       case 169: { // EQD (reg, reg)
3757          reduce(_EQD(redex)->_1,15); // rel
3758          reduce(_EQD(redex)->_2,15); // rel
3759
3760 #line 215 "sparc.pC"
3761         "fcmped %%f%0,%%f%1; nop; fbue";
3762 #line 215 "sparc.pC"
3763 } break;
3764       case 168: { // CVID reg
3765          reduce(_CVID(redex)->CVID,1); // reg
3766
3767 #line 214 "sparc.pC"
3768         "st %%%0,[%%sp+64]; ld [%%sp+64],%%f%c; fitod %%f%c,%%f%c\n";
3769 #line 214 "sparc.pC"
3770 } break;
3771       case 167: { // CVDI reg
3772          reduce(_CVDI(redex)->CVDI,1); // reg
3773
3774 #line 213 "sparc.pC"
3775         "fdtoi %%f%0,%%f0; st %%f0,[%%sp+64]; ld [%%sp+64],%%%c\n";
3776 #line 213 "sparc.pC"
3777 } break;
3778       case 166: { // CVFD reg
3779          reduce(_CVFD(redex)->CVFD,1); // reg
3780
3781 #line 212 "sparc.pC"
3782         "fstod %%f%0,%%f%c\n";
3783 #line 212 "sparc.pC"
3784 } break;
3785       case 165: { // CVDF reg
3786          reduce(_CVDF(redex)->CVDF,1); // reg
3787
3788 #line 211 "sparc.pC"
3789         "fdtos %%f%0,%%f%c\n";
3790 #line 211 "sparc.pC"
3791 } break;
3792       case 164: { // LOADF reg
3793          reduce(_LOADF(redex)->LOADF,1); // reg
3794
3795 #line 210 "sparc.pC"
3796         "fmovs %%f%0,%%f%c\n";
3797 #line 210 "sparc.pC"
3798 } break;
3799       case 163: { // NEGF reg
3800          reduce(_NEGF(redex)->NEGF,1); // reg
3801
3802 #line 209 "sparc.pC"
3803         "fnegs %%f%0,%%f%c\n";
3804 #line 209 "sparc.pC"
3805 } break;
3806       case 162: { // SUBF (reg, reg)
3807          reduce(_SUBF(redex)->_1,1); // reg
3808          reduce(_SUBF(redex)->_2,1); // reg
3809
3810 #line 208 "sparc.pC"
3811         "fsubs %%f%0,%%f%1,%%f%c\n";
3812 #line 208 "sparc.pC"
3813 } break;
3814       case 161: { // SUBD (reg, reg)
3815          reduce(_SUBD(redex)->_1,1); // reg
3816          reduce(_SUBD(redex)->_2,1); // reg
3817
3818 #line 207 "sparc.pC"
3819         "fsubd %%f%0,%%f%1,%%f%c\n";
3820 #line 207 "sparc.pC"
3821 } break;
3822       case 160: { // MULF (reg, reg)
3823          reduce(_MULF(redex)->_1,1); // reg
3824          reduce(_MULF(redex)->_2,1); // reg
3825
3826 #line 206 "sparc.pC"
3827         "fmuls %%f%0,%%f%1,%%f%c\n";
3828 #line 206 "sparc.pC"
3829 } break;
3830       case 159: { // MULD (reg, reg)
3831          reduce(_MULD(redex)->_1,1); // reg
3832          reduce(_MULD(redex)->_2,1); // reg
3833
3834 #line 205 "sparc.pC"
3835         "fmuld %%f%0,%%f%1,%%f%c\n";
3836 #line 205 "sparc.pC"
3837 } break;
3838       case 158: { // DIVF (reg, reg)
3839          reduce(_DIVF(redex)->_1,1); // reg
3840          reduce(_DIVF(redex)->_2,1); // reg
3841
3842 #line 204 "sparc.pC"
3843         "fdivs %%f%0,%%f%1,%%f%c\n";
3844 #line 204 "sparc.pC"
3845 } break;
3846       case 157: { // DIVD (reg, reg)
3847          reduce(_DIVD(redex)->_1,1); // reg
3848          reduce(_DIVD(redex)->_2,1); // reg
3849
3850 #line 203 "sparc.pC"
3851         "fdivd %%f%0,%%f%1,%%f%c\n";
3852 #line 203 "sparc.pC"
3853 } break;
3854       case 156: { // ADDF (reg, reg)
3855          reduce(_ADDF(redex)->_1,1); // reg
3856          reduce(_ADDF(redex)->_2,1); // reg
3857
3858 #line 202 "sparc.pC"
3859         "fadds %%f%0,%%f%1,%%f%c\n";
3860 #line 202 "sparc.pC"
3861 } break;
3862       case 155: { // ADDD (reg, reg)
3863          reduce(_ADDD(redex)->_1,1); // reg
3864          reduce(_ADDD(redex)->_2,1); // reg
3865
3866 #line 201 "sparc.pC"
3867         "faddd %%f%0,%%f%1,%%f%c\n";
3868 #line 201 "sparc.pC"
3869 } break;
3870       case 154: { // MULU (reg, reg)
3871          reduce(_MULU(redex)->_1,1); // reg
3872          reduce(_MULU(redex)->_2,1); // reg
3873
3874 #line 200 "sparc.pC"
3875         "call .umul,2; nop\n";
3876 #line 200 "sparc.pC"
3877 } break;
3878       case 153: { // MULI (reg, reg)
3879          reduce(_MULI(redex)->_1,1); // reg
3880          reduce(_MULI(redex)->_2,1); // reg
3881
3882 #line 199 "sparc.pC"
3883         "call .mul,2; nop\n";
3884 #line 199 "sparc.pC"
3885 } break;
3886       case 152: { // MODU (reg, reg)
3887          reduce(_MODU(redex)->_1,1); // reg
3888          reduce(_MODU(redex)->_2,1); // reg
3889
3890 #line 198 "sparc.pC"
3891         "call .urem,2; nop\n";
3892 #line 198 "sparc.pC"
3893 } break;
3894       case 151: { // MODI (reg, reg)
3895          reduce(_MODI(redex)->_1,1); // reg
3896          reduce(_MODI(redex)->_2,1); // reg
3897
3898 #line 197 "sparc.pC"
3899         "call .rem,2; nop\n";
3900 #line 197 "sparc.pC"
3901 } break;
3902       case 150: { // DIVU (reg, reg)
3903          reduce(_DIVU(redex)->_1,1); // reg
3904          reduce(_DIVU(redex)->_2,1); // reg
3905
3906 #line 196 "sparc.pC"
3907         "call .udiv,2; nop\n";
3908 #line 196 "sparc.pC"
3909 } break;
3910       case 149: { // DIVI (reg, reg)
3911          reduce(_DIVI(redex)->_1,1); // reg
3912          reduce(_DIVI(redex)->_2,1); // reg
3913
3914 #line 195 "sparc.pC"
3915         "call .div,2; nop\n";
3916 #line 195 "sparc.pC"
3917 } break;
3918       case 148: { // ARGF reg
3919          reduce(_ARGF(redex)->ARGF,2); // stmt
3920
3921 #line 194 "sparc.pC"
3922         "# ARGF\n";
3923 #line 194 "sparc.pC"
3924 } break;
3925       case 147: { // ARGD reg
3926          reduce(_ARGD(redex)->ARGD,2); // stmt
3927
3928 #line 193 "sparc.pC"
3929         "# ARGD\n";
3930 #line 193 "sparc.pC"
3931 } break;
3932       case 146: { // ARGP reg
3933          reduce(_ARGP(redex)->ARGP,2); // stmt
3934
3935 #line 192 "sparc.pC"
3936         "st %%%0,[%%sp+4*%c+68]\n";
3937 #line 192 "sparc.pC"
3938 } break;
3939       case 145: { // ARGI reg
3940          reduce(_ARGI(redex)->ARGI,2); // stmt
3941
3942 #line 191 "sparc.pC"
3943         "st %%%0,[%%sp+4*%c+68]\n";
3944 #line 191 "sparc.pC"
3945 } break;
3946       case 144: { // RETI reg
3947          reduce(_RETI(redex)->RETI,2); // stmt
3948
3949 #line 190 "sparc.pC"
3950         "# ret\n";
3951 #line 190 "sparc.pC"
3952 } break;
3953       case 143: { // RETF reg
3954          reduce(_RETF(redex)->RETF,2); // stmt
3955
3956 #line 189 "sparc.pC"
3957         "# ret\n";
3958 #line 189 "sparc.pC"
3959 } break;
3960       case 142: { // RETD reg
3961          reduce(_RETD(redex)->RETD,2); // stmt
3962
3963 #line 188 "sparc.pC"
3964         "# ret\n";
3965 #line 188 "sparc.pC"
3966 } break;
3967       case 141: { // CALLB (call, reg)
3968          reduce(_CALLB(redex)->_1,2); // stmt
3969          reduce(_CALLB(redex)->_2,2); // stmt
3970
3971 #line 187 "sparc.pC"
3972         "call %0; st %%%1,[%%sp+64]\n";
3973 #line 187 "sparc.pC"
3974 } break;
3975       case 140: { // CALLV call
3976          reduce(_CALLV(redex)->CALLV,2); // stmt
3977
3978 #line 186 "sparc.pC"
3979         "call %0; nop\n";
3980 #line 186 "sparc.pC"
3981 } break;
3982       case 139: { // CALLI call
3983          reduce(_CALLI(redex)->CALLI,1); // reg
3984
3985 #line 185 "sparc.pC"
3986         "call %0; nop\n";
3987 #line 185 "sparc.pC"
3988 } break;
3989       case 138: { // CALLF call
3990          reduce(_CALLF(redex)->CALLF,1); // reg
3991
3992 #line 184 "sparc.pC"
3993         "call %0; nop\n";
3994 #line 184 "sparc.pC"
3995 } break;
3996       case 137: { // CALLD call
3997          reduce(_CALLD(redex)->CALLD,1); // reg
3998
3999 #line 183 "sparc.pC"
4000         "call %0; nop\n";
4001 #line 183 "sparc.pC"
4002 } break;
4003       case 136: { // addr
4004          reduce(redex,14); // call
4005
4006 #line 182 "sparc.pC"
4007         "%0";
4008 #line 182 "sparc.pC"
4009 } break;
4010       case 135: { // ADDRGP ()
4011
4012 #line 181 "sparc.pC"
4013         "%a";
4014 #line 181 "sparc.pC"
4015 } break;
4016       case 134: { // NEI (reg, rc)
4017          reduce(_NEI(redex)->_1,2); // stmt
4018          reduce(_NEI(redex)->_2,2); // stmt
4019
4020 #line 180 "sparc.pC"
4021         "cmp %%%0,%1; bne %a; nop\n";
4022 #line 180 "sparc.pC"
4023 } break;
4024       case 133: { // LTU (reg, rc)
4025          reduce(_LTU(redex)->_1,2); // stmt
4026          reduce(_LTU(redex)->_2,2); // stmt
4027
4028 #line 179 "sparc.pC"
4029         "cmp %%%0,%1; blu %a; nop\n";
4030 #line 179 "sparc.pC"
4031 } break;
4032       case 132: { // LTI (reg, rc)
4033          reduce(_LTI(redex)->_1,2); // stmt
4034          reduce(_LTI(redex)->_2,2); // stmt
4035
4036 #line 178 "sparc.pC"
4037         "cmp %%%0,%1; bl %a; nop\n";
4038 #line 178 "sparc.pC"
4039 } break;
4040       case 131: { // LEU (reg, rc)
4041          reduce(_LEU(redex)->_1,2); // stmt
4042          reduce(_LEU(redex)->_2,2); // stmt
4043
4044 #line 177 "sparc.pC"
4045         "cmp %%%0,%1; bleu %a; nop\n";
4046 #line 177 "sparc.pC"
4047 } break;
4048       case 130: { // LEI (reg, rc)
4049          reduce(_LEI(redex)->_1,2); // stmt
4050          reduce(_LEI(redex)->_2,2); // stmt
4051
4052 #line 176 "sparc.pC"
4053         "cmp %%%0,%1; ble %a; nop\n";
4054 #line 176 "sparc.pC"
4055 } break;
4056       case 129: { // GTU (reg, rc)
4057          reduce(_GTU(redex)->_1,2); // stmt
4058          reduce(_GTU(redex)->_2,2); // stmt
4059
4060 #line 175 "sparc.pC"
4061         "cmp %%%0,%1; bgu %a; nop\n";
4062 #line 175 "sparc.pC"
4063 } break;
4064       case 128: { // GTI (reg, rc)
4065          reduce(_GTI(redex)->_1,2); // stmt
4066          reduce(_GTI(redex)->_2,2); // stmt
4067
4068 #line 174 "sparc.pC"
4069         "cmp %%%0,%1; bg %a; nop\n";
4070 #line 174 "sparc.pC"
4071 } break;
4072       case 127: { // GEU (reg, rc)
4073          reduce(_GEU(redex)->_1,2); // stmt
4074          reduce(_GEU(redex)->_2,2); // stmt
4075
4076 #line 173 "sparc.pC"
4077         "cmp %%%0,%1; bgeu %a; nop\n";
4078 #line 173 "sparc.pC"
4079 } break;
4080       case 126: { // GEI (reg, rc)
4081          reduce(_GEI(redex)->_1,2); // stmt
4082          reduce(_GEI(redex)->_2,2); // stmt
4083
4084 #line 172 "sparc.pC"
4085         "cmp %%%0,%1; bge %a; nop\n";
4086 #line 172 "sparc.pC"
4087 } break;
4088       case 125: { // EQI (reg, rc)
4089          reduce(_EQI(redex)->_1,2); // stmt
4090          reduce(_EQI(redex)->_2,2); // stmt
4091
4092 #line 171 "sparc.pC"
4093         "cmp %%%0,%1; be %a; nop\n";
4094 #line 171 "sparc.pC"
4095 } break;
4096       case 124: { // LABELV ()
4097
4098 #line 170 "sparc.pC"
4099         "%a:\n";
4100 #line 170 "sparc.pC"
4101 } break;
4102       case 123: { // JUMPV addr
4103          reduce(_JUMPV(redex)->JUMPV,2); // stmt
4104
4105 #line 169 "sparc.pC"
4106         "jmp %0; nop\n";
4107 #line 169 "sparc.pC"
4108 } break;
4109       case 122: { // JUMPV addrg
4110          reduce(_JUMPV(redex)->JUMPV,2); // stmt
4111
4112 #line 168 "sparc.pC"
4113         "ba %0; nop\n";
4114 #line 168 "sparc.pC"
4115 } break;
4116       case 121: { // ADDRGP ()
4117
4118 #line 167 "sparc.pC"
4119         "%a";
4120 #line 167 "sparc.pC"
4121 } break;
4122       case 120: { // CVSU reg
4123          reduce(_CVSU(redex)->CVSU,1); // reg
4124
4125 #line 166 "sparc.pC"
4126         "set 0xffff,%%g1; and %%%0,%%g1,%%%c\n";
4127 #line 166 "sparc.pC"
4128 } break;
4129       case 119: { // CVCU reg
4130          reduce(_CVCU(redex)->CVCU,1); // reg
4131
4132 #line 165 "sparc.pC"
4133         "and %%%0,0xff,%%%c\n";
4134 #line 165 "sparc.pC"
4135 } break;
4136       case 118: { // CVSI reg
4137          reduce(_CVSI(redex)->CVSI,1); // reg
4138
4139 #line 164 "sparc.pC"
4140         "sll %%%0,16,%%%c; sra %%%c,16,%%%c\n";
4141 #line 164 "sparc.pC"
4142 } break;
4143       case 117: { // CVCI reg
4144          reduce(_CVCI(redex)->CVCI,1); // reg
4145
4146 #line 163 "sparc.pC"
4147         "sll %%%0,24,%%%c; sra %%%c,24,%%%c\n";
4148 #line 163 "sparc.pC"
4149 } break;
4150       case 116: { // BCOMU reg
4151          reduce(_BCOMU(redex)->BCOMU,1); // reg
4152
4153 #line 162 "sparc.pC"
4154         "not %%%0,%%%c\n";
4155 #line 162 "sparc.pC"
4156 } break;
4157       case 115: { // NEGI reg
4158          reduce(_NEGI(redex)->NEGI,1); // reg
4159
4160 #line 161 "sparc.pC"
4161         "neg %%%0,%%%c\n";
4162 #line 161 "sparc.pC"
4163 } break;
4164       case 114: { // BXORU (reg, BCOMU rc)
4165          reduce(_BXORU(redex)->_1,1); // reg
4166          reduce(_BCOMU(_BXORU(redex)->_2)->BCOMU,1); // reg
4167
4168 #line 160 "sparc.pC"
4169         "xnor %%%0,%1,%%%c\n";
4170 #line 160 "sparc.pC"
4171 } break;
4172       case 113: { // BORU (reg, BCOMU rc)
4173          reduce(_BORU(redex)->_1,1); // reg
4174          reduce(_BCOMU(_BORU(redex)->_2)->BCOMU,1); // reg
4175
4176 #line 159 "sparc.pC"
4177         "orn %%%0,%1,%%%c\n";
4178 #line 159 "sparc.pC"
4179 } break;
4180       case 112: { // BANDU (reg, BCOMU rc)
4181          reduce(_BANDU(redex)->_1,1); // reg
4182          reduce(_BCOMU(_BANDU(redex)->_2)->BCOMU,1); // reg
4183
4184 #line 158 "sparc.pC"
4185         "andn %%%0,%1,%%%c\n";
4186 #line 158 "sparc.pC"
4187 } break;
4188       case 111: { // RSHU (reg, rc5)
4189          reduce(_RSHU(redex)->_1,1); // reg
4190          reduce(_RSHU(redex)->_2,1); // reg
4191
4192 #line 157 "sparc.pC"
4193         "srl %%%0,%1,%%%c\n";
4194 #line 157 "sparc.pC"
4195 } break;
4196       case 110: { // RSHI (reg, rc5)
4197          reduce(_RSHI(redex)->_1,1); // reg
4198          reduce(_RSHI(redex)->_2,1); // reg
4199
4200 #line 156 "sparc.pC"
4201         "sra %%%0,%1,%%%c\n";
4202 #line 156 "sparc.pC"
4203 } break;
4204       case 109: { // LSHU (reg, rc5)
4205          reduce(_LSHU(redex)->_1,1); // reg
4206          reduce(_LSHU(redex)->_2,1); // reg
4207
4208 #line 155 "sparc.pC"
4209         "sll %%%0,%1,%%%c\n";
4210 #line 155 "sparc.pC"
4211 } break;
4212       case 108: { // LSHI (reg, rc5)
4213          reduce(_LSHI(redex)->_1,1); // reg
4214          reduce(_LSHI(redex)->_2,1); // reg
4215
4216 #line 154 "sparc.pC"
4217         "sll %%%0,%1,%%%c\n";
4218 #line 154 "sparc.pC"
4219 } break;
4220       case 107: { // reg
4221          reduce(redex,12); // rc5
4222
4223 #line 153 "sparc.pC"
4224         "%%%0";
4225 #line 153 "sparc.pC"
4226 } break;
4227       case 106: { // CNSTI ()
4228
4229 #line 152 "sparc.pC"
4230         "%a";
4231 #line 152 "sparc.pC"
4232 } break;
4233       case 105: { // SUBU (reg, rc)
4234          reduce(_SUBU(redex)->_1,1); // reg
4235          reduce(_SUBU(redex)->_2,1); // reg
4236
4237 #line 151 "sparc.pC"
4238         "sub %%%0,%1,%%%c\n";
4239 #line 151 "sparc.pC"
4240 } break;
4241       case 104: { // SUBP (reg, rc)
4242          reduce(_SUBP(redex)->_1,1); // reg
4243          reduce(_SUBP(redex)->_2,1); // reg
4244
4245 #line 150 "sparc.pC"
4246         "sub %%%0,%1,%%%c\n";
4247 #line 150 "sparc.pC"
4248 } break;
4249       case 103: { // SUBI (reg, rc)
4250          reduce(_SUBI(redex)->_1,1); // reg
4251          reduce(_SUBI(redex)->_2,1); // reg
4252
4253 #line 149 "sparc.pC"
4254         "sub %%%0,%1,%%%c\n";
4255 #line 149 "sparc.pC"
4256 } break;
4257       case 102: { // BXORU (reg, rc)
4258          reduce(_BXORU(redex)->_1,1); // reg
4259          reduce(_BXORU(redex)->_2,1); // reg
4260
4261 #line 148 "sparc.pC"
4262         "xor %%%0,%1,%%%c\n";
4263 #line 148 "sparc.pC"
4264 } break;
4265       case 101: { // BORU (reg, rc)
4266          reduce(_BORU(redex)->_1,1); // reg
4267          reduce(_BORU(redex)->_2,1); // reg
4268
4269 #line 147 "sparc.pC"
4270         "or %%%0,%1,%%%c\n" ;
4271 #line 147 "sparc.pC"
4272 } break;
4273       case 100: { // BANDU (reg, rc)
4274          reduce(_BANDU(redex)->_1,1); // reg
4275          reduce(_BANDU(redex)->_2,1); // reg
4276
4277 #line 146 "sparc.pC"
4278         "and %%%0,%1,%%%c\n";
4279 #line 146 "sparc.pC"
4280 } break;
4281       case 99: { // ADDU (reg, rc)
4282          reduce(_ADDU(redex)->_1,1); // reg
4283          reduce(_ADDU(redex)->_2,1); // reg
4284
4285 #line 145 "sparc.pC"
4286         "add %%%0,%1,%%%c\n";
4287 #line 145 "sparc.pC"
4288 } break;
4289       case 98: { // ADDP (reg, rc)
4290          reduce(_ADDP(redex)->_1,1); // reg
4291          reduce(_ADDP(redex)->_2,1); // reg
4292
4293 #line 144 "sparc.pC"
4294         "add %%%0,%1,%%%c\n";
4295 #line 144 "sparc.pC"
4296 } break;
4297       case 97: { // ADDI (reg, rc)
4298          reduce(_ADDI(redex)->_1,1); // reg
4299          reduce(_ADDI(redex)->_2,1); // reg
4300
4301 #line 143 "sparc.pC"
4302         "add %%%0,%1,%%%c\n";
4303 #line 143 "sparc.pC"
4304 } break;
4305       case 96: { // reg
4306          reduce(redex,11); // rc
4307
4308 #line 142 "sparc.pC"
4309         "%%%0";
4310 #line 142 "sparc.pC"
4311 } break;
4312       case 95: { // con13
4313          reduce(redex,11); // rc
4314
4315 #line 141 "sparc.pC"
4316         "%0";
4317 #line 141 "sparc.pC"
4318 } break;
4319       case 94: { // con
4320          reduce(redex,1); // reg
4321
4322 #line 140 "sparc.pC"
4323         "set %0,%%%c\n";
4324 #line 140 "sparc.pC"
4325 } break;
4326       case 93: { // CNSTU ()
4327
4328 #line 139 "sparc.pC"
4329         "# reg\n";
4330 #line 139 "sparc.pC"
4331 } break;
4332       case 92: { // CNSTS ()
4333
4334 #line 138 "sparc.pC"
4335         "# reg\n";
4336 #line 138 "sparc.pC"
4337 } break;
4338       case 91: { // CNSTP ()
4339
4340 #line 137 "sparc.pC"
4341         "# reg\n";
4342 #line 137 "sparc.pC"
4343 } break;
4344       case 90: { // CNSTI ()
4345
4346 #line 136 "sparc.pC"
4347         "# reg\n";
4348 #line 136 "sparc.pC"
4349 } break;
4350       case 89: { // CNSTC ()
4351
4352 #line 135 "sparc.pC"
4353         "# reg\n";
4354 #line 135 "sparc.pC"
4355 } break;
4356       case 88: { // LOADU reg
4357          reduce(_LOADU(redex)->LOADU,1); // reg
4358
4359 #line 134 "sparc.pC"
4360         "mov %%%0,%%%c\n";
4361 #line 134 "sparc.pC"
4362 } break;
4363       case 87: { // LOADS reg
4364          reduce(_LOADS(redex)->LOADS,1); // reg
4365
4366 #line 133 "sparc.pC"
4367         "mov %%%0,%%%c\n";
4368 #line 133 "sparc.pC"
4369 } break;
4370       case 86: { // LOADP reg
4371          reduce(_LOADP(redex)->LOADP,1); // reg
4372
4373 #line 132 "sparc.pC"
4374         "mov %%%0,%%%c\n";
4375 #line 132 "sparc.pC"
4376 } break;
4377       case 85: { // LOADI reg
4378          reduce(_LOADI(redex)->LOADI,1); // reg
4379
4380 #line 131 "sparc.pC"
4381         "mov %%%0,%%%c\n";
4382 #line 131 "sparc.pC"
4383 } break;
4384       case 84: { // LOADC reg
4385          reduce(_LOADC(redex)->LOADC,1); // reg
4386
4387 #line 130 "sparc.pC"
4388         "mov %%%0,%%%c\n";
4389 #line 130 "sparc.pC"
4390 } break;
4391       case 83: { // CVUS reg
4392          reduce(_CVUS(redex)->CVUS,1); // reg
4393
4394 #line 129 "sparc.pC"
4395         "%0";
4396 #line 129 "sparc.pC"
4397 } break;
4398       case 82: { // CVUC reg
4399          reduce(_CVUC(redex)->CVUC,1); // reg
4400
4401 #line 128 "sparc.pC"
4402         "%0";
4403 #line 128 "sparc.pC"
4404 } break;
4405       case 81: { // CVIS reg
4406          reduce(_CVIS(redex)->CVIS,1); // reg
4407
4408 #line 127 "sparc.pC"
4409         "%0";
4410 #line 127 "sparc.pC"
4411 } break;
4412       case 80: { // CVIC reg
4413          reduce(_CVIC(redex)->CVIC,1); // reg
4414
4415 #line 126 "sparc.pC"
4416         "%0";
4417 #line 126 "sparc.pC"
4418 } break;
4419       case 79: { // CVUS reg
4420          reduce(_CVUS(redex)->CVUS,1); // reg
4421
4422 #line 125 "sparc.pC"
4423         "mov %%%0,%%%c\n";
4424 #line 125 "sparc.pC"
4425 } break;
4426       case 78: { // CVUP reg
4427          reduce(_CVUP(redex)->CVUP,1); // reg
4428
4429 #line 124 "sparc.pC"
4430         "mov %%%0,%%%c\n";
4431 #line 124 "sparc.pC"
4432 } break;
4433       case 77: { // CVUI reg
4434          reduce(_CVUI(redex)->CVUI,1); // reg
4435
4436 #line 123 "sparc.pC"
4437         "mov %%%0,%%%c\n";
4438 #line 123 "sparc.pC"
4439 } break;
4440       case 76: { // CVUC reg
4441          reduce(_CVUC(redex)->CVUC,1); // reg
4442
4443 #line 122 "sparc.pC"
4444         "mov %%%0,%%%c\n";
4445 #line 122 "sparc.pC"
4446 } break;
4447       case 75: { // CVPU reg
4448          reduce(_CVPU(redex)->CVPU,1); // reg
4449
4450 #line 121 "sparc.pC"
4451         "mov %%%0,%%%c\n";
4452 #line 121 "sparc.pC"
4453 } break;
4454       case 74: { // CVIU reg
4455          reduce(_CVIU(redex)->CVIU,1); // reg
4456
4457 #line 120 "sparc.pC"
4458         "mov %%%0,%%%c\n";
4459 #line 120 "sparc.pC"
4460 } break;
4461       case 73: { // CVIS reg
4462          reduce(_CVIS(redex)->CVIS,1); // reg
4463
4464 #line 119 "sparc.pC"
4465         "mov %%%0,%%%c\n";
4466 #line 119 "sparc.pC"
4467 } break;
4468       case 72: { // CVIC reg
4469          reduce(_CVIC(redex)->CVIC,1); // reg
4470
4471 #line 118 "sparc.pC"
4472         "mov %%%0,%%%c\n";
4473 #line 118 "sparc.pC"
4474 } break;
4475       case 71: { // CVSU INDIRS addr
4476          reduce(_INDIRS(_CVSU(redex)->CVSU)->INDIRS,1); // reg
4477
4478 #line 117 "sparc.pC"
4479         "lduh [%0],%%%c\n";
4480 #line 117 "sparc.pC"
4481 } break;
4482       case 70: { // CVCU INDIRC addr
4483          reduce(_INDIRC(_CVCU(redex)->CVCU)->INDIRC,1); // reg
4484
4485 #line 116 "sparc.pC"
4486         "ldub [%0],%%%c\n";
4487 #line 116 "sparc.pC"
4488 } break;
4489       case 69: { // CVSI INDIRS addr
4490          reduce(_INDIRS(_CVSI(redex)->CVSI)->INDIRS,1); // reg
4491
4492 #line 115 "sparc.pC"
4493         "ldsh [%0],%%%c\n";
4494 #line 115 "sparc.pC"
4495 } break;
4496       case 68: { // CVCI INDIRC addr
4497          reduce(_INDIRC(_CVCI(redex)->CVCI)->INDIRC,1); // reg
4498
4499 #line 114 "sparc.pC"
4500         "ldsb [%0],%%%c\n";
4501 #line 114 "sparc.pC"
4502 } break;
4503       case 67: { // ASGND (spill, reg)
4504          reduce(_ASGND(redex)->_1,2); // stmt
4505          reduce(_ASGND(redex)->_2,2); // stmt
4506
4507 #line 113 "sparc.pC"
4508         "set %0,%%g1\nstd %%f%1,[%%fp+%%g1]\n";
4509 #line 113 "sparc.pC"
4510 } break;
4511       case 66: { // ASGNF (spill, reg)
4512          reduce(_ASGNF(redex)->_1,2); // stmt
4513          reduce(_ASGNF(redex)->_2,2); // stmt
4514
4515 #line 112 "sparc.pC"
4516         "set %0,%%g1\nst %%f%1,[%%fp+%%g1]\n";
4517 #line 112 "sparc.pC"
4518 } break;
4519       case 65: { // ASGNP (spill, reg)
4520          reduce(_ASGNP(redex)->_1,2); // stmt
4521          reduce(_ASGNP(redex)->_2,2); // stmt
4522
4523 #line 111 "sparc.pC"
4524         "set %0,%%g1\nst %%%1,[%%fp+%%g1]\n";
4525 #line 111 "sparc.pC"
4526 } break;
4527       case 64: { // ASGNI (spill, reg)
4528          reduce(_ASGNI(redex)->_1,2); // stmt
4529          reduce(_ASGNI(redex)->_2,2); // stmt
4530
4531 #line 110 "sparc.pC"
4532         "set %0,%%g1\nst %%%1,[%%fp+%%g1]\n";
4533 #line 110 "sparc.pC"
4534 } break;
4535       case 63: { // ASGNS (spill, reg)
4536          reduce(_ASGNS(redex)->_1,2); // stmt
4537          reduce(_ASGNS(redex)->_2,2); // stmt
4538
4539 #line 109 "sparc.pC"
4540         "set %0,%%g1\nsth %%%1,[%%fp+%%g1]\n";
4541 #line 109 "sparc.pC"
4542 } break;
4543       case 62: { // ASGNC (spill, reg)
4544          reduce(_ASGNC(redex)->_1,2); // stmt
4545          reduce(_ASGNC(redex)->_2,2); // stmt
4546
4547 #line 108 "sparc.pC"
4548         "set %0,%%g1\nstb %%%1,[%%fp+%%g1]\n";
4549 #line 108 "sparc.pC"
4550 } break;
4551       case 61: { // ADDRLP ()
4552
4553 #line 107 "sparc.pC"
4554         "%a";
4555 #line 107 "sparc.pC"
4556 } break;
4557       case 60: { // ASGND (base, reg)
4558          reduce(_ASGND(redex)->_1,2); // stmt
4559          reduce(_ASGND(redex)->_2,2); // stmt
4560
4561 #line 106 "sparc.pC"
4562         "st2 %%f%1,[%0]\n";
4563 #line 106 "sparc.pC"
4564 } break;
4565       case 59: { // INDIRD base
4566          reduce(_INDIRD(redex)->INDIRD,1); // reg
4567
4568 #line 105 "sparc.pC"
4569         "ld2 [%0],%%f%c\n";
4570 #line 105 "sparc.pC"
4571 } break;
4572       case 58: { // ASGND (addrl, reg)
4573          reduce(_ASGND(redex)->_1,2); // stmt
4574          reduce(_ASGND(redex)->_2,2); // stmt
4575
4576 #line 104 "sparc.pC"
4577         "std %%f%1,[%0]\n";
4578 #line 104 "sparc.pC"
4579 } break;
4580       case 57: { // INDIRD addrl
4581          reduce(_INDIRD(redex)->INDIRD,1); // reg
4582
4583 #line 103 "sparc.pC"
4584         "ldd [%0],%%f%c\n";
4585 #line 103 "sparc.pC"
4586 } break;
4587       case 56: { // ADDRLP ()
4588
4589 #line 102 "sparc.pC"
4590         "%%%fp+%a";
4591 #line 102 "sparc.pC"
4592 } break;
4593       case 55: { // ASGNF (addr, reg)
4594          reduce(_ASGNF(redex)->_1,2); // stmt
4595          reduce(_ASGNF(redex)->_2,2); // stmt
4596
4597 #line 101 "sparc.pC"
4598         "st %%f%1,[%0]\n";
4599 #line 101 "sparc.pC"
4600 } break;
4601       case 54: { // ASGNP (addr, reg)
4602          reduce(_ASGNP(redex)->_1,2); // stmt
4603          reduce(_ASGNP(redex)->_2,2); // stmt
4604
4605 #line 100 "sparc.pC"
4606         "st %%%1,[%0]\n";
4607 #line 100 "sparc.pC"
4608 } break;
4609       case 53: { // ASGNI (addr, reg)
4610          reduce(_ASGNI(redex)->_1,2); // stmt
4611          reduce(_ASGNI(redex)->_2,2); // stmt
4612
4613 #line 99 "sparc.pC"
4614         "st %%%1,[%0]\n";
4615 #line 99 "sparc.pC"
4616 } break;
4617       case 52: { // ASGNS (addr, reg)
4618          reduce(_ASGNS(redex)->_1,2); // stmt
4619          reduce(_ASGNS(redex)->_2,2); // stmt
4620
4621 #line 98 "sparc.pC"
4622         "sth %%%1,[%0]\n";
4623 #line 98 "sparc.pC"
4624 } break;
4625       case 51: { // ASGNC (addr, reg)
4626          reduce(_ASGNC(redex)->_1,2); // stmt
4627          reduce(_ASGNC(redex)->_2,2); // stmt
4628
4629 #line 97 "sparc.pC"
4630         "stb %%%1,[%0]\n";
4631 #line 97 "sparc.pC"
4632 } break;
4633       case 50: { // INDIRF addr
4634          reduce(_INDIRF(redex)->INDIRF,1); // reg
4635
4636 #line 96 "sparc.pC"
4637         "ld [%0],%%f%c\n";
4638 #line 96 "sparc.pC"
4639 } break;
4640       case 49: { // INDIRP addr
4641          reduce(_INDIRP(redex)->INDIRP,1); // reg
4642
4643 #line 95 "sparc.pC"
4644         "ld [%0],%%%c\n";
4645 #line 95 "sparc.pC"
4646 } break;
4647       case 48: { // INDIRI addr
4648          reduce(_INDIRI(redex)->INDIRI,1); // reg
4649
4650 #line 94 "sparc.pC"
4651         "ld [%0],%%%c\n";
4652 #line 94 "sparc.pC"
4653 } break;
4654       case 47: { // INDIRS addr
4655          reduce(_INDIRS(redex)->INDIRS,1); // reg
4656
4657 #line 93 "sparc.pC"
4658         "ldsh [%0],%%%c\n";
4659 #line 93 "sparc.pC"
4660 } break;
4661       case 46: { // INDIRC addr
4662          reduce(_INDIRC(redex)->INDIRC,1); // reg
4663
4664 #line 92 "sparc.pC"
4665         "ldsb [%0],%%%c\n";
4666 #line 92 "sparc.pC"
4667 } break;
4668       case 45: { // stk
4669          reduce(redex,8); // addr
4670
4671 #line 91 "sparc.pC"
4672         "%%fp+%%%0";
4673 #line 91 "sparc.pC"
4674 } break;
4675       case 44: { // ADDU (reg, reg)
4676          reduce(_ADDU(redex)->_1,8); // addr
4677          reduce(_ADDU(redex)->_2,8); // addr
4678
4679 #line 90 "sparc.pC"
4680         "%%%0+%%%1";
4681 #line 90 "sparc.pC"
4682 } break;
4683       case 43: { // ADDP (reg, reg)
4684          reduce(_ADDP(redex)->_1,8); // addr
4685          reduce(_ADDP(redex)->_2,8); // addr
4686
4687 #line 89 "sparc.pC"
4688         "%%%0+%%%1";
4689 #line 89 "sparc.pC"
4690 } break;
4691       case 42: { // ADDI (reg, reg)
4692          reduce(_ADDI(redex)->_1,8); // addr
4693          reduce(_ADDI(redex)->_2,8); // addr
4694
4695 #line 88 "sparc.pC"
4696         "%%%0+%%%1";
4697 #line 88 "sparc.pC"
4698 } break;
4699       case 41: { // base
4700          reduce(redex,8); // addr
4701
4702 #line 87 "sparc.pC"
4703         "%0";
4704 #line 87 "sparc.pC"
4705 } break;
4706       case 40: { // stk13
4707          reduce(redex,7); // base
4708
4709 #line 86 "sparc.pC"
4710         "%%fp+%0";
4711 #line 86 "sparc.pC"
4712 } break;
4713       case 39: { // con13
4714          reduce(redex,7); // base
4715
4716 #line 85 "sparc.pC"
4717         "%0";
4718 #line 85 "sparc.pC"
4719 } break;
4720       case 38: { // reg
4721          reduce(redex,7); // base
4722
4723 #line 84 "sparc.pC"
4724         "%%%0";
4725 #line 84 "sparc.pC"
4726 } break;
4727       case 37: { // ADDU (reg, con13)
4728          reduce(_ADDU(redex)->_1,7); // base
4729          reduce(_ADDU(redex)->_2,7); // base
4730
4731 #line 83 "sparc.pC"
4732         "%%%0+%1";
4733 #line 83 "sparc.pC"
4734 } break;
4735       case 36: { // ADDP (reg, con13)
4736          reduce(_ADDP(redex)->_1,7); // base
4737          reduce(_ADDP(redex)->_2,7); // base
4738
4739 #line 82 "sparc.pC"
4740         "%%%0+%1";
4741 #line 82 "sparc.pC"
4742 } break;
4743       case 35: { // ADDI (reg, con13)
4744          reduce(_ADDI(redex)->_1,7); // base
4745          reduce(_ADDI(redex)->_2,7); // base
4746
4747 #line 81 "sparc.pC"
4748         "%%%0+%1";
4749 #line 81 "sparc.pC"
4750 } break;
4751       case 34: { // CNSTU ()
4752
4753 #line 80 "sparc.pC"
4754         "%a";
4755 #line 80 "sparc.pC"
4756 } break;
4757       case 33: { // CNSTS ()
4758
4759 #line 79 "sparc.pC"
4760         "%a";
4761 #line 79 "sparc.pC"
4762 } break;
4763       case 32: { // CNSTP ()
4764
4765 #line 78 "sparc.pC"
4766         "%a";
4767 #line 78 "sparc.pC"
4768 } break;
4769       case 31: { // CNSTI ()
4770
4771 #line 77 "sparc.pC"
4772         "%a";
4773 #line 77 "sparc.pC"
4774 } break;
4775       case 30: { // CNSTC ()
4776
4777 #line 76 "sparc.pC"
4778         "%a";
4779 #line 76 "sparc.pC"
4780 } break;
4781       case 29: { // ADDRLP ()
4782
4783 #line 75 "sparc.pC"
4784         "set %a,%%%c\nadd %%%c,%%fp,%%%c\n";
4785 #line 75 "sparc.pC"
4786 } break;
4787       case 28: { // ADDRFP ()
4788
4789 #line 74 "sparc.pC"
4790         "set %a,%%%c\nadd %%%c,%%fp,%%%c\n";
4791 #line 74 "sparc.pC"
4792 } break;
4793       case 27: { // ADDRLP ()
4794
4795 #line 73 "sparc.pC"
4796         "set %a,%%%c\n";
4797 #line 73 "sparc.pC"
4798 } break;
4799       case 26: { // ADDRFP ()
4800
4801 #line 72 "sparc.pC"
4802         "set %a,%%%c\n";
4803 #line 72 "sparc.pC"
4804 } break;
4805       case 25: { // stk13
4806          reduce(redex,1); // reg
4807
4808 #line 71 "sparc.pC"
4809         "add %0,%%fp,%%%c\n";
4810 #line 71 "sparc.pC"
4811 } break;
4812       case 24: { // ADDRLP ()
4813
4814 #line 70 "sparc.pC"
4815         "%a";
4816 #line 70 "sparc.pC"
4817 } break;
4818       case 23: { // ADDRFP ()
4819
4820 #line 69 "sparc.pC"
4821         "%a";
4822 #line 69 "sparc.pC"
4823 } break;
4824       case 22: { // ADDRGP ()
4825
4826 #line 68 "sparc.pC"
4827         "set %a,%%%c\n";
4828 #line 68 "sparc.pC"
4829 } break;
4830       case 21: { // CVUP reg
4831          reduce(_CVUP(redex)->CVUP,1); // reg
4832
4833 #line 67 "sparc.pC"
4834         "%0";
4835 #line 67 "sparc.pC"
4836 } break;
4837       case 20: { // CVUI reg
4838          reduce(_CVUI(redex)->CVUI,1); // reg
4839
4840 #line 66 "sparc.pC"
4841         "%0";
4842 #line 66 "sparc.pC"
4843 } break;
4844       case 19: { // CVPU reg
4845          reduce(_CVPU(redex)->CVPU,1); // reg
4846
4847 #line 65 "sparc.pC"
4848         "%0";
4849 #line 65 "sparc.pC"
4850 } break;
4851       case 18: { // CVIU reg
4852          reduce(_CVIU(redex)->CVIU,1); // reg
4853
4854 #line 64 "sparc.pC"
4855         "%0";
4856 #line 64 "sparc.pC"
4857 } break;
4858       case 17: { // reg
4859          reduce(redex,2); // stmt
4860
4861 #line 63 "sparc.pC"
4862         "";
4863 #line 63 "sparc.pC"
4864 } break;
4865       case 16: { // CNSTU ()
4866
4867 #line 62 "sparc.pC"
4868         "%a";
4869 #line 62 "sparc.pC"
4870 } break;
4871       case 15: { // CNSTS ()
4872
4873 #line 61 "sparc.pC"
4874         "%a";
4875 #line 61 "sparc.pC"
4876 } break;
4877       case 14: { // CNSTP ()
4878
4879 #line 60 "sparc.pC"
4880         "%a";
4881 #line 60 "sparc.pC"
4882 } break;
4883       case 13: { // CNSTI ()
4884
4885 #line 59 "sparc.pC"
4886         "%a";
4887 #line 59 "sparc.pC"
4888 } break;
4889       case 12: { // CNSTC ()
4890
4891 #line 58 "sparc.pC"
4892         "%a";
4893 #line 58 "sparc.pC"
4894 } break;
4895       case 11: { // ASGNS (VREGP (), reg)
4896          reduce(_ASGNS(redex)->_2,2); // stmt
4897
4898 #line 57 "sparc.pC"
4899         "# write register\n";
4900 #line 57 "sparc.pC"
4901 } break;
4902       case 10: { // ASGNP (VREGP (), reg)
4903          reduce(_ASGNP(redex)->_2,2); // stmt
4904
4905 #line 56 "sparc.pC"
4906         "# write register\n";
4907 #line 56 "sparc.pC"
4908 } break;
4909       case 9: { // ASGNI (VREGP (), reg)
4910          reduce(_ASGNI(redex)->_2,2); // stmt
4911
4912 #line 55 "sparc.pC"
4913         "# write register\n";
4914 #line 55 "sparc.pC"
4915 } break;
4916       case 8: { // ASGNF (VREGP (), reg)
4917          reduce(_ASGNF(redex)->_2,2); // stmt
4918
4919 #line 54 "sparc.pC"
4920         "# write register\n";
4921 #line 54 "sparc.pC"
4922 } break;
4923       case 7: { // ASGND (VREGP (), reg)
4924          reduce(_ASGND(redex)->_2,2); // stmt
4925
4926 #line 53 "sparc.pC"
4927         "# write register\n";
4928 #line 53 "sparc.pC"
4929 } break;
4930       case 6: { // ASGNC (VREGP (), reg)
4931          reduce(_ASGNC(redex)->_2,2); // stmt
4932
4933 #line 52 "sparc.pC"
4934         "# write register\n";
4935 #line 52 "sparc.pC"
4936 } break;
4937       case 5: { // INDIRS VREGP ()
4938
4939 #line 51 "sparc.pC"
4940         "# read register\n";
4941 #line 51 "sparc.pC"
4942 } break;
4943       case 4: { // INDIRP VREGP ()
4944
4945 #line 50 "sparc.pC"
4946         "# read register\n";
4947 #line 50 "sparc.pC"
4948 } break;
4949       case 3: { // INDIRI VREGP ()
4950
4951 #line 49 "sparc.pC"
4952         "# read register\n";
4953 #line 49 "sparc.pC"
4954 } break;
4955       case 2: { // INDIRF VREGP ()
4956
4957 #line 48 "sparc.pC"
4958         "# read register\n";
4959 #line 48 "sparc.pC"
4960 } break;
4961       case 1: { // INDIRD VREGP ()
4962
4963 #line 47 "sparc.pC"
4964         "# read register\n";
4965 #line 47 "sparc.pC"
4966 } break;
4967       case 0: { // INDIRC VREGP ()
4968
4969 #line 46 "sparc.pC"
4970         "# read register\n";
4971 #line 46 "sparc.pC"
4972 } break;
4973    }
4974 }
4975
4976 /*
4977 ------------------------------- Statistics -------------------------------
4978 Merge matching rules         = yes
4979 Number of DFA nodes merged   = 2327
4980 Number of ifs generated      = 0
4981 Number of switches generated = 21
4982 Number of labels             = 0
4983 Number of gotos              = 0
4984 Adaptive matching            = disabled
4985 Fast string matching         = disabled
4986 Inline downcasts             = disabled
4987 --------------------------------------------------------------------------
4988 */