prop-src/sparc2.C

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.2.7),
   3 //  last updated on Mar 20, 1996.
   4 //  The original source file is "sparc2.pC".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_REWRITING_USED
   8 #define PROP_QUARK_USED
   9 #include <propdefs.h>
  10 ///////////////////////////////////////////////////////////////////////////////
  11 // Forward class definition for Inst
  12 ///////////////////////////////////////////////////////////////////////////////
  13 #ifndef datatype_Inst_defined
  14 #define datatype_Inst_defined
  15    typedef class a_Inst * Inst;
  16 #endif
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 // Class hierarchy for datatype Inst
  20 ///////////////////////////////////////////////////////////////////////////////
  21 class a_Inst; // base class for datatype Inst
  22    class Inst_ADDD;     // subclass for 'ADDD (Inst, Inst)'
  23    class Inst_ADDF;     // subclass for 'ADDF (Inst, Inst)'
  24    class Inst_ADDI;     // subclass for 'ADDI (Inst, Inst)'
  25    class Inst_ADDP;     // subclass for 'ADDP (Inst, Inst)'
  26    class Inst_ADDU;     // subclass for 'ADDU (Inst, Inst)'
  27    class Inst_ARGB;     // subclass for 'ARGB Inst'
  28    class Inst_ARGD;     // subclass for 'ARGD Inst'
  29    class Inst_ARGF;     // subclass for 'ARGF Inst'
  30    class Inst_ARGI;     // subclass for 'ARGI Inst'
  31    class Inst_ARGP;     // subclass for 'ARGP Inst'
  32    class Inst_ASGNB;    // subclass for 'ASGNB (Inst, Inst)'
  33    class Inst_ASGNC;    // subclass for 'ASGNC (Inst, Inst)'
  34    class Inst_ASGND;    // subclass for 'ASGND (Inst, Inst)'
  35    class Inst_ASGNF;    // subclass for 'ASGNF (Inst, Inst)'
  36    class Inst_ASGNI;    // subclass for 'ASGNI (Inst, Inst)'
  37    class Inst_ASGNP;    // subclass for 'ASGNP (Inst, Inst)'
  38    class Inst_ASGNS;    // subclass for 'ASGNS (Inst, Inst)'
  39    class Inst_BANDU;    // subclass for 'BANDU (Inst, Inst)'
  40    class Inst_BCOMU;    // subclass for 'BCOMU Inst'
  41    class Inst_BORU;     // subclass for 'BORU (Inst, Inst)'
  42    class Inst_BXORU;    // subclass for 'BXORU (Inst, Inst)'
  43    class Inst_CALLB;    // subclass for 'CALLB (Inst, Inst)'
  44    class Inst_CALLD;    // subclass for 'CALLD Inst'
  45    class Inst_CALLF;    // subclass for 'CALLF Inst'
  46    class Inst_CALLI;    // subclass for 'CALLI Inst'
  47    class Inst_CALLV;    // subclass for 'CALLV Inst'
  48    class Inst_CVCI;     // subclass for 'CVCI Inst'
  49    class Inst_CVCU;     // subclass for 'CVCU Inst'
  50    class Inst_CVDF;     // subclass for 'CVDF Inst'
  51    class Inst_CVDI;     // subclass for 'CVDI Inst'
  52    class Inst_CVFD;     // subclass for 'CVFD Inst'
  53    class Inst_CVIC;     // subclass for 'CVIC Inst'
  54    class Inst_CVID;     // subclass for 'CVID Inst'
  55    class Inst_CVIS;     // subclass for 'CVIS Inst'
  56    class Inst_CVIU;     // subclass for 'CVIU Inst'
  57    class Inst_CVPU;     // subclass for 'CVPU Inst'
  58    class Inst_CVSI;     // subclass for 'CVSI Inst'
  59    class Inst_CVSU;     // subclass for 'CVSU Inst'
  60    class Inst_CVUC;     // subclass for 'CVUC Inst'
  61    class Inst_CVUI;     // subclass for 'CVUI Inst'
  62    class Inst_CVUP;     // subclass for 'CVUP Inst'
  63    class Inst_CVUS;     // subclass for 'CVUS Inst'
  64    class Inst_DIVD;     // subclass for 'DIVD (Inst, Inst)'
  65    class Inst_DIVF;     // subclass for 'DIVF (Inst, Inst)'
  66    class Inst_DIVI;     // subclass for 'DIVI (Inst, Inst)'
  67    class Inst_DIVU;     // subclass for 'DIVU (Inst, Inst)'
  68    class Inst_EQD;      // subclass for 'EQD (Inst, Inst)'
  69    class Inst_EQF;      // subclass for 'EQF (Inst, Inst)'
  70    class Inst_EQI;      // subclass for 'EQI (Inst, Inst)'
  71    class Inst_GED;      // subclass for 'GED (Inst, Inst)'
  72    class Inst_GEF;      // subclass for 'GEF (Inst, Inst)'
  73    class Inst_GEI;      // subclass for 'GEI (Inst, Inst)'
  74    class Inst_GEU;      // subclass for 'GEU (Inst, Inst)'
  75    class Inst_GTD;      // subclass for 'GTD (Inst, Inst)'
  76    class Inst_GTF;      // subclass for 'GTF (Inst, Inst)'
  77    class Inst_GTI;      // subclass for 'GTI (Inst, Inst)'
  78    class Inst_GTU;      // subclass for 'GTU (Inst, Inst)'
  79    class Inst_INDIRB;   // subclass for 'INDIRB Inst'
  80    class Inst_INDIRC;   // subclass for 'INDIRC Inst'
  81    class Inst_INDIRD;   // subclass for 'INDIRD Inst'
  82    class Inst_INDIRF;   // subclass for 'INDIRF Inst'
  83    class Inst_INDIRI;   // subclass for 'INDIRI Inst'
  84    class Inst_INDIRP;   // subclass for 'INDIRP Inst'
  85    class Inst_INDIRS;   // subclass for 'INDIRS Inst'
  86    class Inst_JUMPV;    // subclass for 'JUMPV Inst'
  87    class Inst_LED;      // subclass for 'LED (Inst, Inst)'
  88    class Inst_LEF;      // subclass for 'LEF (Inst, Inst)'
  89    class Inst_LEI;      // subclass for 'LEI (Inst, Inst)'
  90    class Inst_LEU;      // subclass for 'LEU (Inst, Inst)'
  91    class Inst_LOADB;    // subclass for 'LOADB Inst'
  92    class Inst_LOADC;    // subclass for 'LOADC Inst'
  93    class Inst_LOADD;    // subclass for 'LOADD Inst'
  94    class Inst_LOADF;    // subclass for 'LOADF Inst'
  95    class Inst_LOADI;    // subclass for 'LOADI Inst'
  96    class Inst_LOADP;    // subclass for 'LOADP Inst'
  97    class Inst_LOADS;    // subclass for 'LOADS Inst'
  98    class Inst_LOADU;    // subclass for 'LOADU Inst'
  99    class Inst_LSHI;     // subclass for 'LSHI (Inst, Inst)'
 100    class Inst_LSHU;     // subclass for 'LSHU (Inst, Inst)'
 101    class Inst_LTD;      // subclass for 'LTD (Inst, Inst)'
 102    class Inst_LTF;      // subclass for 'LTF (Inst, Inst)'
 103    class Inst_LTI;      // subclass for 'LTI (Inst, Inst)'
 104    class Inst_LTU;      // subclass for 'LTU (Inst, Inst)'
 105    class Inst_MODI;     // subclass for 'MODI (Inst, Inst)'
 106    class Inst_MODU;     // subclass for 'MODU (Inst, Inst)'
 107    class Inst_MULD;     // subclass for 'MULD (Inst, Inst)'
 108    class Inst_MULF;     // subclass for 'MULF (Inst, Inst)'
 109    class Inst_MULI;     // subclass for 'MULI (Inst, Inst)'
 110    class Inst_MULU;     // subclass for 'MULU (Inst, Inst)'
 111    class Inst_NED;      // subclass for 'NED (Inst, Inst)'
 112    class Inst_NEF;      // subclass for 'NEF (Inst, Inst)'
 113    class Inst_NEI;      // subclass for 'NEI (Inst, Inst)'
 114    class Inst_NEGD;     // subclass for 'NEGD Inst'
 115    class Inst_NEGF;     // subclass for 'NEGF Inst'
 116    class Inst_NEGI;     // subclass for 'NEGI Inst'
 117    class Inst_RETD;     // subclass for 'RETD Inst'
 118    class Inst_RETF;     // subclass for 'RETF Inst'
 119    class Inst_RETI;     // subclass for 'RETI Inst'
 120    class Inst_RSHI;     // subclass for 'RSHI (Inst, Inst)'
 121    class Inst_RSHU;     // subclass for 'RSHU (Inst, Inst)'
 122    class Inst_SUBD;     // subclass for 'SUBD (Inst, Inst)'
 123    class Inst_SUBF;     // subclass for 'SUBF (Inst, Inst)'
 124    class Inst_SUBI;     // subclass for 'SUBI (Inst, Inst)'
 125    class Inst_SUBP;     // subclass for 'SUBP (Inst, Inst)'
 126    class Inst_SUBU;     // subclass for 'SUBU (Inst, Inst)'
 127
 128 ///////////////////////////////////////////////////////////////////////////////
 129 // Base class for datatype 'Inst'
 130 ///////////////////////////////////////////////////////////////////////////////
 131 class a_Inst : public TermObj {
 132 public:
 133 #  define ADDRFP (Inst)0
 134 #  define ADDRGP (Inst)1
 135 #  define ADDRLP (Inst)2
 136 #  define CNSTC (Inst)3
 137 #  define CNSTD (Inst)4
 138 #  define CNSTF (Inst)5
 139 #  define CNSTI (Inst)6
 140 #  define CNSTP (Inst)7
 141 #  define CNSTS (Inst)8
 142 #  define CNSTU (Inst)9
 143 #  define LABELV (Inst)10
 144 #  define VREGP (Inst)11
 145    enum Tag_Inst {
 146       tag_ADDD = 0, tag_ADDF = 1, tag_ADDI = 2, tag_ADDP = 3,
 147       tag_ADDU = 4, tag_ARGB = 5, tag_ARGD = 6, tag_ARGF = 7,
 148       tag_ARGI = 8, tag_ARGP = 9, tag_ASGNB = 10, tag_ASGNC = 11,
 149       tag_ASGND = 12, tag_ASGNF = 13, tag_ASGNI = 14, tag_ASGNP = 15,
 150       tag_ASGNS = 16, tag_BANDU = 17, tag_BCOMU = 18, tag_BORU = 19,
 151       tag_BXORU = 20, tag_CALLB = 21, tag_CALLD = 22, tag_CALLF = 23,
 152       tag_CALLI = 24, tag_CALLV = 25, tag_CVCI = 26, tag_CVCU = 27,
 153       tag_CVDF = 28, tag_CVDI = 29, tag_CVFD = 30, tag_CVIC = 31,
 154       tag_CVID = 32, tag_CVIS = 33, tag_CVIU = 34, tag_CVPU = 35,
 155       tag_CVSI = 36, tag_CVSU = 37, tag_CVUC = 38, tag_CVUI = 39,
 156       tag_CVUP = 40, tag_CVUS = 41, tag_DIVD = 42, tag_DIVF = 43,
 157       tag_DIVI = 44, tag_DIVU = 45, tag_EQD = 46, tag_EQF = 47,
 158       tag_EQI = 48, tag_GED = 49, tag_GEF = 50, tag_GEI = 51,
 159       tag_GEU = 52, tag_GTD = 53, tag_GTF = 54, tag_GTI = 55,
 160       tag_GTU = 56, tag_INDIRB = 57, tag_INDIRC = 58, tag_INDIRD = 59,
 161       tag_INDIRF = 60, tag_INDIRI = 61, tag_INDIRP = 62, tag_INDIRS = 63,
 162       tag_JUMPV = 64, tag_LED = 65, tag_LEF = 66, tag_LEI = 67,
 163       tag_LEU = 68, tag_LOADB = 69, tag_LOADC = 70, tag_LOADD = 71,
 164       tag_LOADF = 72, tag_LOADI = 73, tag_LOADP = 74, tag_LOADS = 75,
 165       tag_LOADU = 76, tag_LSHI = 77, tag_LSHU = 78, tag_LTD = 79,
 166       tag_LTF = 80, tag_LTI = 81, tag_LTU = 82, tag_MODI = 83,
 167       tag_MODU = 84, tag_MULD = 85, tag_MULF = 86, tag_MULI = 87,
 168       tag_MULU = 88, tag_NED = 89, tag_NEF = 90, tag_NEI = 91,
 169       tag_NEGD = 92, tag_NEGF = 93, tag_NEGI = 94, tag_RETD = 95,
 170       tag_RETF = 96, tag_RETI = 97, tag_RSHI = 98, tag_RSHU = 99,
 171       tag_SUBD = 100, tag_SUBF = 101, tag_SUBI = 102, tag_SUBP = 103,
 172       tag_SUBU = 104
 173    };
 174
 175 protected:
 176    const Tag_Inst _tag_;
 177    inline a_Inst(Tag_Inst _t_) : _tag_(_t_) {}
 178 public:
 179    inline int untag() const { return _tag_; }
 180    inline friend int boxed(const a_Inst * x) { return (unsigned long)x >= 12; }
 181    inline friend int untag(const a_Inst * x) { return boxed(x) ? x->_tag_ + 12 : (unsigned long)x; }
 182    ////////////////////////////////////////////////////////////////////////////
 183    // Downcasting functions for Inst
 184    ////////////////////////////////////////////////////////////////////////////
 185    inline friend Inst_ADDD * _ADDD(Inst _x_) { return (Inst_ADDD *)_x_; }
 186    inline friend Inst_ADDF * _ADDF(Inst _x_) { return (Inst_ADDF *)_x_; }
 187    inline friend Inst_ADDI * _ADDI(Inst _x_) { return (Inst_ADDI *)_x_; }
 188    inline friend Inst_ADDP * _ADDP(Inst _x_) { return (Inst_ADDP *)_x_; }
 189    inline friend Inst_ADDU * _ADDU(Inst _x_) { return (Inst_ADDU *)_x_; }
 190    inline friend Inst_ARGB * _ARGB(Inst _x_) { return (Inst_ARGB *)_x_; }
 191    inline friend Inst_ARGD * _ARGD(Inst _x_) { return (Inst_ARGD *)_x_; }
 192    inline friend Inst_ARGF * _ARGF(Inst _x_) { return (Inst_ARGF *)_x_; }
 193    inline friend Inst_ARGI * _ARGI(Inst _x_) { return (Inst_ARGI *)_x_; }
 194    inline friend Inst_ARGP * _ARGP(Inst _x_) { return (Inst_ARGP *)_x_; }
 195    inline friend Inst_ASGNB * _ASGNB(Inst _x_) { return (Inst_ASGNB *)_x_; }
 196    inline friend Inst_ASGNC * _ASGNC(Inst _x_) { return (Inst_ASGNC *)_x_; }
 197    inline friend Inst_ASGND * _ASGND(Inst _x_) { return (Inst_ASGND *)_x_; }
 198    inline friend Inst_ASGNF * _ASGNF(Inst _x_) { return (Inst_ASGNF *)_x_; }
 199    inline friend Inst_ASGNI * _ASGNI(Inst _x_) { return (Inst_ASGNI *)_x_; }
 200    inline friend Inst_ASGNP * _ASGNP(Inst _x_) { return (Inst_ASGNP *)_x_; }
 201    inline friend Inst_ASGNS * _ASGNS(Inst _x_) { return (Inst_ASGNS *)_x_; }
 202    inline friend Inst_BANDU * _BANDU(Inst _x_) { return (Inst_BANDU *)_x_; }
 203    inline friend Inst_BCOMU * _BCOMU(Inst _x_) { return (Inst_BCOMU *)_x_; }
 204    inline friend Inst_BORU * _BORU(Inst _x_) { return (Inst_BORU *)_x_; }
 205    inline friend Inst_BXORU * _BXORU(Inst _x_) { return (Inst_BXORU *)_x_; }
 206    inline friend Inst_CALLB * _CALLB(Inst _x_) { return (Inst_CALLB *)_x_; }
 207    inline friend Inst_CALLD * _CALLD(Inst _x_) { return (Inst_CALLD *)_x_; }
 208    inline friend Inst_CALLF * _CALLF(Inst _x_) { return (Inst_CALLF *)_x_; }
 209    inline friend Inst_CALLI * _CALLI(Inst _x_) { return (Inst_CALLI *)_x_; }
 210    inline friend Inst_CALLV * _CALLV(Inst _x_) { return (Inst_CALLV *)_x_; }
 211    inline friend Inst_CVCI * _CVCI(Inst _x_) { return (Inst_CVCI *)_x_; }
 212    inline friend Inst_CVCU * _CVCU(Inst _x_) { return (Inst_CVCU *)_x_; }
 213    inline friend Inst_CVDF * _CVDF(Inst _x_) { return (Inst_CVDF *)_x_; }
 214    inline friend Inst_CVDI * _CVDI(Inst _x_) { return (Inst_CVDI *)_x_; }
 215    inline friend Inst_CVFD * _CVFD(Inst _x_) { return (Inst_CVFD *)_x_; }
 216    inline friend Inst_CVIC * _CVIC(Inst _x_) { return (Inst_CVIC *)_x_; }
 217    inline friend Inst_CVID * _CVID(Inst _x_) { return (Inst_CVID *)_x_; }
 218    inline friend Inst_CVIS * _CVIS(Inst _x_) { return (Inst_CVIS *)_x_; }
 219    inline friend Inst_CVIU * _CVIU(Inst _x_) { return (Inst_CVIU *)_x_; }
 220    inline friend Inst_CVPU * _CVPU(Inst _x_) { return (Inst_CVPU *)_x_; }
 221    inline friend Inst_CVSI * _CVSI(Inst _x_) { return (Inst_CVSI *)_x_; }
 222    inline friend Inst_CVSU * _CVSU(Inst _x_) { return (Inst_CVSU *)_x_; }
 223    inline friend Inst_CVUC * _CVUC(Inst _x_) { return (Inst_CVUC *)_x_; }
 224    inline friend Inst_CVUI * _CVUI(Inst _x_) { return (Inst_CVUI *)_x_; }
 225    inline friend Inst_CVUP * _CVUP(Inst _x_) { return (Inst_CVUP *)_x_; }
 226    inline friend Inst_CVUS * _CVUS(Inst _x_) { return (Inst_CVUS *)_x_; }
 227    inline friend Inst_DIVD * _DIVD(Inst _x_) { return (Inst_DIVD *)_x_; }
 228    inline friend Inst_DIVF * _DIVF(Inst _x_) { return (Inst_DIVF *)_x_; }
 229    inline friend Inst_DIVI * _DIVI(Inst _x_) { return (Inst_DIVI *)_x_; }
 230    inline friend Inst_DIVU * _DIVU(Inst _x_) { return (Inst_DIVU *)_x_; }
 231    inline friend Inst_EQD * _EQD(Inst _x_) { return (Inst_EQD *)_x_; }
 232    inline friend Inst_EQF * _EQF(Inst _x_) { return (Inst_EQF *)_x_; }
 233    inline friend Inst_EQI * _EQI(Inst _x_) { return (Inst_EQI *)_x_; }
 234    inline friend Inst_GED * _GED(Inst _x_) { return (Inst_GED *)_x_; }
 235    inline friend Inst_GEF * _GEF(Inst _x_) { return (Inst_GEF *)_x_; }
 236    inline friend Inst_GEI * _GEI(Inst _x_) { return (Inst_GEI *)_x_; }
 237    inline friend Inst_GEU * _GEU(Inst _x_) { return (Inst_GEU *)_x_; }
 238    inline friend Inst_GTD * _GTD(Inst _x_) { return (Inst_GTD *)_x_; }
 239    inline friend Inst_GTF * _GTF(Inst _x_) { return (Inst_GTF *)_x_; }
 240    inline friend Inst_GTI * _GTI(Inst _x_) { return (Inst_GTI *)_x_; }
 241    inline friend Inst_GTU * _GTU(Inst _x_) { return (Inst_GTU *)_x_; }
 242    inline friend Inst_INDIRB * _INDIRB(Inst _x_) { return (Inst_INDIRB *)_x_; }
 243    inline friend Inst_INDIRC * _INDIRC(Inst _x_) { return (Inst_INDIRC *)_x_; }
 244    inline friend Inst_INDIRD * _INDIRD(Inst _x_) { return (Inst_INDIRD *)_x_; }
 245    inline friend Inst_INDIRF * _INDIRF(Inst _x_) { return (Inst_INDIRF *)_x_; }
 246    inline friend Inst_INDIRI * _INDIRI(Inst _x_) { return (Inst_INDIRI *)_x_; }
 247    inline friend Inst_INDIRP * _INDIRP(Inst _x_) { return (Inst_INDIRP *)_x_; }
 248    inline friend Inst_INDIRS * _INDIRS(Inst _x_) { return (Inst_INDIRS *)_x_; }
 249    inline friend Inst_JUMPV * _JUMPV(Inst _x_) { return (Inst_JUMPV *)_x_; }
 250    inline friend Inst_LED * _LED(Inst _x_) { return (Inst_LED *)_x_; }
 251    inline friend Inst_LEF * _LEF(Inst _x_) { return (Inst_LEF *)_x_; }
 252    inline friend Inst_LEI * _LEI(Inst _x_) { return (Inst_LEI *)_x_; }
 253    inline friend Inst_LEU * _LEU(Inst _x_) { return (Inst_LEU *)_x_; }
 254    inline friend Inst_LOADB * _LOADB(Inst _x_) { return (Inst_LOADB *)_x_; }
 255    inline friend Inst_LOADC * _LOADC(Inst _x_) { return (Inst_LOADC *)_x_; }
 256    inline friend Inst_LOADD * _LOADD(Inst _x_) { return (Inst_LOADD *)_x_; }
 257    inline friend Inst_LOADF * _LOADF(Inst _x_) { return (Inst_LOADF *)_x_; }
 258    inline friend Inst_LOADI * _LOADI(Inst _x_) { return (Inst_LOADI *)_x_; }
 259    inline friend Inst_LOADP * _LOADP(Inst _x_) { return (Inst_LOADP *)_x_; }
 260    inline friend Inst_LOADS * _LOADS(Inst _x_) { return (Inst_LOADS *)_x_; }
 261    inline friend Inst_LOADU * _LOADU(Inst _x_) { return (Inst_LOADU *)_x_; }
 262    inline friend Inst_LSHI * _LSHI(Inst _x_) { return (Inst_LSHI *)_x_; }
 263    inline friend Inst_LSHU * _LSHU(Inst _x_) { return (Inst_LSHU *)_x_; }
 264    inline friend Inst_LTD * _LTD(Inst _x_) { return (Inst_LTD *)_x_; }
 265    inline friend Inst_LTF * _LTF(Inst _x_) { return (Inst_LTF *)_x_; }
 266    inline friend Inst_LTI * _LTI(Inst _x_) { return (Inst_LTI *)_x_; }
 267    inline friend Inst_LTU * _LTU(Inst _x_) { return (Inst_LTU *)_x_; }
 268    inline friend Inst_MODI * _MODI(Inst _x_) { return (Inst_MODI *)_x_; }
 269    inline friend Inst_MODU * _MODU(Inst _x_) { return (Inst_MODU *)_x_; }
 270    inline friend Inst_MULD * _MULD(Inst _x_) { return (Inst_MULD *)_x_; }
 271    inline friend Inst_MULF * _MULF(Inst _x_) { return (Inst_MULF *)_x_; }
 272    inline friend Inst_MULI * _MULI(Inst _x_) { return (Inst_MULI *)_x_; }
 273    inline friend Inst_MULU * _MULU(Inst _x_) { return (Inst_MULU *)_x_; }
 274    inline friend Inst_NED * _NED(Inst _x_) { return (Inst_NED *)_x_; }
 275    inline friend Inst_NEF * _NEF(Inst _x_) { return (Inst_NEF *)_x_; }
 276    inline friend Inst_NEI * _NEI(Inst _x_) { return (Inst_NEI *)_x_; }
 277    inline friend Inst_NEGD * _NEGD(Inst _x_) { return (Inst_NEGD *)_x_; }
 278    inline friend Inst_NEGF * _NEGF(Inst _x_) { return (Inst_NEGF *)_x_; }
 279    inline friend Inst_NEGI * _NEGI(Inst _x_) { return (Inst_NEGI *)_x_; }
 280    inline friend Inst_RETD * _RETD(Inst _x_) { return (Inst_RETD *)_x_; }
 281    inline friend Inst_RETF * _RETF(Inst _x_) { return (Inst_RETF *)_x_; }
 282    inline friend Inst_RETI * _RETI(Inst _x_) { return (Inst_RETI *)_x_; }
 283    inline friend Inst_RSHI * _RSHI(Inst _x_) { return (Inst_RSHI *)_x_; }
 284    inline friend Inst_RSHU * _RSHU(Inst _x_) { return (Inst_RSHU *)_x_; }
 285    inline friend Inst_SUBD * _SUBD(Inst _x_) { return (Inst_SUBD *)_x_; }
 286    inline friend Inst_SUBF * _SUBF(Inst _x_) { return (Inst_SUBF *)_x_; }
 287    inline friend Inst_SUBI * _SUBI(Inst _x_) { return (Inst_SUBI *)_x_; }
 288    inline friend Inst_SUBP * _SUBP(Inst _x_) { return (Inst_SUBP *)_x_; }
 289    inline friend Inst_SUBU * _SUBU(Inst _x_) { return (Inst_SUBU *)_x_; }
 290 };
 291
 292 ///////////////////////////////////////////////////////////////////////////////
 293 // class for constructor 'Inst::ADDD (Inst, Inst)'
 294 ///////////////////////////////////////////////////////////////////////////////
 295 class Inst_ADDD : public a_Inst {
 296 public:
 297    Inst _1; Inst _2;
 298    inline Inst_ADDD (Inst _x1, Inst _x2)
 299       : a_Inst(a_Inst::tag_ADDD), _1(_x1), _2(_x2) {}
 300    inline friend a_Inst * ADDD (Inst _x1, Inst _x2)
 301       { return new Inst_ADDD (_x1, _x2); }
 302 };
 303
 304 ///////////////////////////////////////////////////////////////////////////////
 305 // class for constructor 'Inst::ADDF (Inst, Inst)'
 306 ///////////////////////////////////////////////////////////////////////////////
 307 class Inst_ADDF : public a_Inst {
 308 public:
 309    Inst _1; Inst _2;
 310    inline Inst_ADDF (Inst _x1, Inst _x2)
 311       : a_Inst(a_Inst::tag_ADDF), _1(_x1), _2(_x2) {}
 312    inline friend a_Inst * ADDF (Inst _x1, Inst _x2)
 313       { return new Inst_ADDF (_x1, _x2); }
 314 };
 315
 316 ///////////////////////////////////////////////////////////////////////////////
 317 // class for constructor 'Inst::ADDI (Inst, Inst)'
 318 ///////////////////////////////////////////////////////////////////////////////
 319 class Inst_ADDI : public a_Inst {
 320 public:
 321    Inst _1; Inst _2;
 322    inline Inst_ADDI (Inst _x1, Inst _x2)
 323       : a_Inst(a_Inst::tag_ADDI), _1(_x1), _2(_x2) {}
 324    inline friend a_Inst * ADDI (Inst _x1, Inst _x2)
 325       { return new Inst_ADDI (_x1, _x2); }
 326 };
 327
 328 ///////////////////////////////////////////////////////////////////////////////
 329 // class for constructor 'Inst::ADDP (Inst, Inst)'
 330 ///////////////////////////////////////////////////////////////////////////////
 331 class Inst_ADDP : public a_Inst {
 332 public:
 333    Inst _1; Inst _2;
 334    inline Inst_ADDP (Inst _x1, Inst _x2)
 335       : a_Inst(a_Inst::tag_ADDP), _1(_x1), _2(_x2) {}
 336    inline friend a_Inst * ADDP (Inst _x1, Inst _x2)
 337       { return new Inst_ADDP (_x1, _x2); }
 338 };
 339
 340 ///////////////////////////////////////////////////////////////////////////////
 341 // class for constructor 'Inst::ADDU (Inst, Inst)'
 342 ///////////////////////////////////////////////////////////////////////////////
 343 class Inst_ADDU : public a_Inst {
 344 public:
 345    Inst _1; Inst _2;
 346    inline Inst_ADDU (Inst _x1, Inst _x2)
 347       : a_Inst(a_Inst::tag_ADDU), _1(_x1), _2(_x2) {}
 348    inline friend a_Inst * ADDU (Inst _x1, Inst _x2)
 349       { return new Inst_ADDU (_x1, _x2); }
 350 };
 351
 352 ///////////////////////////////////////////////////////////////////////////////
 353 // class for constructor 'Inst::ARGB Inst'
 354 ///////////////////////////////////////////////////////////////////////////////
 355 class Inst_ARGB : public a_Inst {
 356 public:
 357    Inst ARGB;
 358    inline Inst_ARGB (Inst _xARGB)
 359       : a_Inst(a_Inst::tag_ARGB), ARGB(_xARGB) {}
 360    inline friend a_Inst * ARGB (Inst _xARGB)
 361       { return new Inst_ARGB (_xARGB); }
 362 };
 363
 364 ///////////////////////////////////////////////////////////////////////////////
 365 // class for constructor 'Inst::ARGD Inst'
 366 ///////////////////////////////////////////////////////////////////////////////
 367 class Inst_ARGD : public a_Inst {
 368 public:
 369    Inst ARGD;
 370    inline Inst_ARGD (Inst _xARGD)
 371       : a_Inst(a_Inst::tag_ARGD), ARGD(_xARGD) {}
 372    inline friend a_Inst * ARGD (Inst _xARGD)
 373       { return new Inst_ARGD (_xARGD); }
 374 };
 375
 376 ///////////////////////////////////////////////////////////////////////////////
 377 // class for constructor 'Inst::ARGF Inst'
 378 ///////////////////////////////////////////////////////////////////////////////
 379 class Inst_ARGF : public a_Inst {
 380 public:
 381    Inst ARGF;
 382    inline Inst_ARGF (Inst _xARGF)
 383       : a_Inst(a_Inst::tag_ARGF), ARGF(_xARGF) {}
 384    inline friend a_Inst * ARGF (Inst _xARGF)
 385       { return new Inst_ARGF (_xARGF); }
 386 };
 387
 388 ///////////////////////////////////////////////////////////////////////////////
 389 // class for constructor 'Inst::ARGI Inst'
 390 ///////////////////////////////////////////////////////////////////////////////
 391 class Inst_ARGI : public a_Inst {
 392 public:
 393    Inst ARGI;
 394    inline Inst_ARGI (Inst _xARGI)
 395       : a_Inst(a_Inst::tag_ARGI), ARGI(_xARGI) {}
 396    inline friend a_Inst * ARGI (Inst _xARGI)
 397       { return new Inst_ARGI (_xARGI); }
 398 };
 399
 400 ///////////////////////////////////////////////////////////////////////////////
 401 // class for constructor 'Inst::ARGP Inst'
 402 ///////////////////////////////////////////////////////////////////////////////
 403 class Inst_ARGP : public a_Inst {
 404 public:
 405    Inst ARGP;
 406    inline Inst_ARGP (Inst _xARGP)
 407       : a_Inst(a_Inst::tag_ARGP), ARGP(_xARGP) {}
 408    inline friend a_Inst * ARGP (Inst _xARGP)
 409       { return new Inst_ARGP (_xARGP); }
 410 };
 411
 412 ///////////////////////////////////////////////////////////////////////////////
 413 // class for constructor 'Inst::ASGNB (Inst, Inst)'
 414 ///////////////////////////////////////////////////////////////////////////////
 415 class Inst_ASGNB : public a_Inst {
 416 public:
 417    Inst _1; Inst _2;
 418    inline Inst_ASGNB (Inst _x1, Inst _x2)
 419       : a_Inst(a_Inst::tag_ASGNB), _1(_x1), _2(_x2) {}
 420    inline friend a_Inst * ASGNB (Inst _x1, Inst _x2)
 421       { return new Inst_ASGNB (_x1, _x2); }
 422 };
 423
 424 ///////////////////////////////////////////////////////////////////////////////
 425 // class for constructor 'Inst::ASGNC (Inst, Inst)'
 426 ///////////////////////////////////////////////////////////////////////////////
 427 class Inst_ASGNC : public a_Inst {
 428 public:
 429    Inst _1; Inst _2;
 430    inline Inst_ASGNC (Inst _x1, Inst _x2)
 431       : a_Inst(a_Inst::tag_ASGNC), _1(_x1), _2(_x2) {}
 432    inline friend a_Inst * ASGNC (Inst _x1, Inst _x2)
 433       { return new Inst_ASGNC (_x1, _x2); }
 434 };
 435
 436 ///////////////////////////////////////////////////////////////////////////////
 437 // class for constructor 'Inst::ASGND (Inst, Inst)'
 438 ///////////////////////////////////////////////////////////////////////////////
 439 class Inst_ASGND : public a_Inst {
 440 public:
 441    Inst _1; Inst _2;
 442    inline Inst_ASGND (Inst _x1, Inst _x2)
 443       : a_Inst(a_Inst::tag_ASGND), _1(_x1), _2(_x2) {}
 444    inline friend a_Inst * ASGND (Inst _x1, Inst _x2)
 445       { return new Inst_ASGND (_x1, _x2); }
 446 };
 447
 448 ///////////////////////////////////////////////////////////////////////////////
 449 // class for constructor 'Inst::ASGNF (Inst, Inst)'
 450 ///////////////////////////////////////////////////////////////////////////////
 451 class Inst_ASGNF : public a_Inst {
 452 public:
 453    Inst _1; Inst _2;
 454    inline Inst_ASGNF (Inst _x1, Inst _x2)
 455       : a_Inst(a_Inst::tag_ASGNF), _1(_x1), _2(_x2) {}
 456    inline friend a_Inst * ASGNF (Inst _x1, Inst _x2)
 457       { return new Inst_ASGNF (_x1, _x2); }
 458 };
 459
 460 ///////////////////////////////////////////////////////////////////////////////
 461 // class for constructor 'Inst::ASGNI (Inst, Inst)'
 462 ///////////////////////////////////////////////////////////////////////////////
 463 class Inst_ASGNI : public a_Inst {
 464 public:
 465    Inst _1; Inst _2;
 466    inline Inst_ASGNI (Inst _x1, Inst _x2)
 467       : a_Inst(a_Inst::tag_ASGNI), _1(_x1), _2(_x2) {}
 468    inline friend a_Inst * ASGNI (Inst _x1, Inst _x2)
 469       { return new Inst_ASGNI (_x1, _x2); }
 470 };
 471
 472 ///////////////////////////////////////////////////////////////////////////////
 473 // class for constructor 'Inst::ASGNP (Inst, Inst)'
 474 ///////////////////////////////////////////////////////////////////////////////
 475 class Inst_ASGNP : public a_Inst {
 476 public:
 477    Inst _1; Inst _2;
 478    inline Inst_ASGNP (Inst _x1, Inst _x2)
 479       : a_Inst(a_Inst::tag_ASGNP), _1(_x1), _2(_x2) {}
 480    inline friend a_Inst * ASGNP (Inst _x1, Inst _x2)
 481       { return new Inst_ASGNP (_x1, _x2); }
 482 };
 483
 484 ///////////////////////////////////////////////////////////////////////////////
 485 // class for constructor 'Inst::ASGNS (Inst, Inst)'
 486 ///////////////////////////////////////////////////////////////////////////////
 487 class Inst_ASGNS : public a_Inst {
 488 public:
 489    Inst _1; Inst _2;
 490    inline Inst_ASGNS (Inst _x1, Inst _x2)
 491       : a_Inst(a_Inst::tag_ASGNS), _1(_x1), _2(_x2) {}
 492    inline friend a_Inst * ASGNS (Inst _x1, Inst _x2)
 493       { return new Inst_ASGNS (_x1, _x2); }
 494 };
 495
 496 ///////////////////////////////////////////////////////////////////////////////
 497 // class for constructor 'Inst::BANDU (Inst, Inst)'
 498 ///////////////////////////////////////////////////////////////////////////////
 499 class Inst_BANDU : public a_Inst {
 500 public:
 501    Inst _1; Inst _2;
 502    inline Inst_BANDU (Inst _x1, Inst _x2)
 503       : a_Inst(a_Inst::tag_BANDU), _1(_x1), _2(_x2) {}
 504    inline friend a_Inst * BANDU (Inst _x1, Inst _x2)
 505       { return new Inst_BANDU (_x1, _x2); }
 506 };
 507
 508 ///////////////////////////////////////////////////////////////////////////////
 509 // class for constructor 'Inst::BCOMU Inst'
 510 ///////////////////////////////////////////////////////////////////////////////
 511 class Inst_BCOMU : public a_Inst {
 512 public:
 513    Inst BCOMU;
 514    inline Inst_BCOMU (Inst _xBCOMU)
 515       : a_Inst(a_Inst::tag_BCOMU), BCOMU(_xBCOMU) {}
 516    inline friend a_Inst * BCOMU (Inst _xBCOMU)
 517       { return new Inst_BCOMU (_xBCOMU); }
 518 };
 519
 520 ///////////////////////////////////////////////////////////////////////////////
 521 // class for constructor 'Inst::BORU (Inst, Inst)'
 522 ///////////////////////////////////////////////////////////////////////////////
 523 class Inst_BORU : public a_Inst {
 524 public:
 525    Inst _1; Inst _2;
 526    inline Inst_BORU (Inst _x1, Inst _x2)
 527       : a_Inst(a_Inst::tag_BORU), _1(_x1), _2(_x2) {}
 528    inline friend a_Inst * BORU (Inst _x1, Inst _x2)
 529       { return new Inst_BORU (_x1, _x2); }
 530 };
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533 // class for constructor 'Inst::BXORU (Inst, Inst)'
 534 ///////////////////////////////////////////////////////////////////////////////
 535 class Inst_BXORU : public a_Inst {
 536 public:
 537    Inst _1; Inst _2;
 538    inline Inst_BXORU (Inst _x1, Inst _x2)
 539       : a_Inst(a_Inst::tag_BXORU), _1(_x1), _2(_x2) {}
 540    inline friend a_Inst * BXORU (Inst _x1, Inst _x2)
 541       { return new Inst_BXORU (_x1, _x2); }
 542 };
 543
 544 ///////////////////////////////////////////////////////////////////////////////
 545 // class for constructor 'Inst::CALLB (Inst, Inst)'
 546 ///////////////////////////////////////////////////////////////////////////////
 547 class Inst_CALLB : public a_Inst {
 548 public:
 549    Inst _1; Inst _2;
 550    inline Inst_CALLB (Inst _x1, Inst _x2)
 551       : a_Inst(a_Inst::tag_CALLB), _1(_x1), _2(_x2) {}
 552    inline friend a_Inst * CALLB (Inst _x1, Inst _x2)
 553       { return new Inst_CALLB (_x1, _x2); }
 554 };
 555
 556 ///////////////////////////////////////////////////////////////////////////////
 557 // class for constructor 'Inst::CALLD Inst'
 558 ///////////////////////////////////////////////////////////////////////////////
 559 class Inst_CALLD : public a_Inst {
 560 public:
 561    Inst CALLD;
 562    inline Inst_CALLD (Inst _xCALLD)
 563       : a_Inst(a_Inst::tag_CALLD), CALLD(_xCALLD) {}
 564    inline friend a_Inst * CALLD (Inst _xCALLD)
 565       { return new Inst_CALLD (_xCALLD); }
 566 };
 567
 568 ///////////////////////////////////////////////////////////////////////////////
 569 // class for constructor 'Inst::CALLF Inst'
 570 ///////////////////////////////////////////////////////////////////////////////
 571 class Inst_CALLF : public a_Inst {
 572 public:
 573    Inst CALLF;
 574    inline Inst_CALLF (Inst _xCALLF)
 575       : a_Inst(a_Inst::tag_CALLF), CALLF(_xCALLF) {}
 576    inline friend a_Inst * CALLF (Inst _xCALLF)
 577       { return new Inst_CALLF (_xCALLF); }
 578 };
 579
 580 ///////////////////////////////////////////////////////////////////////////////
 581 // class for constructor 'Inst::CALLI Inst'
 582 ///////////////////////////////////////////////////////////////////////////////
 583 class Inst_CALLI : public a_Inst {
 584 public:
 585    Inst CALLI;
 586    inline Inst_CALLI (Inst _xCALLI)
 587       : a_Inst(a_Inst::tag_CALLI), CALLI(_xCALLI) {}
 588    inline friend a_Inst * CALLI (Inst _xCALLI)
 589       { return new Inst_CALLI (_xCALLI); }
 590 };
 591
 592 ///////////////////////////////////////////////////////////////////////////////
 593 // class for constructor 'Inst::CALLV Inst'
 594 ///////////////////////////////////////////////////////////////////////////////
 595 class Inst_CALLV : public a_Inst {
 596 public:
 597    Inst CALLV;
 598    inline Inst_CALLV (Inst _xCALLV)
 599       : a_Inst(a_Inst::tag_CALLV), CALLV(_xCALLV) {}
 600    inline friend a_Inst * CALLV (Inst _xCALLV)
 601       { return new Inst_CALLV (_xCALLV); }
 602 };
 603
 604 ///////////////////////////////////////////////////////////////////////////////
 605 // class for constructor 'Inst::CVCI Inst'
 606 ///////////////////////////////////////////////////////////////////////////////
 607 class Inst_CVCI : public a_Inst {
 608 public:
 609    Inst CVCI;
 610    inline Inst_CVCI (Inst _xCVCI)
 611       : a_Inst(a_Inst::tag_CVCI), CVCI(_xCVCI) {}
 612    inline friend a_Inst * CVCI (Inst _xCVCI)
 613       { return new Inst_CVCI (_xCVCI); }
 614 };
 615
 616 ///////////////////////////////////////////////////////////////////////////////
 617 // class for constructor 'Inst::CVCU Inst'
 618 ///////////////////////////////////////////////////////////////////////////////
 619 class Inst_CVCU : public a_Inst {
 620 public:
 621    Inst CVCU;
 622    inline Inst_CVCU (Inst _xCVCU)
 623       : a_Inst(a_Inst::tag_CVCU), CVCU(_xCVCU) {}
 624    inline friend a_Inst * CVCU (Inst _xCVCU)
 625       { return new Inst_CVCU (_xCVCU); }
 626 };
 627
 628 ///////////////////////////////////////////////////////////////////////////////
 629 // class for constructor 'Inst::CVDF Inst'
 630 ///////////////////////////////////////////////////////////////////////////////
 631 class Inst_CVDF : public a_Inst {
 632 public:
 633    Inst CVDF;
 634    inline Inst_CVDF (Inst _xCVDF)
 635       : a_Inst(a_Inst::tag_CVDF), CVDF(_xCVDF) {}
 636    inline friend a_Inst * CVDF (Inst _xCVDF)
 637       { return new Inst_CVDF (_xCVDF); }
 638 };
 639
 640 ///////////////////////////////////////////////////////////////////////////////
 641 // class for constructor 'Inst::CVDI Inst'
 642 ///////////////////////////////////////////////////////////////////////////////
 643 class Inst_CVDI : public a_Inst {
 644 public:
 645    Inst CVDI;
 646    inline Inst_CVDI (Inst _xCVDI)
 647       : a_Inst(a_Inst::tag_CVDI), CVDI(_xCVDI) {}
 648    inline friend a_Inst * CVDI (Inst _xCVDI)
 649       { return new Inst_CVDI (_xCVDI); }
 650 };
 651
 652 ///////////////////////////////////////////////////////////////////////////////
 653 // class for constructor 'Inst::CVFD Inst'
 654 ///////////////////////////////////////////////////////////////////////////////
 655 class Inst_CVFD : public a_Inst {
 656 public:
 657    Inst CVFD;
 658    inline Inst_CVFD (Inst _xCVFD)
 659       : a_Inst(a_Inst::tag_CVFD), CVFD(_xCVFD) {}
 660    inline friend a_Inst * CVFD (Inst _xCVFD)
 661       { return new Inst_CVFD (_xCVFD); }
 662 };
 663
 664 ///////////////////////////////////////////////////////////////////////////////
 665 // class for constructor 'Inst::CVIC Inst'
 666 ///////////////////////////////////////////////////////////////////////////////
 667 class Inst_CVIC : public a_Inst {
 668 public:
 669    Inst CVIC;
 670    inline Inst_CVIC (Inst _xCVIC)
 671       : a_Inst(a_Inst::tag_CVIC), CVIC(_xCVIC) {}
 672    inline friend a_Inst * CVIC (Inst _xCVIC)
 673       { return new Inst_CVIC (_xCVIC); }
 674 };
 675
 676 ///////////////////////////////////////////////////////////////////////////////
 677 // class for constructor 'Inst::CVID Inst'
 678 ///////////////////////////////////////////////////////////////////////////////
 679 class Inst_CVID : public a_Inst {
 680 public:
 681    Inst CVID;
 682    inline Inst_CVID (Inst _xCVID)
 683       : a_Inst(a_Inst::tag_CVID), CVID(_xCVID) {}
 684    inline friend a_Inst * CVID (Inst _xCVID)
 685       { return new Inst_CVID (_xCVID); }
 686 };
 687
 688 ///////////////////////////////////////////////////////////////////////////////
 689 // class for constructor 'Inst::CVIS Inst'
 690 ///////////////////////////////////////////////////////////////////////////////
 691 class Inst_CVIS : public a_Inst {
 692 public:
 693    Inst CVIS;
 694    inline Inst_CVIS (Inst _xCVIS)
 695       : a_Inst(a_Inst::tag_CVIS), CVIS(_xCVIS) {}
 696    inline friend a_Inst * CVIS (Inst _xCVIS)
 697       { return new Inst_CVIS (_xCVIS); }
 698 };
 699
 700 ///////////////////////////////////////////////////////////////////////////////
 701 // class for constructor 'Inst::CVIU Inst'
 702 ///////////////////////////////////////////////////////////////////////////////
 703 class Inst_CVIU : public a_Inst {
 704 public:
 705    Inst CVIU;
 706    inline Inst_CVIU (Inst _xCVIU)
 707       : a_Inst(a_Inst::tag_CVIU), CVIU(_xCVIU) {}
 708    inline friend a_Inst * CVIU (Inst _xCVIU)
 709       { return new Inst_CVIU (_xCVIU); }
 710 };
 711
 712 ///////////////////////////////////////////////////////////////////////////////
 713 // class for constructor 'Inst::CVPU Inst'
 714 ///////////////////////////////////////////////////////////////////////////////
 715 class Inst_CVPU : public a_Inst {
 716 public:
 717    Inst CVPU;
 718    inline Inst_CVPU (Inst _xCVPU)
 719       : a_Inst(a_Inst::tag_CVPU), CVPU(_xCVPU) {}
 720    inline friend a_Inst * CVPU (Inst _xCVPU)
 721       { return new Inst_CVPU (_xCVPU); }
 722 };
 723
 724 ///////////////////////////////////////////////////////////////////////////////
 725 // class for constructor 'Inst::CVSI Inst'
 726 ///////////////////////////////////////////////////////////////////////////////
 727 class Inst_CVSI : public a_Inst {
 728 public:
 729    Inst CVSI;
 730    inline Inst_CVSI (Inst _xCVSI)
 731       : a_Inst(a_Inst::tag_CVSI), CVSI(_xCVSI) {}
 732    inline friend a_Inst * CVSI (Inst _xCVSI)
 733       { return new Inst_CVSI (_xCVSI); }
 734 };
 735
 736 ///////////////////////////////////////////////////////////////////////////////
 737 // class for constructor 'Inst::CVSU Inst'
 738 ///////////////////////////////////////////////////////////////////////////////
 739 class Inst_CVSU : public a_Inst {
 740 public:
 741    Inst CVSU;
 742    inline Inst_CVSU (Inst _xCVSU)
 743       : a_Inst(a_Inst::tag_CVSU), CVSU(_xCVSU) {}
 744    inline friend a_Inst * CVSU (Inst _xCVSU)
 745       { return new Inst_CVSU (_xCVSU); }
 746 };
 747
 748 ///////////////////////////////////////////////////////////////////////////////
 749 // class for constructor 'Inst::CVUC Inst'
 750 ///////////////////////////////////////////////////////////////////////////////
 751 class Inst_CVUC : public a_Inst {
 752 public:
 753    Inst CVUC;
 754    inline Inst_CVUC (Inst _xCVUC)
 755       : a_Inst(a_Inst::tag_CVUC), CVUC(_xCVUC) {}
 756    inline friend a_Inst * CVUC (Inst _xCVUC)
 757       { return new Inst_CVUC (_xCVUC); }
 758 };
 759
 760 ///////////////////////////////////////////////////////////////////////////////
 761 // class for constructor 'Inst::CVUI Inst'
 762 ///////////////////////////////////////////////////////////////////////////////
 763 class Inst_CVUI : public a_Inst {
 764 public:
 765    Inst CVUI;
 766    inline Inst_CVUI (Inst _xCVUI)
 767       : a_Inst(a_Inst::tag_CVUI), CVUI(_xCVUI) {}
 768    inline friend a_Inst * CVUI (Inst _xCVUI)
 769       { return new Inst_CVUI (_xCVUI); }
 770 };
 771
 772 ///////////////////////////////////////////////////////////////////////////////
 773 // class for constructor 'Inst::CVUP Inst'
 774 ///////////////////////////////////////////////////////////////////////////////
 775 class Inst_CVUP : public a_Inst {
 776 public:
 777    Inst CVUP;
 778    inline Inst_CVUP (Inst _xCVUP)
 779       : a_Inst(a_Inst::tag_CVUP), CVUP(_xCVUP) {}
 780    inline friend a_Inst * CVUP (Inst _xCVUP)
 781       { return new Inst_CVUP (_xCVUP); }
 782 };
 783
 784 ///////////////////////////////////////////////////////////////////////////////
 785 // class for constructor 'Inst::CVUS Inst'
 786 ///////////////////////////////////////////////////////////////////////////////
 787 class Inst_CVUS : public a_Inst {
 788 public:
 789    Inst CVUS;
 790    inline Inst_CVUS (Inst _xCVUS)
 791       : a_Inst(a_Inst::tag_CVUS), CVUS(_xCVUS) {}
 792    inline friend a_Inst * CVUS (Inst _xCVUS)
 793       { return new Inst_CVUS (_xCVUS); }
 794 };
 795
 796 ///////////////////////////////////////////////////////////////////////////////
 797 // class for constructor 'Inst::DIVD (Inst, Inst)'
 798 ///////////////////////////////////////////////////////////////////////////////
 799 class Inst_DIVD : public a_Inst {
 800 public:
 801    Inst _1; Inst _2;
 802    inline Inst_DIVD (Inst _x1, Inst _x2)
 803       : a_Inst(a_Inst::tag_DIVD), _1(_x1), _2(_x2) {}
 804    inline friend a_Inst * DIVD (Inst _x1, Inst _x2)
 805       { return new Inst_DIVD (_x1, _x2); }
 806 };
 807
 808 ///////////////////////////////////////////////////////////////////////////////
 809 // class for constructor 'Inst::DIVF (Inst, Inst)'
 810 ///////////////////////////////////////////////////////////////////////////////
 811 class Inst_DIVF : public a_Inst {
 812 public:
 813    Inst _1; Inst _2;
 814    inline Inst_DIVF (Inst _x1, Inst _x2)
 815       : a_Inst(a_Inst::tag_DIVF), _1(_x1), _2(_x2) {}
 816    inline friend a_Inst * DIVF (Inst _x1, Inst _x2)
 817       { return new Inst_DIVF (_x1, _x2); }
 818 };
 819
 820 ///////////////////////////////////////////////////////////////////////////////
 821 // class for constructor 'Inst::DIVI (Inst, Inst)'
 822 ///////////////////////////////////////////////////////////////////////////////
 823 class Inst_DIVI : public a_Inst {
 824 public:
 825    Inst _1; Inst _2;
 826    inline Inst_DIVI (Inst _x1, Inst _x2)
 827       : a_Inst(a_Inst::tag_DIVI), _1(_x1), _2(_x2) {}
 828    inline friend a_Inst * DIVI (Inst _x1, Inst _x2)
 829       { return new Inst_DIVI (_x1, _x2); }
 830 };
 831
 832 ///////////////////////////////////////////////////////////////////////////////
 833 // class for constructor 'Inst::DIVU (Inst, Inst)'
 834 ///////////////////////////////////////////////////////////////////////////////
 835 class Inst_DIVU : public a_Inst {
 836 public:
 837    Inst _1; Inst _2;
 838    inline Inst_DIVU (Inst _x1, Inst _x2)
 839       : a_Inst(a_Inst::tag_DIVU), _1(_x1), _2(_x2) {}
 840    inline friend a_Inst * DIVU (Inst _x1, Inst _x2)
 841       { return new Inst_DIVU (_x1, _x2); }
 842 };
 843
 844 ///////////////////////////////////////////////////////////////////////////////
 845 // class for constructor 'Inst::EQD (Inst, Inst)'
 846 ///////////////////////////////////////////////////////////////////////////////
 847 class Inst_EQD : public a_Inst {
 848 public:
 849    Inst _1; Inst _2;
 850    inline Inst_EQD (Inst _x1, Inst _x2)
 851       : a_Inst(a_Inst::tag_EQD), _1(_x1), _2(_x2) {}
 852    inline friend a_Inst * EQD (Inst _x1, Inst _x2)
 853       { return new Inst_EQD (_x1, _x2); }
 854 };
 855
 856 ///////////////////////////////////////////////////////////////////////////////
 857 // class for constructor 'Inst::EQF (Inst, Inst)'
 858 ///////////////////////////////////////////////////////////////////////////////
 859 class Inst_EQF : public a_Inst {
 860 public:
 861    Inst _1; Inst _2;
 862    inline Inst_EQF (Inst _x1, Inst _x2)
 863       : a_Inst(a_Inst::tag_EQF), _1(_x1), _2(_x2) {}
 864    inline friend a_Inst * EQF (Inst _x1, Inst _x2)
 865       { return new Inst_EQF (_x1, _x2); }
 866 };
 867
 868 ///////////////////////////////////////////////////////////////////////////////
 869 // class for constructor 'Inst::EQI (Inst, Inst)'
 870 ///////////////////////////////////////////////////////////////////////////////
 871 class Inst_EQI : public a_Inst {
 872 public:
 873    Inst _1; Inst _2;
 874    inline Inst_EQI (Inst _x1, Inst _x2)
 875       : a_Inst(a_Inst::tag_EQI), _1(_x1), _2(_x2) {}
 876    inline friend a_Inst * EQI (Inst _x1, Inst _x2)
 877       { return new Inst_EQI (_x1, _x2); }
 878 };
 879
 880 ///////////////////////////////////////////////////////////////////////////////
 881 // class for constructor 'Inst::GED (Inst, Inst)'
 882 ///////////////////////////////////////////////////////////////////////////////
 883 class Inst_GED : public a_Inst {
 884 public:
 885    Inst _1; Inst _2;
 886    inline Inst_GED (Inst _x1, Inst _x2)
 887       : a_Inst(a_Inst::tag_GED), _1(_x1), _2(_x2) {}
 888    inline friend a_Inst * GED (Inst _x1, Inst _x2)
 889       { return new Inst_GED (_x1, _x2); }
 890 };
 891
 892 ///////////////////////////////////////////////////////////////////////////////
 893 // class for constructor 'Inst::GEF (Inst, Inst)'
 894 ///////////////////////////////////////////////////////////////////////////////
 895 class Inst_GEF : public a_Inst {
 896 public:
 897    Inst _1; Inst _2;
 898    inline Inst_GEF (Inst _x1, Inst _x2)
 899       : a_Inst(a_Inst::tag_GEF), _1(_x1), _2(_x2) {}
 900    inline friend a_Inst * GEF (Inst _x1, Inst _x2)
 901       { return new Inst_GEF (_x1, _x2); }
 902 };
 903
 904 ///////////////////////////////////////////////////////////////////////////////
 905 // class for constructor 'Inst::GEI (Inst, Inst)'
 906 ///////////////////////////////////////////////////////////////////////////////
 907 class Inst_GEI : public a_Inst {
 908 public:
 909    Inst _1; Inst _2;
 910    inline Inst_GEI (Inst _x1, Inst _x2)
 911       : a_Inst(a_Inst::tag_GEI), _1(_x1), _2(_x2) {}
 912    inline friend a_Inst * GEI (Inst _x1, Inst _x2)
 913       { return new Inst_GEI (_x1, _x2); }
 914 };
 915
 916 ///////////////////////////////////////////////////////////////////////////////
 917 // class for constructor 'Inst::GEU (Inst, Inst)'
 918 ///////////////////////////////////////////////////////////////////////////////
 919 class Inst_GEU : public a_Inst {
 920 public:
 921    Inst _1; Inst _2;
 922    inline Inst_GEU (Inst _x1, Inst _x2)
 923       : a_Inst(a_Inst::tag_GEU), _1(_x1), _2(_x2) {}
 924    inline friend a_Inst * GEU (Inst _x1, Inst _x2)
 925       { return new Inst_GEU (_x1, _x2); }
 926 };
 927
 928 ///////////////////////////////////////////////////////////////////////////////
 929 // class for constructor 'Inst::GTD (Inst, Inst)'
 930 ///////////////////////////////////////////////////////////////////////////////
 931 class Inst_GTD : public a_Inst {
 932 public:
 933    Inst _1; Inst _2;
 934    inline Inst_GTD (Inst _x1, Inst _x2)
 935       : a_Inst(a_Inst::tag_GTD), _1(_x1), _2(_x2) {}
 936    inline friend a_Inst * GTD (Inst _x1, Inst _x2)
 937       { return new Inst_GTD (_x1, _x2); }
 938 };
 939
 940 ///////////////////////////////////////////////////////////////////////////////
 941 // class for constructor 'Inst::GTF (Inst, Inst)'
 942 ///////////////////////////////////////////////////////////////////////////////
 943 class Inst_GTF : public a_Inst {
 944 public:
 945    Inst _1; Inst _2;
 946    inline Inst_GTF (Inst _x1, Inst _x2)
 947       : a_Inst(a_Inst::tag_GTF), _1(_x1), _2(_x2) {}
 948    inline friend a_Inst * GTF (Inst _x1, Inst _x2)
 949       { return new Inst_GTF (_x1, _x2); }
 950 };
 951
 952 ///////////////////////////////////////////////////////////////////////////////
 953 // class for constructor 'Inst::GTI (Inst, Inst)'
 954 ///////////////////////////////////////////////////////////////////////////////
 955 class Inst_GTI : public a_Inst {
 956 public:
 957    Inst _1; Inst _2;
 958    inline Inst_GTI (Inst _x1, Inst _x2)
 959       : a_Inst(a_Inst::tag_GTI), _1(_x1), _2(_x2) {}
 960    inline friend a_Inst * GTI (Inst _x1, Inst _x2)
 961       { return new Inst_GTI (_x1, _x2); }
 962 };
 963
 964 ///////////////////////////////////////////////////////////////////////////////
 965 // class for constructor 'Inst::GTU (Inst, Inst)'
 966 ///////////////////////////////////////////////////////////////////////////////
 967 class Inst_GTU : public a_Inst {
 968 public:
 969    Inst _1; Inst _2;
 970    inline Inst_GTU (Inst _x1, Inst _x2)
 971       : a_Inst(a_Inst::tag_GTU), _1(_x1), _2(_x2) {}
 972    inline friend a_Inst * GTU (Inst _x1, Inst _x2)
 973       { return new Inst_GTU (_x1, _x2); }
 974 };
 975
 976 ///////////////////////////////////////////////////////////////////////////////
 977 // class for constructor 'Inst::INDIRB Inst'
 978 ///////////////////////////////////////////////////////////////////////////////
 979 class Inst_INDIRB : public a_Inst {
 980 public:
 981    Inst INDIRB;
 982    inline Inst_INDIRB (Inst _xINDIRB)
 983       : a_Inst(a_Inst::tag_INDIRB), INDIRB(_xINDIRB) {}
 984    inline friend a_Inst * INDIRB (Inst _xINDIRB)
 985       { return new Inst_INDIRB (_xINDIRB); }
 986 };
 987
 988 ///////////////////////////////////////////////////////////////////////////////
 989 // class for constructor 'Inst::INDIRC Inst'
 990 ///////////////////////////////////////////////////////////////////////////////
 991 class Inst_INDIRC : public a_Inst {
 992 public:
 993    Inst INDIRC;
 994    inline Inst_INDIRC (Inst _xINDIRC)
 995       : a_Inst(a_Inst::tag_INDIRC), INDIRC(_xINDIRC) {}
 996    inline friend a_Inst * INDIRC (Inst _xINDIRC)
 997       { return new Inst_INDIRC (_xINDIRC); }
 998 };
 999
1000 ///////////////////////////////////////////////////////////////////////////////
1001 // class for constructor 'Inst::INDIRD Inst'
1002 ///////////////////////////////////////////////////////////////////////////////
1003 class Inst_INDIRD : public a_Inst {
1004 public:
1005    Inst INDIRD;
1006    inline Inst_INDIRD (Inst _xINDIRD)
1007       : a_Inst(a_Inst::tag_INDIRD), INDIRD(_xINDIRD) {}
1008    inline friend a_Inst * INDIRD (Inst _xINDIRD)
1009       { return new Inst_INDIRD (_xINDIRD); }
1010 };
1011
1012 ///////////////////////////////////////////////////////////////////////////////
1013 // class for constructor 'Inst::INDIRF Inst'
1014 ///////////////////////////////////////////////////////////////////////////////
1015 class Inst_INDIRF : public a_Inst {
1016 public:
1017    Inst INDIRF;
1018    inline Inst_INDIRF (Inst _xINDIRF)
1019       : a_Inst(a_Inst::tag_INDIRF), INDIRF(_xINDIRF) {}
1020    inline friend a_Inst * INDIRF (Inst _xINDIRF)
1021       { return new Inst_INDIRF (_xINDIRF); }
1022 };
1023
1024 ///////////////////////////////////////////////////////////////////////////////
1025 // class for constructor 'Inst::INDIRI Inst'
1026 ///////////////////////////////////////////////////////////////////////////////
1027 class Inst_INDIRI : public a_Inst {
1028 public:
1029    Inst INDIRI;
1030    inline Inst_INDIRI (Inst _xINDIRI)
1031       : a_Inst(a_Inst::tag_INDIRI), INDIRI(_xINDIRI) {}
1032    inline friend a_Inst * INDIRI (Inst _xINDIRI)
1033       { return new Inst_INDIRI (_xINDIRI); }
1034 };
1035
1036 ///////////////////////////////////////////////////////////////////////////////
1037 // class for constructor 'Inst::INDIRP Inst'
1038 ///////////////////////////////////////////////////////////////////////////////
1039 class Inst_INDIRP : public a_Inst {
1040 public:
1041    Inst INDIRP;
1042    inline Inst_INDIRP (Inst _xINDIRP)
1043       : a_Inst(a_Inst::tag_INDIRP), INDIRP(_xINDIRP) {}
1044    inline friend a_Inst * INDIRP (Inst _xINDIRP)
1045       { return new Inst_INDIRP (_xINDIRP); }
1046 };
1047
1048 ///////////////////////////////////////////////////////////////////////////////
1049 // class for constructor 'Inst::INDIRS Inst'
1050 ///////////////////////////////////////////////////////////////////////////////
1051 class Inst_INDIRS : public a_Inst {
1052 public:
1053    Inst INDIRS;
1054    inline Inst_INDIRS (Inst _xINDIRS)
1055       : a_Inst(a_Inst::tag_INDIRS), INDIRS(_xINDIRS) {}
1056    inline friend a_Inst * INDIRS (Inst _xINDIRS)
1057       { return new Inst_INDIRS (_xINDIRS); }
1058 };
1059
1060 ///////////////////////////////////////////////////////////////////////////////
1061 // class for constructor 'Inst::JUMPV Inst'
1062 ///////////////////////////////////////////////////////////////////////////////
1063 class Inst_JUMPV : public a_Inst {
1064 public:
1065    Inst JUMPV;
1066    inline Inst_JUMPV (Inst _xJUMPV)
1067       : a_Inst(a_Inst::tag_JUMPV), JUMPV(_xJUMPV) {}
1068    inline friend a_Inst * JUMPV (Inst _xJUMPV)
1069       { return new Inst_JUMPV (_xJUMPV); }
1070 };
1071
1072 ///////////////////////////////////////////////////////////////////////////////
1073 // class for constructor 'Inst::LED (Inst, Inst)'
1074 ///////////////////////////////////////////////////////////////////////////////
1075 class Inst_LED : public a_Inst {
1076 public:
1077    Inst _1; Inst _2;
1078    inline Inst_LED (Inst _x1, Inst _x2)
1079       : a_Inst(a_Inst::tag_LED), _1(_x1), _2(_x2) {}
1080    inline friend a_Inst * LED (Inst _x1, Inst _x2)
1081       { return new Inst_LED (_x1, _x2); }
1082 };
1083
1084 ///////////////////////////////////////////////////////////////////////////////
1085 // class for constructor 'Inst::LEF (Inst, Inst)'
1086 ///////////////////////////////////////////////////////////////////////////////
1087 class Inst_LEF : public a_Inst {
1088 public:
1089    Inst _1; Inst _2;
1090    inline Inst_LEF (Inst _x1, Inst _x2)
1091       : a_Inst(a_Inst::tag_LEF), _1(_x1), _2(_x2) {}
1092    inline friend a_Inst * LEF (Inst _x1, Inst _x2)
1093       { return new Inst_LEF (_x1, _x2); }
1094 };
1095
1096 ///////////////////////////////////////////////////////////////////////////////
1097 // class for constructor 'Inst::LEI (Inst, Inst)'
1098 ///////////////////////////////////////////////////////////////////////////////
1099 class Inst_LEI : public a_Inst {
1100 public:
1101    Inst _1; Inst _2;
1102    inline Inst_LEI (Inst _x1, Inst _x2)
1103       : a_Inst(a_Inst::tag_LEI), _1(_x1), _2(_x2) {}
1104    inline friend a_Inst * LEI (Inst _x1, Inst _x2)
1105       { return new Inst_LEI (_x1, _x2); }
1106 };
1107
1108 ///////////////////////////////////////////////////////////////////////////////
1109 // class for constructor 'Inst::LEU (Inst, Inst)'
1110 ///////////////////////////////////////////////////////////////////////////////
1111 class Inst_LEU : public a_Inst {
1112 public:
1113    Inst _1; Inst _2;
1114    inline Inst_LEU (Inst _x1, Inst _x2)
1115       : a_Inst(a_Inst::tag_LEU), _1(_x1), _2(_x2) {}
1116    inline friend a_Inst * LEU (Inst _x1, Inst _x2)
1117       { return new Inst_LEU (_x1, _x2); }
1118 };
1119
1120 ///////////////////////////////////////////////////////////////////////////////
1121 // class for constructor 'Inst::LOADB Inst'
1122 ///////////////////////////////////////////////////////////////////////////////
1123 class Inst_LOADB : public a_Inst {
1124 public:
1125    Inst LOADB;
1126    inline Inst_LOADB (Inst _xLOADB)
1127       : a_Inst(a_Inst::tag_LOADB), LOADB(_xLOADB) {}
1128    inline friend a_Inst * LOADB (Inst _xLOADB)
1129       { return new Inst_LOADB (_xLOADB); }
1130 };
1131
1132 ///////////////////////////////////////////////////////////////////////////////
1133 // class for constructor 'Inst::LOADC Inst'
1134 ///////////////////////////////////////////////////////////////////////////////
1135 class Inst_LOADC : public a_Inst {
1136 public:
1137    Inst LOADC;
1138    inline Inst_LOADC (Inst _xLOADC)
1139       : a_Inst(a_Inst::tag_LOADC), LOADC(_xLOADC) {}
1140    inline friend a_Inst * LOADC (Inst _xLOADC)
1141       { return new Inst_LOADC (_xLOADC); }
1142 };
1143
1144 ///////////////////////////////////////////////////////////////////////////////
1145 // class for constructor 'Inst::LOADD Inst'
1146 ///////////////////////////////////////////////////////////////////////////////
1147 class Inst_LOADD : public a_Inst {
1148 public:
1149    Inst LOADD;
1150    inline Inst_LOADD (Inst _xLOADD)
1151       : a_Inst(a_Inst::tag_LOADD), LOADD(_xLOADD) {}
1152    inline friend a_Inst * LOADD (Inst _xLOADD)
1153       { return new Inst_LOADD (_xLOADD); }
1154 };
1155
1156 ///////////////////////////////////////////////////////////////////////////////
1157 // class for constructor 'Inst::LOADF Inst'
1158 ///////////////////////////////////////////////////////////////////////////////
1159 class Inst_LOADF : public a_Inst {
1160 public:
1161    Inst LOADF;
1162    inline Inst_LOADF (Inst _xLOADF)
1163       : a_Inst(a_Inst::tag_LOADF), LOADF(_xLOADF) {}
1164    inline friend a_Inst * LOADF (Inst _xLOADF)
1165       { return new Inst_LOADF (_xLOADF); }
1166 };
1167
1168 ///////////////////////////////////////////////////////////////////////////////
1169 // class for constructor 'Inst::LOADI Inst'
1170 ///////////////////////////////////////////////////////////////////////////////
1171 class Inst_LOADI : public a_Inst {
1172 public:
1173    Inst LOADI;
1174    inline Inst_LOADI (Inst _xLOADI)
1175       : a_Inst(a_Inst::tag_LOADI), LOADI(_xLOADI) {}
1176    inline friend a_Inst * LOADI (Inst _xLOADI)
1177       { return new Inst_LOADI (_xLOADI); }
1178 };
1179
1180 ///////////////////////////////////////////////////////////////////////////////
1181 // class for constructor 'Inst::LOADP Inst'
1182 ///////////////////////////////////////////////////////////////////////////////
1183 class Inst_LOADP : public a_Inst {
1184 public:
1185    Inst LOADP;
1186    inline Inst_LOADP (Inst _xLOADP)
1187       : a_Inst(a_Inst::tag_LOADP), LOADP(_xLOADP) {}
1188    inline friend a_Inst * LOADP (Inst _xLOADP)
1189       { return new Inst_LOADP (_xLOADP); }
1190 };
1191
1192 ///////////////////////////////////////////////////////////////////////////////
1193 // class for constructor 'Inst::LOADS Inst'
1194 ///////////////////////////////////////////////////////////////////////////////
1195 class Inst_LOADS : public a_Inst {
1196 public:
1197    Inst LOADS;
1198    inline Inst_LOADS (Inst _xLOADS)
1199       : a_Inst(a_Inst::tag_LOADS), LOADS(_xLOADS) {}
1200    inline friend a_Inst * LOADS (Inst _xLOADS)
1201       { return new Inst_LOADS (_xLOADS); }
1202 };
1203
1204 ///////////////////////////////////////////////////////////////////////////////
1205 // class for constructor 'Inst::LOADU Inst'
1206 ///////////////////////////////////////////////////////////////////////////////
1207 class Inst_LOADU : public a_Inst {
1208 public:
1209    Inst LOADU;
1210    inline Inst_LOADU (Inst _xLOADU)
1211       : a_Inst(a_Inst::tag_LOADU), LOADU(_xLOADU) {}
1212    inline friend a_Inst * LOADU (Inst _xLOADU)
1213       { return new Inst_LOADU (_xLOADU); }
1214 };
1215
1216 ///////////////////////////////////////////////////////////////////////////////
1217 // class for constructor 'Inst::LSHI (Inst, Inst)'
1218 ///////////////////////////////////////////////////////////////////////////////
1219 class Inst_LSHI : public a_Inst {
1220 public:
1221    Inst _1; Inst _2;
1222    inline Inst_LSHI (Inst _x1, Inst _x2)
1223       : a_Inst(a_Inst::tag_LSHI), _1(_x1), _2(_x2) {}
1224    inline friend a_Inst * LSHI (Inst _x1, Inst _x2)
1225       { return new Inst_LSHI (_x1, _x2); }
1226 };
1227
1228 ///////////////////////////////////////////////////////////////////////////////
1229 // class for constructor 'Inst::LSHU (Inst, Inst)'
1230 ///////////////////////////////////////////////////////////////////////////////
1231 class Inst_LSHU : public a_Inst {
1232 public:
1233    Inst _1; Inst _2;
1234    inline Inst_LSHU (Inst _x1, Inst _x2)
1235       : a_Inst(a_Inst::tag_LSHU), _1(_x1), _2(_x2) {}
1236    inline friend a_Inst * LSHU (Inst _x1, Inst _x2)
1237       { return new Inst_LSHU (_x1, _x2); }
1238 };
1239
1240 ///////////////////////////////////////////////////////////////////////////////
1241 // class for constructor 'Inst::LTD (Inst, Inst)'
1242 ///////////////////////////////////////////////////////////////////////////////
1243 class Inst_LTD : public a_Inst {
1244 public:
1245    Inst _1; Inst _2;
1246    inline Inst_LTD (Inst _x1, Inst _x2)
1247       : a_Inst(a_Inst::tag_LTD), _1(_x1), _2(_x2) {}
1248    inline friend a_Inst * LTD (Inst _x1, Inst _x2)
1249       { return new Inst_LTD (_x1, _x2); }
1250 };
1251
1252 ///////////////////////////////////////////////////////////////////////////////
1253 // class for constructor 'Inst::LTF (Inst, Inst)'
1254 ///////////////////////////////////////////////////////////////////////////////
1255 class Inst_LTF : public a_Inst {
1256 public:
1257    Inst _1; Inst _2;
1258    inline Inst_LTF (Inst _x1, Inst _x2)
1259       : a_Inst(a_Inst::tag_LTF), _1(_x1), _2(_x2) {}
1260    inline friend a_Inst * LTF (Inst _x1, Inst _x2)
1261       { return new Inst_LTF (_x1, _x2); }
1262 };
1263
1264 ///////////////////////////////////////////////////////////////////////////////
1265 // class for constructor 'Inst::LTI (Inst, Inst)'
1266 ///////////////////////////////////////////////////////////////////////////////
1267 class Inst_LTI : public a_Inst {
1268 public:
1269    Inst _1; Inst _2;
1270    inline Inst_LTI (Inst _x1, Inst _x2)
1271       : a_Inst(a_Inst::tag_LTI), _1(_x1), _2(_x2) {}
1272    inline friend a_Inst * LTI (Inst _x1, Inst _x2)
1273       { return new Inst_LTI (_x1, _x2); }
1274 };
1275
1276 ///////////////////////////////////////////////////////////////////////////////
1277 // class for constructor 'Inst::LTU (Inst, Inst)'
1278 ///////////////////////////////////////////////////////////////////////////////
1279 class Inst_LTU : public a_Inst {
1280 public:
1281    Inst _1; Inst _2;
1282    inline Inst_LTU (Inst _x1, Inst _x2)
1283       : a_Inst(a_Inst::tag_LTU), _1(_x1), _2(_x2) {}
1284    inline friend a_Inst * LTU (Inst _x1, Inst _x2)
1285       { return new Inst_LTU (_x1, _x2); }
1286 };
1287
1288 ///////////////////////////////////////////////////////////////////////////////
1289 // class for constructor 'Inst::MODI (Inst, Inst)'
1290 ///////////////////////////////////////////////////////////////////////////////
1291 class Inst_MODI : public a_Inst {
1292 public:
1293    Inst _1; Inst _2;
1294    inline Inst_MODI (Inst _x1, Inst _x2)
1295       : a_Inst(a_Inst::tag_MODI), _1(_x1), _2(_x2) {}
1296    inline friend a_Inst * MODI (Inst _x1, Inst _x2)
1297       { return new Inst_MODI (_x1, _x2); }
1298 };
1299
1300 ///////////////////////////////////////////////////////////////////////////////
1301 // class for constructor 'Inst::MODU (Inst, Inst)'
1302 ///////////////////////////////////////////////////////////////////////////////
1303 class Inst_MODU : public a_Inst {
1304 public:
1305    Inst _1; Inst _2;
1306    inline Inst_MODU (Inst _x1, Inst _x2)
1307       : a_Inst(a_Inst::tag_MODU), _1(_x1), _2(_x2) {}
1308    inline friend a_Inst * MODU (Inst _x1, Inst _x2)
1309       { return new Inst_MODU (_x1, _x2); }
1310 };
1311
1312 ///////////////////////////////////////////////////////////////////////////////
1313 // class for constructor 'Inst::MULD (Inst, Inst)'
1314 ///////////////////////////////////////////////////////////////////////////////
1315 class Inst_MULD : public a_Inst {
1316 public:
1317    Inst _1; Inst _2;
1318    inline Inst_MULD (Inst _x1, Inst _x2)
1319       : a_Inst(a_Inst::tag_MULD), _1(_x1), _2(_x2) {}
1320    inline friend a_Inst * MULD (Inst _x1, Inst _x2)
1321       { return new Inst_MULD (_x1, _x2); }
1322 };
1323
1324 ///////////////////////////////////////////////////////////////////////////////
1325 // class for constructor 'Inst::MULF (Inst, Inst)'
1326 ///////////////////////////////////////////////////////////////////////////////
1327 class Inst_MULF : public a_Inst {
1328 public:
1329    Inst _1; Inst _2;
1330    inline Inst_MULF (Inst _x1, Inst _x2)
1331       : a_Inst(a_Inst::tag_MULF), _1(_x1), _2(_x2) {}
1332    inline friend a_Inst * MULF (Inst _x1, Inst _x2)
1333       { return new Inst_MULF (_x1, _x2); }
1334 };
1335
1336 ///////////////////////////////////////////////////////////////////////////////
1337 // class for constructor 'Inst::MULI (Inst, Inst)'
1338 ///////////////////////////////////////////////////////////////////////////////
1339 class Inst_MULI : public a_Inst {
1340 public:
1341    Inst _1; Inst _2;
1342    inline Inst_MULI (Inst _x1, Inst _x2)
1343       : a_Inst(a_Inst::tag_MULI), _1(_x1), _2(_x2) {}
1344    inline friend a_Inst * MULI (Inst _x1, Inst _x2)
1345       { return new Inst_MULI (_x1, _x2); }
1346 };
1347
1348 ///////////////////////////////////////////////////////////////////////////////
1349 // class for constructor 'Inst::MULU (Inst, Inst)'
1350 ///////////////////////////////////////////////////////////////////////////////
1351 class Inst_MULU : public a_Inst {
1352 public:
1353    Inst _1; Inst _2;
1354    inline Inst_MULU (Inst _x1, Inst _x2)
1355       : a_Inst(a_Inst::tag_MULU), _1(_x1), _2(_x2) {}
1356    inline friend a_Inst * MULU (Inst _x1, Inst _x2)
1357       { return new Inst_MULU (_x1, _x2); }
1358 };
1359
1360 ///////////////////////////////////////////////////////////////////////////////
1361 // class for constructor 'Inst::NED (Inst, Inst)'
1362 ///////////////////////////////////////////////////////////////////////////////
1363 class Inst_NED : public a_Inst {
1364 public:
1365    Inst _1; Inst _2;
1366    inline Inst_NED (Inst _x1, Inst _x2)
1367       : a_Inst(a_Inst::tag_NED), _1(_x1), _2(_x2) {}
1368    inline friend a_Inst * NED (Inst _x1, Inst _x2)
1369       { return new Inst_NED (_x1, _x2); }
1370 };
1371
1372 ///////////////////////////////////////////////////////////////////////////////
1373 // class for constructor 'Inst::NEF (Inst, Inst)'
1374 ///////////////////////////////////////////////////////////////////////////////
1375 class Inst_NEF : public a_Inst {
1376 public:
1377    Inst _1; Inst _2;
1378    inline Inst_NEF (Inst _x1, Inst _x2)
1379       : a_Inst(a_Inst::tag_NEF), _1(_x1), _2(_x2) {}
1380    inline friend a_Inst * NEF (Inst _x1, Inst _x2)
1381       { return new Inst_NEF (_x1, _x2); }
1382 };
1383
1384 ///////////////////////////////////////////////////////////////////////////////
1385 // class for constructor 'Inst::NEI (Inst, Inst)'
1386 ///////////////////////////////////////////////////////////////////////////////
1387 class Inst_NEI : public a_Inst {
1388 public:
1389    Inst _1; Inst _2;
1390    inline Inst_NEI (Inst _x1, Inst _x2)
1391       : a_Inst(a_Inst::tag_NEI), _1(_x1), _2(_x2) {}
1392    inline friend a_Inst * NEI (Inst _x1, Inst _x2)
1393       { return new Inst_NEI (_x1, _x2); }
1394 };
1395
1396 ///////////////////////////////////////////////////////////////////////////////
1397 // class for constructor 'Inst::NEGD Inst'
1398 ///////////////////////////////////////////////////////////////////////////////
1399 class Inst_NEGD : public a_Inst {
1400 public:
1401    Inst NEGD;
1402    inline Inst_NEGD (Inst _xNEGD)
1403       : a_Inst(a_Inst::tag_NEGD), NEGD(_xNEGD) {}
1404    inline friend a_Inst * NEGD (Inst _xNEGD)
1405       { return new Inst_NEGD (_xNEGD); }
1406 };
1407
1408 ///////////////////////////////////////////////////////////////////////////////
1409 // class for constructor 'Inst::NEGF Inst'
1410 ///////////////////////////////////////////////////////////////////////////////
1411 class Inst_NEGF : public a_Inst {
1412 public:
1413    Inst NEGF;
1414    inline Inst_NEGF (Inst _xNEGF)
1415       : a_Inst(a_Inst::tag_NEGF), NEGF(_xNEGF) {}
1416    inline friend a_Inst * NEGF (Inst _xNEGF)
1417       { return new Inst_NEGF (_xNEGF); }
1418 };
1419
1420 ///////////////////////////////////////////////////////////////////////////////
1421 // class for constructor 'Inst::NEGI Inst'
1422 ///////////////////////////////////////////////////////////////////////////////
1423 class Inst_NEGI : public a_Inst {
1424 public:
1425    Inst NEGI;
1426    inline Inst_NEGI (Inst _xNEGI)
1427       : a_Inst(a_Inst::tag_NEGI), NEGI(_xNEGI) {}
1428    inline friend a_Inst * NEGI (Inst _xNEGI)
1429       { return new Inst_NEGI (_xNEGI); }
1430 };
1431
1432 ///////////////////////////////////////////////////////////////////////////////
1433 // class for constructor 'Inst::RETD Inst'
1434 ///////////////////////////////////////////////////////////////////////////////
1435 class Inst_RETD : public a_Inst {
1436 public:
1437    Inst RETD;
1438    inline Inst_RETD (Inst _xRETD)
1439       : a_Inst(a_Inst::tag_RETD), RETD(_xRETD) {}
1440    inline friend a_Inst * RETD (Inst _xRETD)
1441       { return new Inst_RETD (_xRETD); }
1442 };
1443
1444 ///////////////////////////////////////////////////////////////////////////////
1445 // class for constructor 'Inst::RETF Inst'
1446 ///////////////////////////////////////////////////////////////////////////////
1447 class Inst_RETF : public a_Inst {
1448 public:
1449    Inst RETF;
1450    inline Inst_RETF (Inst _xRETF)
1451       : a_Inst(a_Inst::tag_RETF), RETF(_xRETF) {}
1452    inline friend a_Inst * RETF (Inst _xRETF)
1453       { return new Inst_RETF (_xRETF); }
1454 };
1455
1456 ///////////////////////////////////////////////////////////////////////////////
1457 // class for constructor 'Inst::RETI Inst'
1458 ///////////////////////////////////////////////////////////////////////////////
1459 class Inst_RETI : public a_Inst {
1460 public:
1461    Inst RETI;
1462    inline Inst_RETI (Inst _xRETI)
1463       : a_Inst(a_Inst::tag_RETI), RETI(_xRETI) {}
1464    inline friend a_Inst * RETI (Inst _xRETI)
1465       { return new Inst_RETI (_xRETI); }
1466 };
1467
1468 ///////////////////////////////////////////////////////////////////////////////
1469 // class for constructor 'Inst::RSHI (Inst, Inst)'
1470 ///////////////////////////////////////////////////////////////////////////////
1471 class Inst_RSHI : public a_Inst {
1472 public:
1473    Inst _1; Inst _2;
1474    inline Inst_RSHI (Inst _x1, Inst _x2)
1475       : a_Inst(a_Inst::tag_RSHI), _1(_x1), _2(_x2) {}
1476    inline friend a_Inst * RSHI (Inst _x1, Inst _x2)
1477       { return new Inst_RSHI (_x1, _x2); }
1478 };
1479
1480 ///////////////////////////////////////////////////////////////////////////////
1481 // class for constructor 'Inst::RSHU (Inst, Inst)'
1482 ///////////////////////////////////////////////////////////////////////////////
1483 class Inst_RSHU : public a_Inst {
1484 public:
1485    Inst _1; Inst _2;
1486    inline Inst_RSHU (Inst _x1, Inst _x2)
1487       : a_Inst(a_Inst::tag_RSHU), _1(_x1), _2(_x2) {}
1488    inline friend a_Inst * RSHU (Inst _x1, Inst _x2)
1489       { return new Inst_RSHU (_x1, _x2); }
1490 };
1491
1492 ///////////////////////////////////////////////////////////////////////////////
1493 // class for constructor 'Inst::SUBD (Inst, Inst)'
1494 ///////////////////////////////////////////////////////////////////////////////
1495 class Inst_SUBD : public a_Inst {
1496 public:
1497    Inst _1; Inst _2;
1498    inline Inst_SUBD (Inst _x1, Inst _x2)
1499       : a_Inst(a_Inst::tag_SUBD), _1(_x1), _2(_x2) {}
1500    inline friend a_Inst * SUBD (Inst _x1, Inst _x2)
1501       { return new Inst_SUBD (_x1, _x2); }
1502 };
1503
1504 ///////////////////////////////////////////////////////////////////////////////
1505 // class for constructor 'Inst::SUBF (Inst, Inst)'
1506 ///////////////////////////////////////////////////////////////////////////////
1507 class Inst_SUBF : public a_Inst {
1508 public:
1509    Inst _1; Inst _2;
1510    inline Inst_SUBF (Inst _x1, Inst _x2)
1511       : a_Inst(a_Inst::tag_SUBF), _1(_x1), _2(_x2) {}
1512    inline friend a_Inst * SUBF (Inst _x1, Inst _x2)
1513       { return new Inst_SUBF (_x1, _x2); }
1514 };
1515
1516 ///////////////////////////////////////////////////////////////////////////////
1517 // class for constructor 'Inst::SUBI (Inst, Inst)'
1518 ///////////////////////////////////////////////////////////////////////////////
1519 class Inst_SUBI : public a_Inst {
1520 public:
1521    Inst _1; Inst _2;
1522    inline Inst_SUBI (Inst _x1, Inst _x2)
1523       : a_Inst(a_Inst::tag_SUBI), _1(_x1), _2(_x2) {}
1524    inline friend a_Inst * SUBI (Inst _x1, Inst _x2)
1525       { return new Inst_SUBI (_x1, _x2); }
1526 };
1527
1528 ///////////////////////////////////////////////////////////////////////////////
1529 // class for constructor 'Inst::SUBP (Inst, Inst)'
1530 ///////////////////////////////////////////////////////////////////////////////
1531 class Inst_SUBP : public a_Inst {
1532 public:
1533    Inst _1; Inst _2;
1534    inline Inst_SUBP (Inst _x1, Inst _x2)
1535       : a_Inst(a_Inst::tag_SUBP), _1(_x1), _2(_x2) {}
1536    inline friend a_Inst * SUBP (Inst _x1, Inst _x2)
1537       { return new Inst_SUBP (_x1, _x2); }
1538 };
1539
1540 ///////////////////////////////////////////////////////////////////////////////
1541 // class for constructor 'Inst::SUBU (Inst, Inst)'
1542 ///////////////////////////////////////////////////////////////////////////////
1543 class Inst_SUBU : public a_Inst {
1544 public:
1545    Inst _1; Inst _2;
1546    inline Inst_SUBU (Inst _x1, Inst _x2)
1547       : a_Inst(a_Inst::tag_SUBU), _1(_x1), _2(_x2) {}
1548    inline friend a_Inst * SUBU (Inst _x1, Inst _x2)
1549       { return new Inst_SUBU (_x1, _x2); }
1550 };
1551
1552
1553
1554 void compile (Inst e)
1555 {
1556    extern void  _s_p_a_r_c_2co_X1_rewrite(Inst & );
1557    _s_p_a_r_c_2co_X1_rewrite(e);
1558 }
1559 class _s_p_a_r_c_2co_X1 : public BURS {
1560 private:
1561    _s_p_a_r_c_2co_X1(const _s_p_a_r_c_2co_X1&);               // no copy constructor
1562    void operator = (const _s_p_a_r_c_2co_X1&); // no assignment
1563 public:
1564    struct _s_p_a_r_c_2co_X1_StateRec * stack__, * stack_top__;
1565           void labeler(Inst & redex);
1566    inline virtual void operator () (Inst & redex) { labeler(redex); }
1567           void  reduce(Inst redex);
1568 private:
1569    public:
1570       inline _s_p_a_r_c_2co_X1() {}
1571 };
1572 void  _s_p_a_r_c_2co_X1_rewrite(Inst &  _x_)
1573 {  _s_p_a_r_c_2co_X1 _r_;
1574    _r_(_x_); return _r_.reduce(_x_);
1575 }
1576
1577
1578 ///////////////////////////////////////////////////////////////////////////////
1579 // State record for rewrite class _s_p_a_r_c_2co_X1
1580 ///////////////////////////////////////////////////////////////////////////////
1581 struct _s_p_a_r_c_2co_X1_StateRec {
1582    TreeTables::Cost cost[4]; // cost for each non-terminal
1583    struct { // accept rule number
1584       unsigned int _stmt : 4;
1585       unsigned int _con : 3;
1586       unsigned int _reg : 4;
1587    } rule;
1588 };
1589
1590 ///////////////////////////////////////////////////////////////////////////////
1591 // Accept rules tables for rewrite class _s_p_a_r_c_2co_X1
1592 ///////////////////////////////////////////////////////////////////////////////
1593 const char _s_p_a_r_c_2co_X1_stmt_accept[] = { -1, 17, 11, 10, 9, 8, 7, 6 };
1594
1595 const char _s_p_a_r_c_2co_X1_con_accept[] = { -1, 16, 15, 14, 13, 12 };
1596
1597 const char _s_p_a_r_c_2co_X1_reg_accept[] = { -1, 22, 21, 20, 19, 18, 5, 4, 3, 2, 1, 0 };
1598
1599 ///////////////////////////////////////////////////////////////////////////////
1600 // Closure methods for rewrite class _s_p_a_r_c_2co_X1
1601 ///////////////////////////////////////////////////////////////////////////////
1602 static void _s_p_a_r_c_2co_X1_reg_closure(Inst redex,int cost);
1603
1604 static void _s_p_a_r_c_2co_X1_reg_closure(Inst redex,int cost__)
1605 {
1606    _s_p_a_r_c_2co_X1_StateRec * _state_rec = (_s_p_a_r_c_2co_X1_StateRec *)(redex->get_state_rec());
1607    if (cost__ + 0 < _state_rec->cost[2])
1608    {  _state_rec->cost[2] = cost__ + 0;
1609       _state_rec->rule._stmt = 1;
1610    }
1611 }
1612
1613 void _s_p_a_r_c_2co_X1::labeler (Inst redex)
1614 {
1615    int cost__;
1616    _s_p_a_r_c_2co_X1_StateRec * _state_rec = (_s_p_a_r_c_2co_X1_StateRec *)mem[sizeof(_s_p_a_r_c_2co_X1_StateRec)];
1617    redex->set_state_rec(_state_rec);
1618    _state_rec->cost[0] = 0;
1619    _state_rec->cost[1] =
1620    _state_rec->cost[2] =
1621    _state_rec->cost[3] = 32767;
1622    {
1623       if (boxed(redex)) {
1624          switch (redex->untag()) {
1625             case a_Inst::tag_ADDD: {
1626                // Inst (12)
1627                } break;
1628             case a_Inst::tag_ADDF: {
1629                // Inst (13)
1630                } break;
1631             case a_Inst::tag_ADDI: {
1632                // Inst (14)
1633                } break;
1634             case a_Inst::tag_ADDP: {
1635                // Inst (15)
1636                } break;
1637             case a_Inst::tag_ADDU: {
1638                // Inst (16)
1639                } break;
1640             case a_Inst::tag_ARGB: {
1641                // Inst (17)
1642                } break;
1643             case a_Inst::tag_ARGD: {
1644                // Inst (18)
1645                } break;
1646             case a_Inst::tag_ARGF: {
1647                // Inst (19)
1648                } break;
1649             case a_Inst::tag_ARGI: {
1650                // Inst (20)
1651                } break;
1652             case a_Inst::tag_ARGP: {
1653                // Inst (21)
1654                } break;
1655             case a_Inst::tag_ASGNB: {
1656                // Inst (22)
1657                } break;
1658             case a_Inst::tag_ASGNC: {
1659                // Inst (23)
1660                if (boxed(_ASGNC(redex)->_1)) {} else {
1661                   switch ((int)_ASGNC(redex)->_1) {
1662                      case (int)VREGP: {
1663                         if (cost__ + 0 < state_rec->cost[2])
1664                         {   _state_rec->cost[2] = cost__ + 0;
1665                             _state_rec->rule._stmt = 7;
1666                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1667                         }} break;
1668                      default: {} break;
1669                   }
1670                }
1671                } break;
1672             case a_Inst::tag_ASGND: {
1673                // Inst (24)
1674                if (boxed(_ASGND(redex)->_1)) {} else {
1675                   switch ((int)_ASGND(redex)->_1) {
1676                      case (int)VREGP: {
1677                         if (cost__ + 0 < state_rec->cost[2])
1678                         {   _state_rec->cost[2] = cost__ + 0;
1679                             _state_rec->rule._stmt = 6;
1680                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1681                         }} break;
1682                      default: {} break;
1683                   }
1684                }
1685                } break;
1686             case a_Inst::tag_ASGNF: {
1687                // Inst (25)
1688                if (boxed(_ASGNF(redex)->_1)) {} else {
1689                   switch ((int)_ASGNF(redex)->_1) {
1690                      case (int)VREGP: {
1691                         if (cost__ + 0 < state_rec->cost[2])
1692                         {   _state_rec->cost[2] = cost__ + 0;
1693                             _state_rec->rule._stmt = 5;
1694                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1695                         }} break;
1696                      default: {} break;
1697                   }
1698                }
1699                } break;
1700             case a_Inst::tag_ASGNI: {
1701                // Inst (26)
1702                if (boxed(_ASGNI(redex)->_1)) {} else {
1703                   switch ((int)_ASGNI(redex)->_1) {
1704                      case (int)VREGP: {
1705                         if (cost__ + 0 < state_rec->cost[2])
1706                         {   _state_rec->cost[2] = cost__ + 0;
1707                             _state_rec->rule._stmt = 4;
1708                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1709                         }} break;
1710                      default: {} break;
1711                   }
1712                }
1713                } break;
1714             case a_Inst::tag_ASGNP: {
1715                // Inst (27)
1716                if (boxed(_ASGNP(redex)->_1)) {} else {
1717                   switch ((int)_ASGNP(redex)->_1) {
1718                      case (int)VREGP: {
1719                         if (cost__ + 0 < state_rec->cost[2])
1720                         {   _state_rec->cost[2] = cost__ + 0;
1721                             _state_rec->rule._stmt = 3;
1722                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1723                         }} break;
1724                      default: {} break;
1725                   }
1726                }
1727                } break;
1728             case a_Inst::tag_ASGNS: {
1729                // Inst (28)
1730                if (boxed(_ASGNS(redex)->_1)) {} else {
1731                   switch ((int)_ASGNS(redex)->_1) {
1732                      case (int)VREGP: {
1733                         if (cost__ + 0 < state_rec->cost[2])
1734                         {   _state_rec->cost[2] = cost__ + 0;
1735                             _state_rec->rule._stmt = 2;
1736                            _s_p_a_r_c_2co_X1_stmt_closure(redex, cost__ + 0);
1737                         }} break;
1738                      default: {} break;
1739                   }
1740                }
1741                } break;
1742             case a_Inst::tag_BANDU: {
1743                // Inst (29)
1744                } break;
1745             case a_Inst::tag_BCOMU: {
1746                // Inst (30)
1747                } break;
1748             case a_Inst::tag_BORU: {
1749                // Inst (31)
1750                } break;
1751             case a_Inst::tag_BXORU: {
1752                // Inst (32)
1753                } break;
1754             case a_Inst::tag_CALLB: {
1755                // Inst (33)
1756                } break;
1757             case a_Inst::tag_CALLD: {
1758                // Inst (34)
1759                } break;
1760             case a_Inst::tag_CALLF: {
1761                // Inst (35)
1762                } break;
1763             case a_Inst::tag_CALLI: {
1764                // Inst (36)
1765                } break;
1766             case a_Inst::tag_CALLV: {
1767                // Inst (37)
1768                } break;
1769             case a_Inst::tag_CVCI: {
1770                // Inst (38)
1771                } break;
1772             case a_Inst::tag_CVCU: {
1773                // Inst (39)
1774                } break;
1775             case a_Inst::tag_CVDF: {
1776                // Inst (40)
1777                } break;
1778             case a_Inst::tag_CVDI: {
1779                // Inst (41)
1780                } break;
1781             case a_Inst::tag_CVFD: {
1782                // Inst (42)
1783                } break;
1784             case a_Inst::tag_CVIC: {
1785                // Inst (43)
1786                } break;
1787             case a_Inst::tag_CVID: {
1788                // Inst (44)
1789                } break;
1790             case a_Inst::tag_CVIS: {
1791                // Inst (45)
1792                } break;
1793             case a_Inst::tag_CVIU: {
1794                // Inst (46)
1795                int _X2 = notarget(redex);
1796                if (cost__ + _X2 < state_rec->cost[1])
1797                {   _state_rec->cost[1] = cost__ + _X2;
1798                    _state_rec->rule._reg = 5;
1799                   _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + _X2);
1800                }} break;
1801             case a_Inst::tag_CVPU: {
1802                // Inst (47)
1803                int _X3 = notarget(redex);
1804                if (cost__ + _X3 < state_rec->cost[1])
1805                {   _state_rec->cost[1] = cost__ + _X3;
1806                    _state_rec->rule._reg = 4;
1807                   _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + _X3);
1808                }} break;
1809             case a_Inst::tag_CVSI: {
1810                // Inst (48)
1811                } break;
1812             case a_Inst::tag_CVSU: {
1813                // Inst (49)
1814                } break;
1815             case a_Inst::tag_CVUC: {
1816                // Inst (50)
1817                } break;
1818             case a_Inst::tag_CVUI: {
1819                // Inst (51)
1820                int _X4 = notarget(redex);
1821                if (cost__ + _X4 < state_rec->cost[1])
1822                {   _state_rec->cost[1] = cost__ + _X4;
1823                    _state_rec->rule._reg = 3;
1824                   _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + _X4);
1825                }} break;
1826             case a_Inst::tag_CVUP: {
1827                // Inst (52)
1828                int _X5 = notarget(redex);
1829                if (cost__ + _X5 < state_rec->cost[1])
1830                {   _state_rec->cost[1] = cost__ + _X5;
1831                    _state_rec->rule._reg = 2;
1832                   _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + _X5);
1833                }} break;
1834             case a_Inst::tag_CVUS: {
1835                // Inst (53)
1836                } break;
1837             case a_Inst::tag_DIVD: {
1838                // Inst (54)
1839                } break;
1840             case a_Inst::tag_DIVF: {
1841                // Inst (55)
1842                } break;
1843             case a_Inst::tag_DIVI: {
1844                // Inst (56)
1845                } break;
1846             case a_Inst::tag_DIVU: {
1847                // Inst (57)
1848                } break;
1849             case a_Inst::tag_EQD: {
1850                // Inst (58)
1851                } break;
1852             case a_Inst::tag_EQF: {
1853                // Inst (59)
1854                } break;
1855             case a_Inst::tag_EQI: {
1856                // Inst (60)
1857                } break;
1858             case a_Inst::tag_GED: {
1859                // Inst (61)
1860                } break;
1861             case a_Inst::tag_GEF: {
1862                // Inst (62)
1863                } break;
1864             case a_Inst::tag_GEI: {
1865                // Inst (63)
1866                } break;
1867             case a_Inst::tag_GEU: {
1868                // Inst (64)
1869                } break;
1870             case a_Inst::tag_GTD: {
1871                // Inst (65)
1872                } break;
1873             case a_Inst::tag_GTF: {
1874                // Inst (66)
1875                } break;
1876             case a_Inst::tag_GTI: {
1877                // Inst (67)
1878                } break;
1879             case a_Inst::tag_GTU: {
1880                // Inst (68)
1881                } break;
1882             case a_Inst::tag_INDIRB: {
1883                // Inst (69)
1884                } break;
1885             case a_Inst::tag_INDIRC: {
1886                // Inst (70)
1887                if (boxed(_INDIRC(redex)->INDIRC)) {} else {
1888                   switch ((int)_INDIRC(redex)->INDIRC) {
1889                      case (int)VREGP: {
1890                         if (cost__ + 0 < state_rec->cost[1])
1891                         {   _state_rec->cost[1] = cost__ + 0;
1892                             _state_rec->rule._reg = 11;
1893                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1894                         }} break;
1895                      default: {} break;
1896                   }
1897                }
1898                } break;
1899             case a_Inst::tag_INDIRD: {
1900                // Inst (71)
1901                if (boxed(_INDIRD(redex)->INDIRD)) {} else {
1902                   switch ((int)_INDIRD(redex)->INDIRD) {
1903                      case (int)VREGP: {
1904                         if (cost__ + 0 < state_rec->cost[1])
1905                         {   _state_rec->cost[1] = cost__ + 0;
1906                             _state_rec->rule._reg = 10;
1907                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1908                         }} break;
1909                      default: {} break;
1910                   }
1911                }
1912                } break;
1913             case a_Inst::tag_INDIRF: {
1914                // Inst (72)
1915                if (boxed(_INDIRF(redex)->INDIRF)) {} else {
1916                   switch ((int)_INDIRF(redex)->INDIRF) {
1917                      case (int)VREGP: {
1918                         if (cost__ + 0 < state_rec->cost[1])
1919                         {   _state_rec->cost[1] = cost__ + 0;
1920                             _state_rec->rule._reg = 9;
1921                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1922                         }} break;
1923                      default: {} break;
1924                   }
1925                }
1926                } break;
1927             case a_Inst::tag_INDIRI: {
1928                // Inst (73)
1929                if (boxed(_INDIRI(redex)->INDIRI)) {} else {
1930                   switch ((int)_INDIRI(redex)->INDIRI) {
1931                      case (int)VREGP: {
1932                         if (cost__ + 0 < state_rec->cost[1])
1933                         {   _state_rec->cost[1] = cost__ + 0;
1934                             _state_rec->rule._reg = 8;
1935                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1936                         }} break;
1937                      default: {} break;
1938                   }
1939                }
1940                } break;
1941             case a_Inst::tag_INDIRP: {
1942                // Inst (74)
1943                if (boxed(_INDIRP(redex)->INDIRP)) {} else {
1944                   switch ((int)_INDIRP(redex)->INDIRP) {
1945                      case (int)VREGP: {
1946                         if (cost__ + 0 < state_rec->cost[1])
1947                         {   _state_rec->cost[1] = cost__ + 0;
1948                             _state_rec->rule._reg = 7;
1949                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1950                         }} break;
1951                      default: {} break;
1952                   }
1953                }
1954                } break;
1955             case a_Inst::tag_INDIRS: {
1956                // Inst (75)
1957                if (boxed(_INDIRS(redex)->INDIRS)) {} else {
1958                   switch ((int)_INDIRS(redex)->INDIRS) {
1959                      case (int)VREGP: {
1960                         if (cost__ + 0 < state_rec->cost[1])
1961                         {   _state_rec->cost[1] = cost__ + 0;
1962                             _state_rec->rule._reg = 6;
1963                            _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
1964                         }} break;
1965                      default: {} break;
1966                   }
1967                }
1968                } break;
1969             case a_Inst::tag_JUMPV: {
1970                // Inst (76)
1971                } break;
1972             case a_Inst::tag_LED: {
1973                // Inst (77)
1974                } break;
1975             case a_Inst::tag_LEF: {
1976                // Inst (78)
1977                } break;
1978             case a_Inst::tag_LEI: {
1979                // Inst (79)
1980                } break;
1981             case a_Inst::tag_LEU: {
1982                // Inst (80)
1983                } break;
1984             case a_Inst::tag_LOADB: {
1985                // Inst (81)
1986                } break;
1987             case a_Inst::tag_LOADC: {
1988                // Inst (82)
1989                } break;
1990             case a_Inst::tag_LOADD: {
1991                // Inst (83)
1992                } break;
1993             case a_Inst::tag_LOADF: {
1994                // Inst (84)
1995                } break;
1996             case a_Inst::tag_LOADI: {
1997                // Inst (85)
1998                } break;
1999             case a_Inst::tag_LOADP: {
2000                // Inst (86)
2001                } break;
2002             case a_Inst::tag_LOADS: {
2003                // Inst (87)
2004                } break;
2005             case a_Inst::tag_LOADU: {
2006                // Inst (88)
2007                } break;
2008             case a_Inst::tag_LSHI: {
2009                // Inst (89)
2010                } break;
2011             case a_Inst::tag_LSHU: {
2012                // Inst (90)
2013                } break;
2014             case a_Inst::tag_LTD: {
2015                // Inst (91)
2016                } break;
2017             case a_Inst::tag_LTF: {
2018                // Inst (92)
2019                } break;
2020             case a_Inst::tag_LTI: {
2021                // Inst (93)
2022                } break;
2023             case a_Inst::tag_LTU: {
2024                // Inst (94)
2025                } break;
2026             case a_Inst::tag_MODI: {
2027                // Inst (95)
2028                } break;
2029             case a_Inst::tag_MODU: {
2030                // Inst (96)
2031                } break;
2032             case a_Inst::tag_MULD: {
2033                // Inst (97)
2034                } break;
2035             case a_Inst::tag_MULF: {
2036                // Inst (98)
2037                } break;
2038             case a_Inst::tag_MULI: {
2039                // Inst (99)
2040                } break;
2041             case a_Inst::tag_MULU: {
2042                // Inst (100)
2043                } break;
2044             case a_Inst::tag_NED: {
2045                // Inst (101)
2046                } break;
2047             case a_Inst::tag_NEF: {
2048                // Inst (102)
2049                } break;
2050             case a_Inst::tag_NEI: {
2051                // Inst (103)
2052                } break;
2053             case a_Inst::tag_NEGD: {
2054                // Inst (104)
2055                } break;
2056             case a_Inst::tag_NEGF: {
2057                // Inst (105)
2058                } break;
2059             case a_Inst::tag_NEGI: {
2060                // Inst (106)
2061                } break;
2062             case a_Inst::tag_RETD: {
2063                // Inst (107)
2064                } break;
2065             case a_Inst::tag_RETF: {
2066                // Inst (108)
2067                } break;
2068             case a_Inst::tag_RETI: {
2069                // Inst (109)
2070                } break;
2071             case a_Inst::tag_RSHI: {
2072                // Inst (110)
2073                } break;
2074             case a_Inst::tag_RSHU: {
2075                // Inst (111)
2076                } break;
2077             case a_Inst::tag_SUBD: {
2078                // Inst (112)
2079                } break;
2080             case a_Inst::tag_SUBF: {
2081                // Inst (113)
2082                } break;
2083             case a_Inst::tag_SUBI: {
2084                // Inst (114)
2085                } break;
2086             case a_Inst::tag_SUBP: {
2087                // Inst (115)
2088                } break;
2089             default: {
2090                // Inst (116)
2091                } break;
2092          }
2093       } else {
2094          switch ((int)redex) {
2095             case (int)ADDRFP: {
2096                // Inst (0)
2097                } break;
2098             case (int)ADDRGP: {
2099                // Inst (1)
2100                if (cost__ + 0 < state_rec->cost[1])
2101                {   _state_rec->cost[1] = cost__ + 0;
2102                    _state_rec->rule._reg = 1;
2103                   _s_p_a_r_c_2co_X1_reg_closure(redex, cost__ + 0);
2104                }} break;
2105             case (int)ADDRLP: {
2106                // Inst (2)
2107                } break;
2108             case (int)CNSTC: {
2109                // Inst (3)
2110                if (cost__ + 0 < state_rec->cost[3])
2111                {   _state_rec->cost[3] = cost__ + 0;
2112                    _state_rec->rule._con = 5;
2113                   _s_p_a_r_c_2co_X1_con_closure(redex, cost__ + 0);
2114                }} break;
2115             case (int)CNSTD: {
2116                // Inst (4)
2117                } break;
2118             case (int)CNSTF: {
2119                // Inst (5)
2120                } break;
2121             case (int)CNSTI: {
2122                // Inst (6)
2123                if (cost__ + 0 < state_rec->cost[3])
2124                {   _state_rec->cost[3] = cost__ + 0;
2125                    _state_rec->rule._con = 4;
2126                   _s_p_a_r_c_2co_X1_con_closure(redex, cost__ + 0);
2127                }} break;
2128             case (int)CNSTP: {
2129                // Inst (7)
2130                if (cost__ + 0 < state_rec->cost[3])
2131                {   _state_rec->cost[3] = cost__ + 0;
2132                    _state_rec->rule._con = 3;
2133                   _s_p_a_r_c_2co_X1_con_closure(redex, cost__ + 0);
2134                }} break;
2135             case (int)CNSTS: {
2136                // Inst (8)
2137                if (cost__ + 0 < state_rec->cost[3])
2138                {   _state_rec->cost[3] = cost__ + 0;
2139                    _state_rec->rule._con = 2;
2140                   _s_p_a_r_c_2co_X1_con_closure(redex, cost__ + 0);
2141                }} break;
2142             case (int)CNSTU: {
2143                // Inst (9)
2144                if (cost__ + 0 < state_rec->cost[3])
2145                {   _state_rec->cost[3] = cost__ + 0;
2146                    _state_rec->rule._con = 1;
2147                   _s_p_a_r_c_2co_X1_con_closure(redex, cost__ + 0);
2148                }} break;
2149             case (int)LABELV: {
2150                // Inst (10)
2151                } break;
2152             default: {
2153                // Inst (11)
2154                } break;
2155          }
2156       }
2157    }
2158
2159 }
2160
2161 void _s_p_a_r_c_2co_X1::reduce(Inst redex)
2162 {
2163    int r__ = (_s_p_a_r_c_2co_X1_StateRec *)(redex->get_state_rec());
2164    switch (r__) {
2165       case 22: { // ADDRGP
2166           "set %a,%%%c\n"  1; } break;
2167       case 21: { // CVUP reg
2168          reduce(_CVUP(redex)->CVUP);
2169           "%0"  notarget(a); } break;
2170       case 20: { // CVUI reg
2171          reduce(_CVUI(redex)->CVUI);
2172           "%0"  notarget(a); } break;
2173       case 19: { // CVPU reg
2174          reduce(_CVPU(redex)->CVPU);
2175           "%0"  notarget(a); } break;
2176       case 18: { // CVIU reg
2177          reduce(_CVIU(redex)->CVIU);
2178           "%0"  notarget(a); } break;
2179       case 17: { // reg
2180          reduce(redex);
2181
2182          { redex = ""; r__ = 1; goto replacement__; }} break;
2183       case 16: { // CNSTU
2184
2185          { redex = "%a"; r__ = 1; goto replacement__; }} break;
2186       case 15: { // CNSTS
2187
2188          { redex = "%a"; r__ = 1; goto replacement__; }} break;
2189       case 14: { // CNSTP
2190
2191          { redex = "%a"; r__ = 1; goto replacement__; }} break;
2192       case 13: { // CNSTI
2193
2194          { redex = "%a"; r__ = 1; goto replacement__; }} break;
2195       case 12: { // CNSTC
2196
2197          { redex = "%a"; r__ = 1; goto replacement__; }} break;
2198       case 11: { // ASGNS (VREGP, reg)
2199          reduce(_ASGNS(redex)->_2);
2200
2201          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2202       case 10: { // ASGNP (VREGP, reg)
2203          reduce(_ASGNP(redex)->_2);
2204
2205          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2206       case 9: { // ASGNI (VREGP, reg)
2207          reduce(_ASGNI(redex)->_2);
2208
2209          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2210       case 8: { // ASGNF (VREGP, reg)
2211          reduce(_ASGNF(redex)->_2);
2212
2213          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2214       case 7: { // ASGND (VREGP, reg)
2215          reduce(_ASGND(redex)->_2);
2216
2217          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2218       case 6: { // ASGNC (VREGP, reg)
2219          reduce(_ASGNC(redex)->_2);
2220
2221          { redex = "# write register\n"; r__ = 1; goto replacement__; }} break;
2222       case 5: { // INDIRS VREGP
2223
2224          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2225       case 4: { // INDIRP VREGP
2226
2227          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2228       case 3: { // INDIRI VREGP
2229
2230          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2231       case 2: { // INDIRF VREGP
2232
2233          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2234       case 1: { // INDIRD VREGP
2235
2236          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2237       case 0: { // INDIRC VREGP
2238
2239          { redex = "# read register\n"; r__ = 1; goto replacement__; }} break;
2240    }
2241 }
2242
2243 /*
2244 ------------------------------- Statistics -------------------------------
2245 Merge matching rules         = yes
2246 Number of DFA nodes merged   = 1511
2247 Number of ifs generated      = 13
2248 Number of switches generated = 14
2249 Number of labels             = 0
2250 Number of gotos              = 0
2251 Adaptive matching            = disabled
2252 Fast string matching         = disabled
2253 Inline downcasts             = disabled
2254 --------------------------------------------------------------------------
2255 */