Boomerang: decoder_low.cpp Source File

00001 #define sign_extend(N,SIZE) (((int)((N) << (sizeof(unsigned)*8-(SIZE)))) >> (sizeof(unsigned)*8-(SIZE)))
00002 #include <assert.h>
00003 
00004 #line 2 "machine/mc68k/decoder_low.m"
00005 /*==============================================================================
00006  * FILE:       decoder_low.m
00007  * OVERVIEW:   Implementation of the low level mc68000 specific parts of the
00008  *             NJMCDecoder class.
00009  *============================================================================*/
00010 
00011 /* $Revision: 1.1 $
00012  * $Id: decoder_low.cpp,v 1.1 2002/08/08 05:59:31 quantumg Exp $
00013  * Created by Cristina 04 Feb 2000
00014  *
00015  * Based on: 
00016  *  m68k__assembly.m
00017  *  written by Owen Braun
00018  *  ocbraun@princeton.edu
00019  *  created 4/8/96 3:57 am
00020  *
00021  *  M68kInstr method decodeInstr which uses Toolkit matching statement
00022  *  to decode instruction and generate _assembly-language representation
00023  *
00024  * 04 Feb 00 - Integration with UQBT's .prc loader (PalmBinaryFile)
00025  * 07 Feb 00 - Mike: Made numInstrWords a reference, and initialised to 1
00026  * 09 Feb 00 - Cristina: changed register display syntax to conform to 
00027  *      Motorola's assembly syntax.
00028  *      unlk is now a non factored constructor
00029  *      Added system trap function name support 
00030  * 11 Feb 00 - Mike: started making RTL version from disassembler
00031  * 13 Feb 00 - Cristina: continued 
00032  * 15 Feb 00 - Mike: inserted addressing mode code
00033  * 21 Feb 00 - Mike: support for -(an) and (an)+ (bump and bumpr)
00034  * 22 Feb 00 - Cristina: for ADDQ and SUBQ we need 5 chars to match SSL name
00035  * 25 Feb 00 - Mike: Fixed move (a7)+,d3 (was faulting)
00036  * 24 Mar 00 - Mike: Converted sizes to bits
00037  * 27 Mar 00 - Mike: Fixed instructions like addaw.ex that were not having
00038  *                the .ex removed before 2nd last char (using chopBoth())
00039  * 07 Apr 00 - Mike: Fixed semantics of movew d3, a0 (sign extends)
00040  * 13 Apr 00 - Mike: Fixed side effects of the above; was putting the BUMP
00041  *                at the wrong place
00042  * 22 Mar 01 - Mike: Fixed a fault when decoding mem to mem move; initialisation
00043  *                of RTs to an empty list was in the wrong place
00044  * 01 Aug 01 - Mike: Added some #includes; would not compile without these
00045  */
00046 
00047 #include <assert.h>
00048 #include <stdio.h>
00049 #include "global.h" 
00050 #include "decoder.h"
00051 #include "ss.h"
00052 #include "rtl.h"
00053 
00054 // File scope globals
00055 static bool IsTrap = false;
00056 static bool prevIsTrap = false;
00057 static char sslName[20];            // Modifiable; [name] from the toolkit is
00058                                     // in the text section and read-only
00059 static int temp1 = 0;               // id of a temp; initialised on first use
00060 
00061 /*==============================================================================
00062  * FUNCTION:        getWord
00063  * OVERVIEW:        Returns the word starting at the given address.
00064  * PARAMETERS:      lc - host address at which to decode 
00065  * RETURNS:         the decoded double
00066  *============================================================================*/
00067 SWord getWord (unsigned lc)
00068 /* get2Bytes - returns next 2-Byte from image pointed to by lc.
00069    Fetch in a big-endian manner  */
00070 {
00071     return (SWord)((*(Byte *)lc << 8) + *(Byte *)(lc+1));
00072 }
00073 
00074 
00075 /*==============================================================================
00076  * FUNCTION:        decodeTrapName
00077  * OVERVIEW:        Places the name of the system call in _assembly.
00078  * PARAMETERS:      pc - address at which to decode 
00079  * RETURNS:         nil
00080  *============================================================================*/
00081 void decodeTrapName (ADDRESS pc)
00082 {
00083 // Need to think about what to do here
00084     //fprintf (stderr, "dc.w #%d\t// ", (SWord)(*(SWord *)pc));  
00085     //fprintf (stderr, "%s", trapNames[*(SWord *)pc - sysTrapBase]); 
00086 }
00087 
00088 // Convert names like addb.ex, orl, mulu to appropriate SSL form
00089 // Puts resultant name into static (file scope) global sslName
00090 void chopDotex(char* name)
00091 {
00092     int l = strlen(name);
00093     strcpy(sslName, name);
00094     if (name[l-3] == '.')           // Has .ex
00095         l -= 3;                     // Discard the .ex
00096     sslName[l] = '\0';
00097 }
00098 
00099 // Chop 2nd last character from a name, e.g. roxrib -> roxrb
00100 void chop2ndLast(char* name)
00101 {
00102     int l = strlen(name);
00103     strcpy(sslName, name);
00104     sslName[l-2] = name[l-1];
00105     sslName[l-1] = '\0';
00106 }
00107 
00108 // Chop .ex (if present) AND 2nd last character from a name
00109 // e.g. roxrib.ex -> roxrb
00110 void chopBoth(char* name)
00111 {
00112     int l = strlen(name);
00113     strcpy(sslName, name);
00114     if (name[l-3] == '.')           // Has .ex
00115         l -= 3;                     // Discard the .ex
00116     sslName[l] = '\0';
00117     sslName[l-2] = name[l-1];
00118     sslName[l-1] = '\0';
00119 }
00120 
00121 /*==============================================================================
00122  * FUNCTION:       bumpRegister
00123  * OVERVIEW:       Add an RTAssgn to bump a register by an amount
00124  * PARAMETERS:     RTs: list of RTs to add this RTAssgn to
00125  *                 bump: amount to add to the register
00126  *                 bumpr: register to bump
00127  * RETURNS:        <nothing>
00128  *============================================================================*/
00129 void bumpRegister(list<RT*>* RTs, int bump, int bumpr)
00130 {
00131     // Lhs: r[bumpr]
00132     SemStr* lhs = new SemStr(32);
00133     lhs->push(idRegOf); lhs->push(idIntConst); lhs->push(bumpr);
00134     // Rhs: r[bumpr] + bump
00135     SemStr* rhs = new SemStr(32);
00136     rhs->push(idPlus);
00137     rhs->push(idRegOf); rhs->push(idIntConst); rhs->push(bumpr);
00138     rhs->push(idIntConst); rhs->push(bump);
00139     RTAssgn* pRT = new RTAssgn(lhs, rhs, 32);
00140     RTs->push_back(pRT);
00141 }
00142 
00143 /*==============================================================================
00144  * FUNCTION:       assignTemp
00145  * OVERVIEW:       Add an RTAssgn to assign src to temp1
00146  * PARAMETERS:     src: Pointer to SemStr for src
00147  *                 size: size of the assignment, in bits
00148  *                 temp: this function sets this parameter to point to a copy
00149  *                  of a SemStr that represents "temp1"
00150  * RETURNS:        Pointer to the assignment RT
00151  *============================================================================*/
00152 RT* assignTemp(SemStr* src, int size, SemStr*& temp)
00153 {
00154     if (temp1 == 0) temp1 = theSemTable.addItem("temp1");
00155     // Lhs: r[temp1]
00156     SemStr* lhs = new SemStr(size);
00157     lhs->push(idRegOf); lhs->push(idTemp); lhs->push(temp1);
00158     // Rhs is just src
00159     RTAssgn* pRT = new RTAssgn(lhs, src, size);
00160     temp = new SemStr(*lhs);
00161     return pRT;
00162 }
00163 
00164 /*==============================================================================
00165  * FUNCTION:       sgnExTemp
00166  * OVERVIEW:       Add an RTAssgn to sign extend src to temp1
00167  * PARAMETERS:     dest: Pointer to SemStr for dest
00168  *                 size: size of the source, in bits
00169  *                 size2: size of the destination, in bits
00170  *                 temp: this function sets this parameter to point to a copy
00171  *                  of a SemStr that represents "temp1"
00172  * RETURNS:        Pointer to the assignment RT
00173  *============================================================================*/
00174 RT* sgnExTemp(SemStr* src, int size, int size2, SemStr*& temp)
00175 {
00176     if (temp1 == 0) temp1 = theSemTable.addItem("temp1");
00177     // Lhs: r[temp1]
00178     SemStr* lhs = new SemStr(size2);
00179     lhs->push(idRegOf); lhs->push(idTemp); lhs->push(temp1);
00180     // Rhs is just sgnex(size, size2, src)
00181     src->prep(size2);
00182     src->prep(size);
00183     src->prep(idSgnEx);
00184     RTAssgn* pRT = new RTAssgn(lhs, src, size2);
00185     temp = new SemStr(*lhs);
00186     return pRT;
00187 }
00188 
00189 // Macro to handle bumping register if reqd
00190 #define ADDBUMP {if (bump) bumpRegister(RTs, bump, bumpr);}
00191 
00192 /*==============================================================================
00193  * FUNCTION:       NJMCDecoder::decodeLowLevelInstruction
00194  * OVERVIEW:       Decodes a machine instruction and returns an instantiated
00195  *                 list of RTs.
00196  * PARAMETERS:     hostPC - the address of the pc in the loaded Elf object
00197  *                 pc - the virtual address of the pc
00198  *                 result - a reference parameter that has a field that will be
00199  *                   set to false if an invalid or UNIMP instruction was decoded
00200  * RETURNS:        the instantiated list of RTs
00201  *============================================================================*/
00202 list<RT*>* NJMCDecoder::decodeLowLevelInstruction (ADDRESS hostPC, ADDRESS pc,
00203     DecodeResult& result) 
00204 {
00205   //  This uses both patterned and non-patterned constructors in
00206   //  its matching statement. For the non-patterened constructors,
00207   //  all decoding variables are set here. For the patterned constructors,
00208   //  the name of the opcode is copied into the opcodeStr variable and
00209   //  the decoding variables are set by a "second round" decoding method.
00210 
00211     result.numBytes = 0;
00212     prevIsTrap = IsTrap;            // Remember if last instr was a trap
00213     IsTrap = false;
00214     int delta = hostPC - pc;
00215 
00216     // The list of instantiated RTs.
00217     list<RT*>* RTs = NULL;
00218 
00219 
00220 
00221 #line 217 "machine/mc68k/decoder_low.m"
00222 { 
00223   dword MATCH_p = 
00224     
00225     #line 217 "machine/mc68k/decoder_low.m"
00226     hostPC
00227     ;
00228   char *MATCH_name;
00229   static char *MATCH_name_sz_1[] = {"orrb", "oriw", "oril", "bset", };
00230   static char *MATCH_name_sz_3[] = {"orrb.ex", "andiw", "andil", "bset.ex", };
00231   static char *MATCH_name_sz_5[] = {"andrb", "subiw", "subil", "divu", };
00232   static char *MATCH_name_sz_7[] = {
00233     "andrb.ex", "addiw", "addil", "divu.ex", 
00234   };
00235   static char *MATCH_name_sz_12[] = {(char *)0, "eoriw", "eoril", "mulu", };
00236   static char *MATCH_name_sz_14[] = {
00237     (char *)0, "cmpiw", "cmpil", "mulu.ex", 
00238   };
00239   static char *MATCH_name_sz_15[] = {(char *)0, "bchg", "bclr", };
00240   static char *MATCH_name_sz_17[] = {(char *)0, "oriw.ex", "oril.ex", };
00241   static char *MATCH_name_sz_19[] = {(char *)0, "andiw.ex", "andil.ex", };
00242   static char *MATCH_name_sz_21[] = {(char *)0, "subiw.ex", "subil.ex", };
00243   static char *MATCH_name_sz_23[] = {(char *)0, "addiw.ex", "addil.ex", };
00244   static char *MATCH_name_sz_28[] = {(char *)0, "eoriw.ex", "eoril.ex", };
00245   static char *MATCH_name_sz_30[] = {(char *)0, "cmpiw.ex", "cmpil.ex", };
00246   static char *MATCH_name_sz_31[] = {(char *)0, "bchg.ex", "bclr.ex", };
00247   static char *MATCH_name_adrm_35[] = {
00248     "moveb", "moveb", "moveb", "moveb", "moveb", "moveb.ex", "moveb.ex", 
00249     "rorrb", 
00250   };
00251   static char *MATCH_name_reg2_36[] = {
00252     "moveb.ex", "moveb.exl", "moveb.ex", "moveb.ex", "moveb.ex", "rts", 
00253     "trapv", "rtr", 
00254   };
00255   static char *MATCH_name_adrm_37[] = {
00256     "moveb.mx", "moveb.mx", "moveb.mx", "moveb.mx", "moveb.mx", "moveb.emx", 
00257     "moveb.emx", "rorrw", 
00258   };
00259   static char *MATCH_name_reg2_38[] = {
00260     "moveb.emx", "moveb.emxl", "moveb.emx", "moveb.emx", "moveb.emx", 
00261   };
00262   static char *MATCH_name_MDadrm_39[] = {
00263     "moveb", "moveb", "moveb", "moveb", "moveb", "moveb.mx", "moveb.mx", 
00264     "moveb.mx", 
00265   };
00266   static char *MATCH_name_MDadrm_40[] = {
00267     "moveb.ex", "moveb.ex", "moveb.ex", "moveb.ex", "moveb.ex", "moveb.emx", 
00268     "moveb.emx", "moveb.emx", 
00269   };
00270   static char *MATCH_name_MDadrm_41[] = {
00271     "moveb.exl", "moveb.exl", "moveb.exl", "moveb.exl", "moveb.exl", 
00272     "moveb.emxl", "moveb.emxl", "moveb.emxl", 
00273   };
00274   static char *MATCH_name_adrm_42[] = {
00275     "movel", "movel", "movel", "movel", "movel", "movel.ex", "movel.ex", 
00276     "rorrl", 
00277   };
00278   static char *MATCH_name_reg2_43[] = {
00279     "movel.ex", "movel.exl", "movel.ex", "movel.ex", "movel.exl", 
00280   };
00281   static char *MATCH_name_adrm_44[] = {
00282     "movel.mx", "movel.mx", "movel.mx", "movel.mx", "movel.mx", "movel.emx", 
00283     "movel.emx", "rolrb", 
00284   };
00285   static char *MATCH_name_reg2_45[] = {
00286     "movel.emx", "movel.emxl", "movel.emx", "movel.emx", "movel.emxl", 
00287   };
00288   static char *MATCH_name_MDadrm_46[] = {
00289     "movel", "movel", "movel", "movel", "movel", "movel.mx", "movel.mx", 
00290     "movel.mx", 
00291   };
00292   static char *MATCH_name_MDadrm_47[] = {
00293     "movel.ex", "movel.ex", "movel.ex", "movel.ex", "movel.ex", "movel.emx", 
00294     "movel.emx", "movel.emx", 
00295   };
00296   static char *MATCH_name_MDadrm_48[] = {
00297     "movel.exl", "movel.exl", "movel.exl", "movel.exl", "movel.exl", 
00298     "movel.emxl", "movel.emxl", "movel.emxl", 
00299   };
00300   static char *MATCH_name_adrm_49[] = {
00301     "movew", "movew", "movew", "movew", "movew", "movew.ex", "movew.ex", 
00302     "rolrw", 
00303   };
00304   static char *MATCH_name_reg2_50[] = {
00305     "movew.ex", "movew.exl", "movew.ex", "movew.ex", "movew.ex", 
00306   };
00307   static char *MATCH_name_adrm_51[] = {
00308     "movew.mx", "movew.mx", "movew.mx", "movew.mx", "movew.mx", "movew.emx", 
00309     "movew.emx", "rolrl", 
00310   };
00311   static char *MATCH_name_reg2_52[] = {
00312     "movew.emx", "movew.emxl", "movew.emx", "movew.emx", "movew.emx", 
00313   };
00314   static char *MATCH_name_MDadrm_53[] = {
00315     "movew", "movew", "movew", "movew", "movew", "movew.mx", "movew.mx", 
00316     "movew.mx", 
00317   };
00318   static char *MATCH_name_MDadrm_54[] = {
00319     "movew.ex", "movew.ex", "movew.ex", "movew.ex", "movew.ex", "movew.emx", 
00320     "movew.emx", "movew.emx", 
00321   };
00322   static char *MATCH_name_MDadrm_55[] = {
00323     "movew.exl", "movew.exl", "movew.exl", "movew.exl", "movew.exl", 
00324     "movew.emxl", "movew.emxl", "movew.emxl", 
00325   };
00326   static char *MATCH_name_reg1_56[] = {
00327     "negxb", "clrb", "negb", "notb", "nbcd", "tstb", (char *)0, "jsr", 
00328   };
00329   static char *MATCH_name_reg1_57[] = {
00330     "negxb.ex", "clrb.ex", "negb.ex", "notb.ex", "nbcd.ex", "tstb.ex", 
00331     (char *)0, "jsr.ex", 
00332   };
00333   static char *MATCH_name_adrm_58[] = {
00334     "negxw", "addqb", "negxw", "negxw", "negxw", "negxw.ex", "negxw.ex", 
00335   };
00336   static char *MATCH_name_reg2_59[] = {
00337     "negxw.ex", "negxw.ex", "pea.ex", "pea.ex", "moveToCCR.ex", 
00338   };
00339   static char *MATCH_name_adrm_60[] = {
00340     "clrw", "subqb", "clrw", "clrw", "clrw", "clrw.ex", "clrw.ex", 
00341   };
00342   static char *MATCH_name_reg2_61[] = {
00343     "clrw.ex", "clrw.ex", "moveToCCR.ex", "rte", "illegal", 
00344   };
00345   static char *MATCH_name_adrm_62[] = {
00346     "negw", "addqw", "negw", "negw", "negw", "negw.ex", "negw.ex", 
00347   };
00348   static char *MATCH_name_reg2_63[] = {
00349     "negw.ex", "negw.ex", "jmp.ex", "moveToCCR.ex", "chk.ex", 
00350   };
00351   static char *MATCH_name_adrm_64[] = {
00352     "notw", "subqw", "notw", "notw", "notw", "notw.ex", "notw.ex", 
00353   };
00354   static char *MATCH_name_reg2_65[] = {
00355     "notw.ex", "notw.ex", "chk.ex", "jmp.ex", "divs.ex", 
00356   };
00357   static char *MATCH_name_adrm_66[] = {
00358     "swap", "addql", "pea", "tstw", "tstw", "pea.ex", "pea.ex", 
00359   };
00360   static char *MATCH_name_reg2_67[] = {
00361     "pea.ex", "pea.ex", "divs.ex", "chk.ex", "subrb.ex", 
00362   };
00363   static char *MATCH_name_adrm_68[] = {
00364     "tstw", "subql", "tstw", "unlk", "moveFromCCR", "tstw.ex", "tstw.ex", 
00365   };
00366   static char *MATCH_name_reg2_69[] = {
00367     "tstw.ex", "tstw.ex", "subrb.ex", "divs.ex", "subrw.ex", 
00368   };
00369   static char *MATCH_name_reg2_71[] = {
00370     "reset", "nop", "subrw.ex", "subrb.ex", "subrl.ex", 
00371   };
00372   static char *MATCH_name_reg1_72[] = {
00373     "negxl", "clrl", "negl", "notl", "extw", "tstl", 
00374   };
00375   static char *MATCH_name_reg1_73[] = {
00376     "negxl.ex", "clrl.ex", "negl.ex", "notl.ex", (char *)0, "tstl.ex", 
00377   };
00378   static char *MATCH_name_adrm_74[] = {
00379     "moveFromCCR", "sbcdm", "moveFromCCR", "moveFromCCR", "moveToCCR", 
00380     "moveFromCCR.ex", "moveFromCCR.ex", 
00381   };
00382   static char *MATCH_name_reg2_75[] = {
00383     "moveFromCCR.ex", "moveFromCCR.ex", "subrl.ex", "subrw.ex", "subaw.ex", 
00384   };
00385   static char *MATCH_name_adrm_76[] = {
00386     "moveToCCR", "subrb", "moveToCCR", "moveToCCR", "tas", "moveToCCR.ex", 
00387     "moveToCCR.ex", 
00388   };
00389   static char *MATCH_name_reg2_77[] = {
00390     "moveToCCR.ex", "moveToCCR.ex", "subaw.ex", "subrl.ex", "subal.ex", 
00391   };
00392   static char *MATCH_name_adrm_78[] = {
00393     "extl", "subrw", "tas", "tas", "chk", "tas.ex", "tas.ex", 
00394   };
00395   static char *MATCH_name_adrm_79[] = {
00396     "tas", "subrl", "jmp", "chk", "addqb", "jmp.ex", "jmp.ex", 
00397   };
00398   static char *MATCH_name_reg2_80[] = {
00399     "tas.ex", "tas.ex", "subal.ex", "subaw.ex", "cmpb.ex", 
00400   };
00401   static char *MATCH_name_reg2_81[] = {
00402     "jmp.ex", "jmp.ex", "cmpb.ex", "subal.ex", "cmpw.ex", 
00403   };
00404   static char *MATCH_name_adrm_82[] = {
00405     "chk", "subaw", "chk", "addqb", "subqb", "chk.ex", "chk.ex", 
00406   };
00407   static char *MATCH_name_reg2_83[] = {
00408     "chk.ex", "chk.ex", "cmpw.ex", "cmpb.ex", "cmpl.ex", 
00409   };
00410   static char *MATCH_name_adrm_84[] = {
00411     "addqb", "subxmb", "addqb", "subqb", "addqw", "addqb.ex", "addqb.ex", 
00412   };
00413   static char *MATCH_name_reg2_85[] = {
00414     "addqb.ex", "addqb.ex", "cmpl.ex", "cmpw.ex", "cmpaw.ex", 
00415   };
00416   static char *MATCH_name_adrm_86[] = {
00417     "subqb", "subxmw", "subqb", "addqw", "subqw", "subqb.ex", "subqb.ex", 
00418   };
00419   static char *MATCH_name_reg2_87[] = {
00420     "subqb.ex", "subqb.ex", "cmpaw.ex", "cmpl.ex", "cmpal.ex", 
00421   };
00422   static char *MATCH_name_adrm_88[] = {
00423     "addqw", "subxml", "addqw", "subqw", "addql", "addqw.ex", "addqw.ex", 
00424   };
00425   static char *MATCH_name_reg2_89[] = {
00426     "addqw.ex", "addqw.ex", "cmpal.ex", "cmpaw.ex", "muls.ex", 
00427   };
00428   static char *MATCH_name_adrm_90[] = {
00429     "subqw", "subal", "subqw", "addql", "subql", "subqw.ex", "subqw.ex", 
00430   };
00431   static char *MATCH_name_reg2_91[] = {
00432     "subqw.ex", "subqw.ex", "muls.ex", "cmpal.ex", "addrb.ex", 
00433   };
00434   static char *MATCH_name_adrm_92[] = {
00435     "addql", "cmpb", "addql", "subql", "ormb", "addql.ex", "addql.ex", 
00436   };
00437   static char *MATCH_name_reg2_93[] = {
00438     "addql.ex", "addql.ex", "addrb.ex", "muls.ex", "addrw.ex", 
00439   };
00440   static char *MATCH_name_adrm_94[] = {
00441     "subql", "cmpw", "subql", "ormb", "ormw", "subql.ex", "subql.ex", 
00442   };
00443   static char *MATCH_name_reg2_95[] = {
00444     "subql.ex", "subql.ex", "addrw.ex", "addrb.ex", "addrl.ex", 
00445   };
00446   static char *MATCH_name_cond_96[] = {
00447     "st", "sf", "shi", "sls", "scc", "scs", "sne", "seq", "svc", "svs", 
00448     "spl", "smi", "sge", "slt", "sgt", "sle", 
00449   };
00450   static char *MATCH_name_cond_97[] = {
00451     "dbt", "dbf", "dbhi", "dbls", "dbcc", "dbcs", "dbne", "dbeq", "dbvc", 
00452     "dbvs", "dbpl", "dbmi", "dbge", "dblt", "dbgt", "dble", 
00453   };
00454   static char *MATCH_name_cond_98[] = {
00455     "st.ex", "sf.ex", "shi.ex", "sls.ex", "scc.ex", "scs.ex", "sne.ex", 
00456     "seq.ex", "svc.ex", "svs.ex", "spl.ex", "smi.ex", "sge.ex", "slt.ex", 
00457     "sgt.ex", "sle.ex", 
00458   };
00459   static char *MATCH_name_cond_99[] = {
00460     "bra", "bsr", "bhi", "bls", "bcc", "bcs", "bne", "beq", "bvc", "bvs", 
00461     "bpl", "bmi", "bge", "blt", "bgt", "ble", 
00462   };
00463   static char *MATCH_name_sz_100[] = {(char *)0, "orrw", "orrl", };
00464   static char *MATCH_name_sz_101[] = {(char *)0, "orrw.ex", "orrl.ex", };
00465   static char *MATCH_name_adrm_102[] = {
00466     "sbcdr", "cmpl", "ormb", "ormw", "orml", "ormb.ex", "ormb.ex", 
00467   };
00468   static char *MATCH_name_reg2_103[] = {
00469     "ormb.ex", "ormb.ex", "addrl.ex", "addrw.ex", "addaw.ex", 
00470   };
00471   static char *MATCH_name_adrm_104[] = {
00472     "divs", "cmpaw", "ormw", "orml", "divs", "ormw.ex", "ormw.ex", 
00473   };
00474   static char *MATCH_name_reg2_105[] = {
00475     "ormw.ex", "ormw.ex", "addaw.ex", "addrl.ex", "addal.ex", 
00476   };
00477   static char *MATCH_name_adrm_106[] = {
00478     "subrb", "cmpmb", "orml", "divs", "subrb", "orml.ex", "orml.ex", 
00479   };
00480   static char *MATCH_name_reg2_107[] = {
00481     "orml.ex", "orml.ex", "addal.ex", "addaw.ex", 
00482   };
00483   static char *MATCH_name_adrm_108[] = {
00484     "subrw", "cmpmw", "divs", "subrb", "subrw", "divs.ex", "divs.ex", 
00485   };
00486   static char *MATCH_name_reg2_109[] = {
00487     "divs.ex", "divs.ex", (char *)0, "addal.ex", 
00488   };
00489   static char *MATCH_name_adrm_110[] = {
00490     "subrl", "cmpml", "subrb", "subrw", "subrl", "subrb.ex", "subrb.ex", 
00491   };
00492   static char *MATCH_name_adrm_112[] = {
00493     "subaw", "cmpal", "subrw", "subrl", "subaw", "subrw.ex", "subrw.ex", 
00494   };
00495   static char *MATCH_name_adrm_114[] = {
00496     "subxrb", "abcdm", "subrl", "subaw", "submb", "subrl.ex", "subrl.ex", 
00497   };
00498   static char *MATCH_name_adrm_116[] = {
00499     "subxrw", "exgaa", "subaw", "submb", "submw", "subaw.ex", "subaw.ex", 
00500   };
00501   static char *MATCH_name_adrm_118[] = {
00502     "subxrl", "exgda", "submb", "submw", "subml", "submb.ex", "submb.ex", 
00503   };
00504   static char *MATCH_name_adrm_120[] = {
00505     "subal", "addrb", "submw", "subml", "subal", "submw.ex", "submw.ex", 
00506   };
00507   static char *MATCH_name_adrm_122[] = {
00508     "cmpb", "addrw", "subml", "subal", "cmpb", "subml.ex", "subml.ex", 
00509   };
00510   static char *MATCH_name_adrm_124[] = {
00511     "cmpw", "addrl", "subal", "cmpb", "cmpw", "subal.ex", "subal.ex", 
00512   };
00513   static char *MATCH_name_adrm_126[] = {
00514     "cmpl", "addaw", "cmpb", "cmpw", "cmpl", "cmpb.ex", "cmpb.ex", 
00515   };
00516   static char *MATCH_name_adrm_128[] = {
00517     "cmpaw", "addxmb", "cmpw", "cmpl", "cmpaw", "cmpw.ex", "cmpw.ex", 
00518   };
00519   static char *MATCH_name_adrm_130[] = {
00520     "eorb", "addxmw", "cmpl", "cmpaw", "eorb", "cmpl.ex", "cmpl.ex", 
00521   };
00522   static char *MATCH_name_adrm_132[] = {
00523     "eorw", "addxml", "cmpaw", "eorb", "eorw", "cmpaw.ex", "cmpaw.ex", 
00524   };
00525   static char *MATCH_name_adrm_134[] = {
00526     "eorl", "addal", "eorb", "eorw", "eorl", "eorb.ex", "eorb.ex", 
00527   };
00528   static char *MATCH_name_adrm_136[] = {
00529     "cmpal", "lsrib", "eorw", "eorl", "cmpal", "eorw.ex", "eorw.ex", 
00530   };
00531   static char *MATCH_name_adrm_138[] = {
00532     "abcdr", "lsriw", "eorl", "cmpal", "andmb", "eorl.ex", "eorl.ex", 
00533   };
00534   static char *MATCH_name_adrm_140[] = {
00535     "exgdd", "lsril", "cmpal", "andmb", "andmw", "cmpal.ex", "cmpal.ex", 
00536   };
00537   static char *MATCH_name_sz_142[] = {(char *)0, "andrw", "andrl", };
00538   static char *MATCH_name_sz_143[] = {(char *)0, "andrw.ex", "andrl.ex", };
00539   static char *MATCH_name_adrm_144[] = {
00540     "muls", "lslib", "andmb", "andmw", "andml", "andmb.ex", "andmb.ex", 
00541   };
00542   static char *MATCH_name_adrm_146[] = {
00543     "addrb", "lsliw", "andmw", "andml", "muls", "andmw.ex", "andmw.ex", 
00544   };
00545   static char *MATCH_name_adrm_148[] = {
00546     "addrw", "lslil", "andml", "muls", "addrb", "andml.ex", "andml.ex", 
00547   };
00548   static char *MATCH_name_adrm_150[] = {
00549     "addrl", (char *)0, "muls", "addrb", "addrw", "muls.ex", "muls.ex", 
00550   };
00551   static char *MATCH_name_adrm_152[] = {
00552     "addaw", (char *)0, "addrb", "addrw", "addrl", "addrb.ex", "addrb.ex", 
00553   };
00554   static char *MATCH_name_adrm_154[] = {
00555     "addxrb", (char *)0, "addrw", "addrl", "addaw", "addrw.ex", "addrw.ex", 
00556   };
00557   static char *MATCH_name_adrm_156[] = {
00558     "addxrw", (char *)0, "addrl", "addaw", "addmb", "addrl.ex", "addrl.ex", 
00559   };
00560   static char *MATCH_name_adrm_158[] = {
00561     "addxrl", (char *)0, "addaw", "addmb", "addmw", "addaw.ex", "addaw.ex", 
00562   };
00563   static char *MATCH_name_adrm_160[] = {
00564     "addal", (char *)0, "addmb", "addmw", "addml", "addmb.ex", "addmb.ex", 
00565   };
00566   static char *MATCH_name_adrm_162[] = {
00567     "asrib", (char *)0, "addmw", "addml", "addal", "addmw.ex", "addmw.ex", 
00568   };
00569   static char *MATCH_name_adrm_164[] = {
00570     "asriw", (char *)0, "addml", "addal", "asrrb", "addml.ex", "addml.ex", 
00571   };
00572   static char *MATCH_name_adrm_166[] = {
00573     "asril", (char *)0, "addal", "rorib", "asrrw", "addal.ex", "addal.ex", 
00574   };
00575   static char *MATCH_name_adrm_168[] = {
00576     "aslib", (char *)0, "roxrib", "roriw", "asrrl", "lsrrb", "roxrrb", 
00577   };
00578   static char *MATCH_name_adrm_169[] = {
00579     "asliw", (char *)0, "roxriw", "roril", "asrm", "lsrrw", "roxrrw", 
00580   };
00581   static char *MATCH_name_adrm_170[] = {
00582     "aslil", (char *)0, "roxril", "asrm", "lsrm", "lsrrl", "roxrrl", 
00583   };
00584   static char *MATCH_name_adrm_171[] = {
00585     (char *)0, (char *)0, "asrm", "lsrm", "roxrm", "asrm.ex", "asrm.ex", 
00586   };
00587   static char *MATCH_name_adrm_173[] = {
00588     (char *)0, (char *)0, "lsrm", "roxrm", "rorm", "lsrm.ex", "lsrm.ex", 
00589   };
00590   static char *MATCH_name_adrm_175[] = {
00591     (char *)0, (char *)0, "roxrm", "rorm", "aslrb", "roxrm.ex", "roxrm.ex", 
00592   };
00593   static char *MATCH_name_adrm_177[] = {
00594     (char *)0, (char *)0, "rorm", "rolib", "aslrw", "rorm.ex", "rorm.ex", 
00595   };
00596   static char *MATCH_name_adrm_179[] = {
00597     (char *)0, (char *)0, "roxlib", "roliw", "aslrl", "lslrb", "roxlrb", 
00598   };
00599   static char *MATCH_name_adrm_180[] = {
00600     (char *)0, (char *)0, "roxliw", "rolil", "aslm", "lslrw", "roxlrw", 
00601   };
00602   static char *MATCH_name_adrm_181[] = {
00603     (char *)0, (char *)0, "roxlil", "aslm", "lslm", "lslrl", "roxlrl", 
00604   };
00605   static char *MATCH_name_adrm_182[] = {
00606     (char *)0, (char *)0, "aslm", "lslm", "roxlm", "aslm.ex", "aslm.ex", 
00607   };
00608   static char *MATCH_name_adrm_184[] = {
00609     (char *)0, (char *)0, "lslm", "roxlm", "rolm", "lslm.ex", "lslm.ex", 
00610   };
00611   static char *MATCH_name_adrm_186[] = {
00612     (char *)0, (char *)0, "roxlm", "rolm", (char *)0, "roxlm.ex", "roxlm.ex", 
00613   };
00614   static char *MATCH_name_adrm_188[] = {
00615     (char *)0, (char *)0, "rolm", (char *)0, (char *)0, "rolm.ex", "rolm.ex", 
00616   };
00617   unsigned /* [0..65535] */ MATCH_w_16_0;
00618   unsigned /* [0..65535] */ MATCH_w_16_16;
00619   unsigned /* [0..65535] */ MATCH_w_16_32;
00620   { 
00621     MATCH_w_16_0 = getWord(MATCH_p); 
00622     
00623       switch((MATCH_w_16_0 >> 12 & 0xf) /* op at 0 */) {
00624         case 0: 
00625           
00626             switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
00627               case 0: case 2: case 3: case 4: 
00628                 if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
00629                   
00630                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00631                       case 0: 
00632                         { 
00633                           unsigned ea = addressToPC(MATCH_p);
00634                           unsigned n = 
00635                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
00636                           
00637                           #line 315 "machine/mc68k/decoder_low.m"
00638                            {
00639 
00640                                   // btst, btsti
00641 
00642                                       int bump = 0, bumpr;
00643 
00644                                       RTs = instantiate(pc, "btst", DIS_DN(32), dBEA(ea, pc, bump, bumpr, 8));
00645 
00646                                       ADDBUMP;
00647 
00648                                   }
00649 
00650                              
00651 
00652                           
00653 
00654                           
00655                           
00656                           
00657                         }
00658                         
00659                         break;
00660                       case 1: case 2: 
00661                         MATCH_name = 
00662                           MATCH_name_sz_15[(MATCH_w_16_0 >> 6 & 0x3) 
00663                               /* sz at 0 */]; 
00664                         goto MATCH_label_a5; 
00665                         
00666                         break;
00667                       case 3: 
00668                         MATCH_name = 
00669                           MATCH_name_sz_1[(MATCH_w_16_0 >> 6 & 0x3) 
00670                               /* sz at 0 */]; 
00671                         goto MATCH_label_a5; 
00672                         
00673                         break;
00674                       default: assert(0);
00675                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
00676                 else 
00677                   
00678                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
00679                       case 0: 
00680                         
00681                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00682                             case 0: 
00683                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00684                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00685                                       /* iReg at 16 */ == 0 && 
00686                                 (MATCH_w_16_16 >> 11 & 0x1) 
00687                                       /* iSize at 16 */ == 0 && 
00688                                 (MATCH_w_16_16 >> 15 & 0x1) 
00689                                       /* iType at 16 */ == 0 && 
00690                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00691                                       /* null at 16 */ && 
00692                                 (MATCH_w_16_16 >> 8 & 0x7) 
00693                                       /* null at 16 */ < 8) || 
00694                                 (MATCH_w_16_16 >> 12 & 0x7) 
00695                                       /* iReg at 16 */ == 0 && 
00696                                 (MATCH_w_16_16 >> 11 & 0x1) 
00697                                       /* iSize at 16 */ == 0 && 
00698                                 (MATCH_w_16_16 >> 15 & 0x1) 
00699                                       /* iType at 16 */ == 1 || 
00700                                 (MATCH_w_16_16 >> 12 & 0x7) 
00701                                       /* iReg at 16 */ == 0 && 
00702                                 (MATCH_w_16_16 >> 11 & 0x1) 
00703                                       /* iSize at 16 */ == 1 || 
00704                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00705                                       /* iReg at 16 */ && 
00706                                 (MATCH_w_16_16 >> 12 & 0x7) 
00707                                       /* iReg at 16 */ < 8) 
00708                                 goto MATCH_label_a1;  /*opt-block+*/
00709                               else { 
00710                                 MATCH_name = "orib"; 
00711                                 goto MATCH_label_a0; 
00712                                 
00713                               } /*opt-block*/
00714                               
00715                               break;
00716                             case 1: 
00717                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00718                               MATCH_name = 
00719                                 MATCH_name_sz_1[(MATCH_w_16_0 >> 6 & 0x3) 
00720                                     /* sz at 0 */]; 
00721                               goto MATCH_label_a2; 
00722                               
00723                               break;
00724                             case 2: 
00725                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00726                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
00727                               MATCH_name = 
00728                                 MATCH_name_sz_1[(MATCH_w_16_0 >> 6 & 0x3) 
00729                                     /* sz at 0 */]; 
00730                               goto MATCH_label_a3; 
00731                               
00732                               break;
00733                             case 3: 
00734                               goto MATCH_label_a1; break;
00735                             default: assert(0);
00736                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
00737                         break;
00738                       case 1: 
00739                         
00740                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00741                             case 0: 
00742                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00743                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00744                                       /* iReg at 16 */ == 0 && 
00745                                 (MATCH_w_16_16 >> 11 & 0x1) 
00746                                       /* iSize at 16 */ == 0 && 
00747                                 (MATCH_w_16_16 >> 15 & 0x1) 
00748                                       /* iType at 16 */ == 0 && 
00749                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00750                                       /* null at 16 */ && 
00751                                 (MATCH_w_16_16 >> 8 & 0x7) 
00752                                       /* null at 16 */ < 8) || 
00753                                 (MATCH_w_16_16 >> 12 & 0x7) 
00754                                       /* iReg at 16 */ == 0 && 
00755                                 (MATCH_w_16_16 >> 11 & 0x1) 
00756                                       /* iSize at 16 */ == 0 && 
00757                                 (MATCH_w_16_16 >> 15 & 0x1) 
00758                                       /* iType at 16 */ == 1 || 
00759                                 (MATCH_w_16_16 >> 12 & 0x7) 
00760                                       /* iReg at 16 */ == 0 && 
00761                                 (MATCH_w_16_16 >> 11 & 0x1) 
00762                                       /* iSize at 16 */ == 1 || 
00763                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00764                                       /* iReg at 16 */ && 
00765                                 (MATCH_w_16_16 >> 12 & 0x7) 
00766                                       /* iReg at 16 */ < 8) 
00767                                 goto MATCH_label_a1;  /*opt-block+*/
00768                               else { 
00769                                 MATCH_name = "andib"; 
00770                                 goto MATCH_label_a0; 
00771                                 
00772                               } /*opt-block*/
00773                               
00774                               break;
00775                             case 1: 
00776                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00777                               MATCH_name = 
00778                                 MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
00779                                     /* sz at 0 */]; 
00780                               goto MATCH_label_a2; 
00781                               
00782                               break;
00783                             case 2: 
00784                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00785                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
00786                               MATCH_name = 
00787                                 MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
00788                                     /* sz at 0 */]; 
00789                               goto MATCH_label_a3; 
00790                               
00791                               break;
00792                             case 3: 
00793                               goto MATCH_label_a1; break;
00794                             default: assert(0);
00795                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
00796                         break;
00797                       case 2: 
00798                         
00799                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00800                             case 0: 
00801                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00802                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00803                                       /* iReg at 16 */ == 0 && 
00804                                 (MATCH_w_16_16 >> 11 & 0x1) 
00805                                       /* iSize at 16 */ == 0 && 
00806                                 (MATCH_w_16_16 >> 15 & 0x1) 
00807                                       /* iType at 16 */ == 0 && 
00808                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00809                                       /* null at 16 */ && 
00810                                 (MATCH_w_16_16 >> 8 & 0x7) 
00811                                       /* null at 16 */ < 8) || 
00812                                 (MATCH_w_16_16 >> 12 & 0x7) 
00813                                       /* iReg at 16 */ == 0 && 
00814                                 (MATCH_w_16_16 >> 11 & 0x1) 
00815                                       /* iSize at 16 */ == 0 && 
00816                                 (MATCH_w_16_16 >> 15 & 0x1) 
00817                                       /* iType at 16 */ == 1 || 
00818                                 (MATCH_w_16_16 >> 12 & 0x7) 
00819                                       /* iReg at 16 */ == 0 && 
00820                                 (MATCH_w_16_16 >> 11 & 0x1) 
00821                                       /* iSize at 16 */ == 1 || 
00822                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00823                                       /* iReg at 16 */ && 
00824                                 (MATCH_w_16_16 >> 12 & 0x7) 
00825                                       /* iReg at 16 */ < 8) 
00826                                 goto MATCH_label_a1;  /*opt-block+*/
00827                               else { 
00828                                 MATCH_name = "subib"; 
00829                                 goto MATCH_label_a0; 
00830                                 
00831                               } /*opt-block*/
00832                               
00833                               break;
00834                             case 1: 
00835                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00836                               MATCH_name = 
00837                                 MATCH_name_sz_5[(MATCH_w_16_0 >> 6 & 0x3) 
00838                                     /* sz at 0 */]; 
00839                               goto MATCH_label_a2; 
00840                               
00841                               break;
00842                             case 2: 
00843                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00844                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
00845                               MATCH_name = 
00846                                 MATCH_name_sz_5[(MATCH_w_16_0 >> 6 & 0x3) 
00847                                     /* sz at 0 */]; 
00848                               goto MATCH_label_a3; 
00849                               
00850                               break;
00851                             case 3: 
00852                               goto MATCH_label_a1; break;
00853                             default: assert(0);
00854                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
00855                         break;
00856                       case 3: 
00857                         
00858                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00859                             case 0: 
00860                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00861                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00862                                       /* iReg at 16 */ == 0 && 
00863                                 (MATCH_w_16_16 >> 11 & 0x1) 
00864                                       /* iSize at 16 */ == 0 && 
00865                                 (MATCH_w_16_16 >> 15 & 0x1) 
00866                                       /* iType at 16 */ == 0 && 
00867                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00868                                       /* null at 16 */ && 
00869                                 (MATCH_w_16_16 >> 8 & 0x7) 
00870                                       /* null at 16 */ < 8) || 
00871                                 (MATCH_w_16_16 >> 12 & 0x7) 
00872                                       /* iReg at 16 */ == 0 && 
00873                                 (MATCH_w_16_16 >> 11 & 0x1) 
00874                                       /* iSize at 16 */ == 0 && 
00875                                 (MATCH_w_16_16 >> 15 & 0x1) 
00876                                       /* iType at 16 */ == 1 || 
00877                                 (MATCH_w_16_16 >> 12 & 0x7) 
00878                                       /* iReg at 16 */ == 0 && 
00879                                 (MATCH_w_16_16 >> 11 & 0x1) 
00880                                       /* iSize at 16 */ == 1 || 
00881                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00882                                       /* iReg at 16 */ && 
00883                                 (MATCH_w_16_16 >> 12 & 0x7) 
00884                                       /* iReg at 16 */ < 8) 
00885                                 goto MATCH_label_a1;  /*opt-block+*/
00886                               else { 
00887                                 MATCH_name = "addib"; 
00888                                 goto MATCH_label_a0; 
00889                                 
00890                               } /*opt-block*/
00891                               
00892                               break;
00893                             case 1: 
00894                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00895                               MATCH_name = 
00896                                 MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
00897                                     /* sz at 0 */]; 
00898                               goto MATCH_label_a2; 
00899                               
00900                               break;
00901                             case 2: 
00902                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00903                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
00904                               MATCH_name = 
00905                                 MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
00906                                     /* sz at 0 */]; 
00907                               goto MATCH_label_a3; 
00908                               
00909                               break;
00910                             case 3: 
00911                               goto MATCH_label_a1; break;
00912                             default: assert(0);
00913                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
00914                         break;
00915                       case 4: 
00916                         
00917                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
00918                             case 0: 
00919                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00920                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00921                                       /* iReg at 16 */ == 0 && 
00922                                 (MATCH_w_16_16 >> 11 & 0x1) 
00923                                       /* iSize at 16 */ == 0 && 
00924                                 (MATCH_w_16_16 >> 15 & 0x1) 
00925                                       /* iType at 16 */ == 0 && 
00926                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00927                                       /* null at 16 */ && 
00928                                 (MATCH_w_16_16 >> 8 & 0x7) 
00929                                       /* null at 16 */ < 8) || 
00930                                 (MATCH_w_16_16 >> 12 & 0x7) 
00931                                       /* iReg at 16 */ == 0 && 
00932                                 (MATCH_w_16_16 >> 11 & 0x1) 
00933                                       /* iSize at 16 */ == 0 && 
00934                                 (MATCH_w_16_16 >> 15 & 0x1) 
00935                                       /* iType at 16 */ == 1 || 
00936                                 (MATCH_w_16_16 >> 12 & 0x7) 
00937                                       /* iReg at 16 */ == 0 && 
00938                                 (MATCH_w_16_16 >> 11 & 0x1) 
00939                                       /* iSize at 16 */ == 1 || 
00940                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00941                                       /* iReg at 16 */ && 
00942                                 (MATCH_w_16_16 >> 12 & 0x7) 
00943                                       /* iReg at 16 */ < 8) 
00944                                 goto MATCH_label_a1;  /*opt-block+*/
00945                               else { 
00946                                 unsigned ea = addressToPC(MATCH_p);
00947                                 unsigned i8 = 
00948                                   (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
00949                                 
00950                                 #line 328 "machine/mc68k/decoder_low.m"
00951                                  { 
00952 
00953                                             int bump = 0, bumpr;
00954 
00955                                             RTs = instantiate (pc, "btst", DIS_I8, dBEA (ea, pc, bump, bumpr, 8)); 
00956 
00957                                             ADDBUMP;
00958 
00959                                             result.numBytes += 2; 
00960 
00961                                         }
00962 
00963                                 
00964 
00965                                 
00966                                 
00967                                 
00968                               } /*opt-block*//*opt-block+*/
00969                               
00970                               break;
00971                             case 1: 
00972                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
00973                               if ((MATCH_w_16_16 >> 12 & 0x7) 
00974                                       /* iReg at 16 */ == 0 && 
00975                                 (MATCH_w_16_16 >> 11 & 0x1) 
00976                                       /* iSize at 16 */ == 0 && 
00977                                 (MATCH_w_16_16 >> 15 & 0x1) 
00978                                       /* iType at 16 */ == 0 && 
00979                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
00980                                       /* null at 16 */ && 
00981                                 (MATCH_w_16_16 >> 8 & 0x7) 
00982                                       /* null at 16 */ < 8) || 
00983                                 (MATCH_w_16_16 >> 12 & 0x7) 
00984                                       /* iReg at 16 */ == 0 && 
00985                                 (MATCH_w_16_16 >> 11 & 0x1) 
00986                                       /* iSize at 16 */ == 0 && 
00987                                 (MATCH_w_16_16 >> 15 & 0x1) 
00988                                       /* iType at 16 */ == 1 || 
00989                                 (MATCH_w_16_16 >> 12 & 0x7) 
00990                                       /* iReg at 16 */ == 0 && 
00991                                 (MATCH_w_16_16 >> 11 & 0x1) 
00992                                       /* iSize at 16 */ == 1 || 
00993                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
00994                                       /* iReg at 16 */ && 
00995                                 (MATCH_w_16_16 >> 12 & 0x7) 
00996                                       /* iReg at 16 */ < 8) 
00997                                 goto MATCH_label_a1;  /*opt-block+*/
00998                               else { 
00999                                 MATCH_name = "bchgi"; 
01000                                 goto MATCH_label_a4; 
01001                                 
01002                               } /*opt-block*/
01003                               
01004                               break;
01005                             case 2: 
01006                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01007                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01008                                       /* iReg at 16 */ == 0 && 
01009                                 (MATCH_w_16_16 >> 11 & 0x1) 
01010                                       /* iSize at 16 */ == 0 && 
01011                                 (MATCH_w_16_16 >> 15 & 0x1) 
01012                                       /* iType at 16 */ == 0 && 
01013                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01014                                       /* null at 16 */ && 
01015                                 (MATCH_w_16_16 >> 8 & 0x7) 
01016                                       /* null at 16 */ < 8) || 
01017                                 (MATCH_w_16_16 >> 12 & 0x7) 
01018                                       /* iReg at 16 */ == 0 && 
01019                                 (MATCH_w_16_16 >> 11 & 0x1) 
01020                                       /* iSize at 16 */ == 0 && 
01021                                 (MATCH_w_16_16 >> 15 & 0x1) 
01022                                       /* iType at 16 */ == 1 || 
01023                                 (MATCH_w_16_16 >> 12 & 0x7) 
01024                                       /* iReg at 16 */ == 0 && 
01025                                 (MATCH_w_16_16 >> 11 & 0x1) 
01026                                       /* iSize at 16 */ == 1 || 
01027                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01028                                       /* iReg at 16 */ && 
01029                                 (MATCH_w_16_16 >> 12 & 0x7) 
01030                                       /* iReg at 16 */ < 8) 
01031                                 goto MATCH_label_a1;  /*opt-block+*/
01032                               else { 
01033                                 MATCH_name = "bclri"; 
01034                                 goto MATCH_label_a4; 
01035                                 
01036                               } /*opt-block*/
01037                               
01038                               break;
01039                             case 3: 
01040                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01041                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01042                                       /* iReg at 16 */ == 0 && 
01043                                 (MATCH_w_16_16 >> 11 & 0x1) 
01044                                       /* iSize at 16 */ == 0 && 
01045                                 (MATCH_w_16_16 >> 15 & 0x1) 
01046                                       /* iType at 16 */ == 0 && 
01047                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01048                                       /* null at 16 */ && 
01049                                 (MATCH_w_16_16 >> 8 & 0x7) 
01050                                       /* null at 16 */ < 8) || 
01051                                 (MATCH_w_16_16 >> 12 & 0x7) 
01052                                       /* iReg at 16 */ == 0 && 
01053                                 (MATCH_w_16_16 >> 11 & 0x1) 
01054                                       /* iSize at 16 */ == 0 && 
01055                                 (MATCH_w_16_16 >> 15 & 0x1) 
01056                                       /* iType at 16 */ == 1 || 
01057                                 (MATCH_w_16_16 >> 12 & 0x7) 
01058                                       /* iReg at 16 */ == 0 && 
01059                                 (MATCH_w_16_16 >> 11 & 0x1) 
01060                                       /* iSize at 16 */ == 1 || 
01061                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01062                                       /* iReg at 16 */ && 
01063                                 (MATCH_w_16_16 >> 12 & 0x7) 
01064                                       /* iReg at 16 */ < 8) 
01065                                 goto MATCH_label_a1;  /*opt-block+*/
01066                               else { 
01067                                 MATCH_name = "bseti"; 
01068                                 goto MATCH_label_a4; 
01069                                 
01070                               } /*opt-block*/
01071                               
01072                               break;
01073                             default: assert(0);
01074                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01075                         break;
01076                       case 5: 
01077                         
01078                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01079                             case 0: 
01080                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01081                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01082                                       /* iReg at 16 */ == 0 && 
01083                                 (MATCH_w_16_16 >> 11 & 0x1) 
01084                                       /* iSize at 16 */ == 0 && 
01085                                 (MATCH_w_16_16 >> 15 & 0x1) 
01086                                       /* iType at 16 */ == 0 && 
01087                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01088                                       /* null at 16 */ && 
01089                                 (MATCH_w_16_16 >> 8 & 0x7) 
01090                                       /* null at 16 */ < 8) || 
01091                                 (MATCH_w_16_16 >> 12 & 0x7) 
01092                                       /* iReg at 16 */ == 0 && 
01093                                 (MATCH_w_16_16 >> 11 & 0x1) 
01094                                       /* iSize at 16 */ == 0 && 
01095                                 (MATCH_w_16_16 >> 15 & 0x1) 
01096                                       /* iType at 16 */ == 1 || 
01097                                 (MATCH_w_16_16 >> 12 & 0x7) 
01098                                       /* iReg at 16 */ == 0 && 
01099                                 (MATCH_w_16_16 >> 11 & 0x1) 
01100                                       /* iSize at 16 */ == 1 || 
01101                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01102                                       /* iReg at 16 */ && 
01103                                 (MATCH_w_16_16 >> 12 & 0x7) 
01104                                       /* iReg at 16 */ < 8) 
01105                                 goto MATCH_label_a1;  /*opt-block+*/
01106                               else { 
01107                                 MATCH_name = "eorib"; 
01108                                 goto MATCH_label_a0; 
01109                                 
01110                               } /*opt-block*/
01111                               
01112                               break;
01113                             case 1: 
01114                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01115                               MATCH_name = 
01116                                 MATCH_name_sz_12[(MATCH_w_16_0 >> 6 & 0x3) 
01117                                     /* sz at 0 */]; 
01118                               goto MATCH_label_a2; 
01119                               
01120                               break;
01121                             case 2: 
01122                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01123                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01124                               MATCH_name = 
01125                                 MATCH_name_sz_12[(MATCH_w_16_0 >> 6 & 0x3) 
01126                                     /* sz at 0 */]; 
01127                               goto MATCH_label_a3; 
01128                               
01129                               break;
01130                             case 3: 
01131                               goto MATCH_label_a1; break;
01132                             default: assert(0);
01133                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01134                         break;
01135                       case 6: 
01136                         
01137                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01138                             case 0: 
01139                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01140                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01141                                       /* iReg at 16 */ == 0 && 
01142                                 (MATCH_w_16_16 >> 11 & 0x1) 
01143                                       /* iSize at 16 */ == 0 && 
01144                                 (MATCH_w_16_16 >> 15 & 0x1) 
01145                                       /* iType at 16 */ == 0 && 
01146                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01147                                       /* null at 16 */ && 
01148                                 (MATCH_w_16_16 >> 8 & 0x7) 
01149                                       /* null at 16 */ < 8) || 
01150                                 (MATCH_w_16_16 >> 12 & 0x7) 
01151                                       /* iReg at 16 */ == 0 && 
01152                                 (MATCH_w_16_16 >> 11 & 0x1) 
01153                                       /* iSize at 16 */ == 0 && 
01154                                 (MATCH_w_16_16 >> 15 & 0x1) 
01155                                       /* iType at 16 */ == 1 || 
01156                                 (MATCH_w_16_16 >> 12 & 0x7) 
01157                                       /* iReg at 16 */ == 0 && 
01158                                 (MATCH_w_16_16 >> 11 & 0x1) 
01159                                       /* iSize at 16 */ == 1 || 
01160                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01161                                       /* iReg at 16 */ && 
01162                                 (MATCH_w_16_16 >> 12 & 0x7) 
01163                                       /* iReg at 16 */ < 8) 
01164                                 goto MATCH_label_a1;  /*opt-block+*/
01165                               else { 
01166                                 MATCH_name = "cmpib"; 
01167                                 goto MATCH_label_a0; 
01168                                 
01169                               } /*opt-block*/
01170                               
01171                               break;
01172                             case 1: 
01173                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01174                               MATCH_name = 
01175                                 MATCH_name_sz_14[(MATCH_w_16_0 >> 6 & 0x3) 
01176                                     /* sz at 0 */]; 
01177                               goto MATCH_label_a2; 
01178                               
01179                               break;
01180                             case 2: 
01181                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01182                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01183                               MATCH_name = 
01184                                 MATCH_name_sz_14[(MATCH_w_16_0 >> 6 & 0x3) 
01185                                     /* sz at 0 */]; 
01186                               goto MATCH_label_a3; 
01187                               
01188                               break;
01189                             case 3: 
01190                               goto MATCH_label_a1; break;
01191                             default: assert(0);
01192                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01193                         break;
01194                       case 7: 
01195                         goto MATCH_label_a1; break;
01196                       default: assert(0);
01197                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/  
01198                 break;
01199               case 1: 
01200                 goto MATCH_label_a1; break;
01201               case 5: case 6: 
01202                 if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
01203                   
01204                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01205                       case 0: 
01206                         goto MATCH_label_a11; break;
01207                       case 1: case 2: 
01208                         MATCH_name = 
01209                           MATCH_name_sz_31[(MATCH_w_16_0 >> 6 & 0x3) 
01210                               /* sz at 0 */]; 
01211                         goto MATCH_label_a12; 
01212                         
01213                         break;
01214                       case 3: 
01215                         MATCH_name = 
01216                           MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
01217                               /* sz at 0 */]; 
01218                         goto MATCH_label_a12; 
01219                         
01220                         break;
01221                       default: assert(0);
01222                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
01223                 else 
01224                   
01225                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
01226                       case 0: 
01227                         
01228                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01229                             case 0: 
01230                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01231                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01232                                       /* iReg at 16 */ == 0 && 
01233                                 (MATCH_w_16_16 >> 11 & 0x1) 
01234                                       /* iSize at 16 */ == 0 && 
01235                                 (MATCH_w_16_16 >> 15 & 0x1) 
01236                                       /* iType at 16 */ == 0 && 
01237                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01238                                       /* null at 16 */ && 
01239                                 (MATCH_w_16_16 >> 8 & 0x7) 
01240                                       /* null at 16 */ < 8) || 
01241                                 (MATCH_w_16_16 >> 12 & 0x7) 
01242                                       /* iReg at 16 */ == 0 && 
01243                                 (MATCH_w_16_16 >> 11 & 0x1) 
01244                                       /* iSize at 16 */ == 0 && 
01245                                 (MATCH_w_16_16 >> 15 & 0x1) 
01246                                       /* iType at 16 */ == 1 || 
01247                                 (MATCH_w_16_16 >> 12 & 0x7) 
01248                                       /* iReg at 16 */ == 0 && 
01249                                 (MATCH_w_16_16 >> 11 & 0x1) 
01250                                       /* iSize at 16 */ == 1 || 
01251                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01252                                       /* iReg at 16 */ && 
01253                                 (MATCH_w_16_16 >> 12 & 0x7) 
01254                                       /* iReg at 16 */ < 8) 
01255                                 goto MATCH_label_a1;  /*opt-block+*/
01256                               else { 
01257                                 MATCH_name = "orib.ex"; 
01258                                 goto MATCH_label_a6; 
01259                                 
01260                               } /*opt-block*/
01261                               
01262                               break;
01263                             case 1: 
01264                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01265                               MATCH_name = 
01266                                 MATCH_name_sz_17[(MATCH_w_16_0 >> 6 & 0x3) 
01267                                     /* sz at 0 */]; 
01268                               goto MATCH_label_a7; 
01269                               
01270                               break;
01271                             case 2: 
01272                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01273                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01274                               MATCH_name = 
01275                                 MATCH_name_sz_17[(MATCH_w_16_0 >> 6 & 0x3) 
01276                                     /* sz at 0 */]; 
01277                               goto MATCH_label_a8; 
01278                               
01279                               break;
01280                             case 3: 
01281                               goto MATCH_label_a1; break;
01282                             default: assert(0);
01283                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01284                         break;
01285                       case 1: 
01286                         
01287                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01288                             case 0: 
01289                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01290                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01291                                       /* iReg at 16 */ == 0 && 
01292                                 (MATCH_w_16_16 >> 11 & 0x1) 
01293                                       /* iSize at 16 */ == 0 && 
01294                                 (MATCH_w_16_16 >> 15 & 0x1) 
01295                                       /* iType at 16 */ == 0 && 
01296                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01297                                       /* null at 16 */ && 
01298                                 (MATCH_w_16_16 >> 8 & 0x7) 
01299                                       /* null at 16 */ < 8) || 
01300                                 (MATCH_w_16_16 >> 12 & 0x7) 
01301                                       /* iReg at 16 */ == 0 && 
01302                                 (MATCH_w_16_16 >> 11 & 0x1) 
01303                                       /* iSize at 16 */ == 0 && 
01304                                 (MATCH_w_16_16 >> 15 & 0x1) 
01305                                       /* iType at 16 */ == 1 || 
01306                                 (MATCH_w_16_16 >> 12 & 0x7) 
01307                                       /* iReg at 16 */ == 0 && 
01308                                 (MATCH_w_16_16 >> 11 & 0x1) 
01309                                       /* iSize at 16 */ == 1 || 
01310                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01311                                       /* iReg at 16 */ && 
01312                                 (MATCH_w_16_16 >> 12 & 0x7) 
01313                                       /* iReg at 16 */ < 8) 
01314                                 goto MATCH_label_a1;  /*opt-block+*/
01315                               else { 
01316                                 MATCH_name = "andib.ex"; 
01317                                 goto MATCH_label_a6; 
01318                                 
01319                               } /*opt-block*/
01320                               
01321                               break;
01322                             case 1: 
01323                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01324                               MATCH_name = 
01325                                 MATCH_name_sz_19[(MATCH_w_16_0 >> 6 & 0x3) 
01326                                     /* sz at 0 */]; 
01327                               goto MATCH_label_a7; 
01328                               
01329                               break;
01330                             case 2: 
01331                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01332                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01333                               MATCH_name = 
01334                                 MATCH_name_sz_19[(MATCH_w_16_0 >> 6 & 0x3) 
01335                                     /* sz at 0 */]; 
01336                               goto MATCH_label_a8; 
01337                               
01338                               break;
01339                             case 3: 
01340                               goto MATCH_label_a1; break;
01341                             default: assert(0);
01342                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01343                         break;
01344                       case 2: 
01345                         
01346                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01347                             case 0: 
01348                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01349                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01350                                       /* iReg at 16 */ == 0 && 
01351                                 (MATCH_w_16_16 >> 11 & 0x1) 
01352                                       /* iSize at 16 */ == 0 && 
01353                                 (MATCH_w_16_16 >> 15 & 0x1) 
01354                                       /* iType at 16 */ == 0 && 
01355                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01356                                       /* null at 16 */ && 
01357                                 (MATCH_w_16_16 >> 8 & 0x7) 
01358                                       /* null at 16 */ < 8) || 
01359                                 (MATCH_w_16_16 >> 12 & 0x7) 
01360                                       /* iReg at 16 */ == 0 && 
01361                                 (MATCH_w_16_16 >> 11 & 0x1) 
01362                                       /* iSize at 16 */ == 0 && 
01363                                 (MATCH_w_16_16 >> 15 & 0x1) 
01364                                       /* iType at 16 */ == 1 || 
01365                                 (MATCH_w_16_16 >> 12 & 0x7) 
01366                                       /* iReg at 16 */ == 0 && 
01367                                 (MATCH_w_16_16 >> 11 & 0x1) 
01368                                       /* iSize at 16 */ == 1 || 
01369                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01370                                       /* iReg at 16 */ && 
01371                                 (MATCH_w_16_16 >> 12 & 0x7) 
01372                                       /* iReg at 16 */ < 8) 
01373                                 goto MATCH_label_a1;  /*opt-block+*/
01374                               else { 
01375                                 MATCH_name = "subib.ex"; 
01376                                 goto MATCH_label_a6; 
01377                                 
01378                               } /*opt-block*/
01379                               
01380                               break;
01381                             case 1: 
01382                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01383                               MATCH_name = 
01384                                 MATCH_name_sz_21[(MATCH_w_16_0 >> 6 & 0x3) 
01385                                     /* sz at 0 */]; 
01386                               goto MATCH_label_a7; 
01387                               
01388                               break;
01389                             case 2: 
01390                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01391                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01392                               MATCH_name = 
01393                                 MATCH_name_sz_21[(MATCH_w_16_0 >> 6 & 0x3) 
01394                                     /* sz at 0 */]; 
01395                               goto MATCH_label_a8; 
01396                               
01397                               break;
01398                             case 3: 
01399                               goto MATCH_label_a1; break;
01400                             default: assert(0);
01401                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01402                         break;
01403                       case 3: 
01404                         
01405                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01406                             case 0: 
01407                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01408                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01409                                       /* iReg at 16 */ == 0 && 
01410                                 (MATCH_w_16_16 >> 11 & 0x1) 
01411                                       /* iSize at 16 */ == 0 && 
01412                                 (MATCH_w_16_16 >> 15 & 0x1) 
01413                                       /* iType at 16 */ == 0 && 
01414                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01415                                       /* null at 16 */ && 
01416                                 (MATCH_w_16_16 >> 8 & 0x7) 
01417                                       /* null at 16 */ < 8) || 
01418                                 (MATCH_w_16_16 >> 12 & 0x7) 
01419                                       /* iReg at 16 */ == 0 && 
01420                                 (MATCH_w_16_16 >> 11 & 0x1) 
01421                                       /* iSize at 16 */ == 0 && 
01422                                 (MATCH_w_16_16 >> 15 & 0x1) 
01423                                       /* iType at 16 */ == 1 || 
01424                                 (MATCH_w_16_16 >> 12 & 0x7) 
01425                                       /* iReg at 16 */ == 0 && 
01426                                 (MATCH_w_16_16 >> 11 & 0x1) 
01427                                       /* iSize at 16 */ == 1 || 
01428                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01429                                       /* iReg at 16 */ && 
01430                                 (MATCH_w_16_16 >> 12 & 0x7) 
01431                                       /* iReg at 16 */ < 8) 
01432                                 goto MATCH_label_a1;  /*opt-block+*/
01433                               else { 
01434                                 MATCH_name = "addib.ex"; 
01435                                 goto MATCH_label_a6; 
01436                                 
01437                               } /*opt-block*/
01438                               
01439                               break;
01440                             case 1: 
01441                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01442                               MATCH_name = 
01443                                 MATCH_name_sz_23[(MATCH_w_16_0 >> 6 & 0x3) 
01444                                     /* sz at 0 */]; 
01445                               goto MATCH_label_a7; 
01446                               
01447                               break;
01448                             case 2: 
01449                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01450                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01451                               MATCH_name = 
01452                                 MATCH_name_sz_23[(MATCH_w_16_0 >> 6 & 0x3) 
01453                                     /* sz at 0 */]; 
01454                               goto MATCH_label_a8; 
01455                               
01456                               break;
01457                             case 3: 
01458                               goto MATCH_label_a1; break;
01459                             default: assert(0);
01460                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01461                         break;
01462                       case 4: 
01463                         
01464                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01465                             case 0: 
01466                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01467                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01468                                       /* iReg at 16 */ == 0 && 
01469                                 (MATCH_w_16_16 >> 11 & 0x1) 
01470                                       /* iSize at 16 */ == 0 && 
01471                                 (MATCH_w_16_16 >> 15 & 0x1) 
01472                                       /* iType at 16 */ == 0 && 
01473                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01474                                       /* null at 16 */ && 
01475                                 (MATCH_w_16_16 >> 8 & 0x7) 
01476                                       /* null at 16 */ < 8) || 
01477                                 (MATCH_w_16_16 >> 12 & 0x7) 
01478                                       /* iReg at 16 */ == 0 && 
01479                                 (MATCH_w_16_16 >> 11 & 0x1) 
01480                                       /* iSize at 16 */ == 0 && 
01481                                 (MATCH_w_16_16 >> 15 & 0x1) 
01482                                       /* iType at 16 */ == 1 || 
01483                                 (MATCH_w_16_16 >> 12 & 0x7) 
01484                                       /* iReg at 16 */ == 0 && 
01485                                 (MATCH_w_16_16 >> 11 & 0x1) 
01486                                       /* iSize at 16 */ == 1 || 
01487                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01488                                       /* iReg at 16 */ && 
01489                                 (MATCH_w_16_16 >> 12 & 0x7) 
01490                                       /* iReg at 16 */ < 8) 
01491                                 goto MATCH_label_a1;  /*opt-block+*/
01492                               else 
01493                                 goto MATCH_label_a9;  /*opt-block+*/
01494                               
01495                               break;
01496                             case 1: 
01497                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01498                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01499                                       /* iReg at 16 */ == 0 && 
01500                                 (MATCH_w_16_16 >> 11 & 0x1) 
01501                                       /* iSize at 16 */ == 0 && 
01502                                 (MATCH_w_16_16 >> 15 & 0x1) 
01503                                       /* iType at 16 */ == 0 && 
01504                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01505                                       /* null at 16 */ && 
01506                                 (MATCH_w_16_16 >> 8 & 0x7) 
01507                                       /* null at 16 */ < 8) || 
01508                                 (MATCH_w_16_16 >> 12 & 0x7) 
01509                                       /* iReg at 16 */ == 0 && 
01510                                 (MATCH_w_16_16 >> 11 & 0x1) 
01511                                       /* iSize at 16 */ == 0 && 
01512                                 (MATCH_w_16_16 >> 15 & 0x1) 
01513                                       /* iType at 16 */ == 1 || 
01514                                 (MATCH_w_16_16 >> 12 & 0x7) 
01515                                       /* iReg at 16 */ == 0 && 
01516                                 (MATCH_w_16_16 >> 11 & 0x1) 
01517                                       /* iSize at 16 */ == 1 || 
01518                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01519                                       /* iReg at 16 */ && 
01520                                 (MATCH_w_16_16 >> 12 & 0x7) 
01521                                       /* iReg at 16 */ < 8) 
01522                                 goto MATCH_label_a1;  /*opt-block+*/
01523                               else { 
01524                                 MATCH_name = "bchgi.ex"; 
01525                                 goto MATCH_label_a10; 
01526                                 
01527                               } /*opt-block*/
01528                               
01529                               break;
01530                             case 2: 
01531                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01532                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01533                                       /* iReg at 16 */ == 0 && 
01534                                 (MATCH_w_16_16 >> 11 & 0x1) 
01535                                       /* iSize at 16 */ == 0 && 
01536                                 (MATCH_w_16_16 >> 15 & 0x1) 
01537                                       /* iType at 16 */ == 0 && 
01538                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01539                                       /* null at 16 */ && 
01540                                 (MATCH_w_16_16 >> 8 & 0x7) 
01541                                       /* null at 16 */ < 8) || 
01542                                 (MATCH_w_16_16 >> 12 & 0x7) 
01543                                       /* iReg at 16 */ == 0 && 
01544                                 (MATCH_w_16_16 >> 11 & 0x1) 
01545                                       /* iSize at 16 */ == 0 && 
01546                                 (MATCH_w_16_16 >> 15 & 0x1) 
01547                                       /* iType at 16 */ == 1 || 
01548                                 (MATCH_w_16_16 >> 12 & 0x7) 
01549                                       /* iReg at 16 */ == 0 && 
01550                                 (MATCH_w_16_16 >> 11 & 0x1) 
01551                                       /* iSize at 16 */ == 1 || 
01552                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01553                                       /* iReg at 16 */ && 
01554                                 (MATCH_w_16_16 >> 12 & 0x7) 
01555                                       /* iReg at 16 */ < 8) 
01556                                 goto MATCH_label_a1;  /*opt-block+*/
01557                               else { 
01558                                 MATCH_name = "bclri.ex"; 
01559                                 goto MATCH_label_a10; 
01560                                 
01561                               } /*opt-block*/
01562                               
01563                               break;
01564                             case 3: 
01565                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01566                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01567                                       /* iReg at 16 */ == 0 && 
01568                                 (MATCH_w_16_16 >> 11 & 0x1) 
01569                                       /* iSize at 16 */ == 0 && 
01570                                 (MATCH_w_16_16 >> 15 & 0x1) 
01571                                       /* iType at 16 */ == 0 && 
01572                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01573                                       /* null at 16 */ && 
01574                                 (MATCH_w_16_16 >> 8 & 0x7) 
01575                                       /* null at 16 */ < 8) || 
01576                                 (MATCH_w_16_16 >> 12 & 0x7) 
01577                                       /* iReg at 16 */ == 0 && 
01578                                 (MATCH_w_16_16 >> 11 & 0x1) 
01579                                       /* iSize at 16 */ == 0 && 
01580                                 (MATCH_w_16_16 >> 15 & 0x1) 
01581                                       /* iType at 16 */ == 1 || 
01582                                 (MATCH_w_16_16 >> 12 & 0x7) 
01583                                       /* iReg at 16 */ == 0 && 
01584                                 (MATCH_w_16_16 >> 11 & 0x1) 
01585                                       /* iSize at 16 */ == 1 || 
01586                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01587                                       /* iReg at 16 */ && 
01588                                 (MATCH_w_16_16 >> 12 & 0x7) 
01589                                       /* iReg at 16 */ < 8) 
01590                                 goto MATCH_label_a1;  /*opt-block+*/
01591                               else { 
01592                                 MATCH_name = "bseti.ex"; 
01593                                 goto MATCH_label_a10; 
01594                                 
01595                               } /*opt-block*/
01596                               
01597                               break;
01598                             default: assert(0);
01599                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01600                         break;
01601                       case 5: 
01602                         
01603                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01604                             case 0: 
01605                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01606                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01607                                       /* iReg at 16 */ == 0 && 
01608                                 (MATCH_w_16_16 >> 11 & 0x1) 
01609                                       /* iSize at 16 */ == 0 && 
01610                                 (MATCH_w_16_16 >> 15 & 0x1) 
01611                                       /* iType at 16 */ == 0 && 
01612                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01613                                       /* null at 16 */ && 
01614                                 (MATCH_w_16_16 >> 8 & 0x7) 
01615                                       /* null at 16 */ < 8) || 
01616                                 (MATCH_w_16_16 >> 12 & 0x7) 
01617                                       /* iReg at 16 */ == 0 && 
01618                                 (MATCH_w_16_16 >> 11 & 0x1) 
01619                                       /* iSize at 16 */ == 0 && 
01620                                 (MATCH_w_16_16 >> 15 & 0x1) 
01621                                       /* iType at 16 */ == 1 || 
01622                                 (MATCH_w_16_16 >> 12 & 0x7) 
01623                                       /* iReg at 16 */ == 0 && 
01624                                 (MATCH_w_16_16 >> 11 & 0x1) 
01625                                       /* iSize at 16 */ == 1 || 
01626                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01627                                       /* iReg at 16 */ && 
01628                                 (MATCH_w_16_16 >> 12 & 0x7) 
01629                                       /* iReg at 16 */ < 8) 
01630                                 goto MATCH_label_a1;  /*opt-block+*/
01631                               else { 
01632                                 MATCH_name = "eorib.ex"; 
01633                                 goto MATCH_label_a6; 
01634                                 
01635                               } /*opt-block*/
01636                               
01637                               break;
01638                             case 1: 
01639                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01640                               MATCH_name = 
01641                                 MATCH_name_sz_28[(MATCH_w_16_0 >> 6 & 0x3) 
01642                                     /* sz at 0 */]; 
01643                               goto MATCH_label_a7; 
01644                               
01645                               break;
01646                             case 2: 
01647                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01648                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01649                               MATCH_name = 
01650                                 MATCH_name_sz_28[(MATCH_w_16_0 >> 6 & 0x3) 
01651                                     /* sz at 0 */]; 
01652                               goto MATCH_label_a8; 
01653                               
01654                               break;
01655                             case 3: 
01656                               goto MATCH_label_a1; break;
01657                             default: assert(0);
01658                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01659                         break;
01660                       case 6: 
01661                         
01662                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01663                             case 0: 
01664                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01665                               if ((MATCH_w_16_16 >> 12 & 0x7) 
01666                                       /* iReg at 16 */ == 0 && 
01667                                 (MATCH_w_16_16 >> 11 & 0x1) 
01668                                       /* iSize at 16 */ == 0 && 
01669                                 (MATCH_w_16_16 >> 15 & 0x1) 
01670                                       /* iType at 16 */ == 0 && 
01671                                 (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01672                                       /* null at 16 */ && 
01673                                 (MATCH_w_16_16 >> 8 & 0x7) 
01674                                       /* null at 16 */ < 8) || 
01675                                 (MATCH_w_16_16 >> 12 & 0x7) 
01676                                       /* iReg at 16 */ == 0 && 
01677                                 (MATCH_w_16_16 >> 11 & 0x1) 
01678                                       /* iSize at 16 */ == 0 && 
01679                                 (MATCH_w_16_16 >> 15 & 0x1) 
01680                                       /* iType at 16 */ == 1 || 
01681                                 (MATCH_w_16_16 >> 12 & 0x7) 
01682                                       /* iReg at 16 */ == 0 && 
01683                                 (MATCH_w_16_16 >> 11 & 0x1) 
01684                                       /* iSize at 16 */ == 1 || 
01685                                 1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01686                                       /* iReg at 16 */ && 
01687                                 (MATCH_w_16_16 >> 12 & 0x7) 
01688                                       /* iReg at 16 */ < 8) 
01689                                 goto MATCH_label_a1;  /*opt-block+*/
01690                               else { 
01691                                 MATCH_name = "cmpib.ex"; 
01692                                 goto MATCH_label_a6; 
01693                                 
01694                               } /*opt-block*/
01695                               
01696                               break;
01697                             case 1: 
01698                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01699                               MATCH_name = 
01700                                 MATCH_name_sz_30[(MATCH_w_16_0 >> 6 & 0x3) 
01701                                     /* sz at 0 */]; 
01702                               goto MATCH_label_a7; 
01703                               
01704                               break;
01705                             case 2: 
01706                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
01707                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
01708                               MATCH_name = 
01709                                 MATCH_name_sz_30[(MATCH_w_16_0 >> 6 & 0x3) 
01710                                     /* sz at 0 */]; 
01711                               goto MATCH_label_a8; 
01712                               
01713                               break;
01714                             case 3: 
01715                               goto MATCH_label_a1; break;
01716                             default: assert(0);
01717                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
01718                         break;
01719                       case 7: 
01720                         goto MATCH_label_a1; break;
01721                       default: assert(0);
01722                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/  
01723                 break;
01724               case 7: 
01725                 
01726                   switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
01727                     case 0: case 1: 
01728                       if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
01729                         
01730                           switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
01731                             case 0: 
01732                               goto MATCH_label_a11; break;
01733                             case 1: case 2: 
01734                               MATCH_name = 
01735                                 MATCH_name_sz_31[(MATCH_w_16_0 >> 6 & 0x3) 
01736                                     /* sz at 0 */]; 
01737                               goto MATCH_label_a12; 
01738                               
01739                               break;
01740                             case 3: 
01741                               MATCH_name = 
01742                                 MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
01743                                     /* sz at 0 */]; 
01744                               goto MATCH_label_a12; 
01745                               
01746                               break;
01747                             default: assert(0);
01748                           } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
01749                       else 
01750                         
01751                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
01752                             case 0: 
01753                               
01754                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
01755                                       /* sz at 0 */) {
01756                                   case 0: 
01757                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01758                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
01759                                             /* iReg at 16 */ == 0 && 
01760                                       (MATCH_w_16_16 >> 11 & 0x1) 
01761                                             /* iSize at 16 */ == 0 && 
01762                                       (MATCH_w_16_16 >> 15 & 0x1) 
01763                                             /* iType at 16 */ == 0 && 
01764                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01765                                             /* null at 16 */ && 
01766                                       (MATCH_w_16_16 >> 8 & 0x7) 
01767                                             /* null at 16 */ < 8) || 
01768                                       (MATCH_w_16_16 >> 12 & 0x7) 
01769                                             /* iReg at 16 */ == 0 && 
01770                                       (MATCH_w_16_16 >> 11 & 0x1) 
01771                                             /* iSize at 16 */ == 0 && 
01772                                       (MATCH_w_16_16 >> 15 & 0x1) 
01773                                             /* iType at 16 */ == 1 || 
01774                                       (MATCH_w_16_16 >> 12 & 0x7) 
01775                                             /* iReg at 16 */ == 0 && 
01776                                       (MATCH_w_16_16 >> 11 & 0x1) 
01777                                             /* iSize at 16 */ == 1 || 
01778                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01779                                             /* iReg at 16 */ && 
01780                                       (MATCH_w_16_16 >> 12 & 0x7) 
01781                                             /* iReg at 16 */ < 8) 
01782                                       goto MATCH_label_a1;  /*opt-block+*/
01783                                     else { 
01784                                       MATCH_name = "orib.ex"; 
01785                                       goto MATCH_label_a6; 
01786                                       
01787                                     } /*opt-block*/
01788                                     
01789                                     break;
01790                                   case 1: 
01791                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01792                                     MATCH_name = 
01793                                       MATCH_name_sz_17[(MATCH_w_16_0 >> 6 & 0x3) 
01794                                           /* sz at 0 */]; 
01795                                     goto MATCH_label_a7; 
01796                                     
01797                                     break;
01798                                   case 2: 
01799                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01800                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
01801                                     MATCH_name = 
01802                                       MATCH_name_sz_17[(MATCH_w_16_0 >> 6 & 0x3) 
01803                                           /* sz at 0 */]; 
01804                                     goto MATCH_label_a8; 
01805                                     
01806                                     break;
01807                                   case 3: 
01808                                     goto MATCH_label_a1; break;
01809                                   default: assert(0);
01810                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
01811                                       -- sz at 0 --*/ 
01812                               break;
01813                             case 1: 
01814                               
01815                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
01816                                       /* sz at 0 */) {
01817                                   case 0: 
01818                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01819                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
01820                                             /* iReg at 16 */ == 0 && 
01821                                       (MATCH_w_16_16 >> 11 & 0x1) 
01822                                             /* iSize at 16 */ == 0 && 
01823                                       (MATCH_w_16_16 >> 15 & 0x1) 
01824                                             /* iType at 16 */ == 0 && 
01825                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01826                                             /* null at 16 */ && 
01827                                       (MATCH_w_16_16 >> 8 & 0x7) 
01828                                             /* null at 16 */ < 8) || 
01829                                       (MATCH_w_16_16 >> 12 & 0x7) 
01830                                             /* iReg at 16 */ == 0 && 
01831                                       (MATCH_w_16_16 >> 11 & 0x1) 
01832                                             /* iSize at 16 */ == 0 && 
01833                                       (MATCH_w_16_16 >> 15 & 0x1) 
01834                                             /* iType at 16 */ == 1 || 
01835                                       (MATCH_w_16_16 >> 12 & 0x7) 
01836                                             /* iReg at 16 */ == 0 && 
01837                                       (MATCH_w_16_16 >> 11 & 0x1) 
01838                                             /* iSize at 16 */ == 1 || 
01839                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01840                                             /* iReg at 16 */ && 
01841                                       (MATCH_w_16_16 >> 12 & 0x7) 
01842                                             /* iReg at 16 */ < 8) 
01843                                       goto MATCH_label_a1;  /*opt-block+*/
01844                                     else { 
01845                                       MATCH_name = "andib.ex"; 
01846                                       goto MATCH_label_a6; 
01847                                       
01848                                     } /*opt-block*/
01849                                     
01850                                     break;
01851                                   case 1: 
01852                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01853                                     MATCH_name = 
01854                                       MATCH_name_sz_19[(MATCH_w_16_0 >> 6 & 0x3) 
01855                                           /* sz at 0 */]; 
01856                                     goto MATCH_label_a7; 
01857                                     
01858                                     break;
01859                                   case 2: 
01860                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01861                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
01862                                     MATCH_name = 
01863                                       MATCH_name_sz_19[(MATCH_w_16_0 >> 6 & 0x3) 
01864                                           /* sz at 0 */]; 
01865                                     goto MATCH_label_a8; 
01866                                     
01867                                     break;
01868                                   case 3: 
01869                                     goto MATCH_label_a1; break;
01870                                   default: assert(0);
01871                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
01872                                       -- sz at 0 --*/ 
01873                               break;
01874                             case 2: 
01875                               
01876                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
01877                                       /* sz at 0 */) {
01878                                   case 0: 
01879                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01880                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
01881                                             /* iReg at 16 */ == 0 && 
01882                                       (MATCH_w_16_16 >> 11 & 0x1) 
01883                                             /* iSize at 16 */ == 0 && 
01884                                       (MATCH_w_16_16 >> 15 & 0x1) 
01885                                             /* iType at 16 */ == 0 && 
01886                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01887                                             /* null at 16 */ && 
01888                                       (MATCH_w_16_16 >> 8 & 0x7) 
01889                                             /* null at 16 */ < 8) || 
01890                                       (MATCH_w_16_16 >> 12 & 0x7) 
01891                                             /* iReg at 16 */ == 0 && 
01892                                       (MATCH_w_16_16 >> 11 & 0x1) 
01893                                             /* iSize at 16 */ == 0 && 
01894                                       (MATCH_w_16_16 >> 15 & 0x1) 
01895                                             /* iType at 16 */ == 1 || 
01896                                       (MATCH_w_16_16 >> 12 & 0x7) 
01897                                             /* iReg at 16 */ == 0 && 
01898                                       (MATCH_w_16_16 >> 11 & 0x1) 
01899                                             /* iSize at 16 */ == 1 || 
01900                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01901                                             /* iReg at 16 */ && 
01902                                       (MATCH_w_16_16 >> 12 & 0x7) 
01903                                             /* iReg at 16 */ < 8) 
01904                                       goto MATCH_label_a1;  /*opt-block+*/
01905                                     else { 
01906                                       MATCH_name = "subib.ex"; 
01907                                       goto MATCH_label_a6; 
01908                                       
01909                                     } /*opt-block*/
01910                                     
01911                                     break;
01912                                   case 1: 
01913                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01914                                     MATCH_name = 
01915                                       MATCH_name_sz_21[(MATCH_w_16_0 >> 6 & 0x3) 
01916                                           /* sz at 0 */]; 
01917                                     goto MATCH_label_a7; 
01918                                     
01919                                     break;
01920                                   case 2: 
01921                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01922                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
01923                                     MATCH_name = 
01924                                       MATCH_name_sz_21[(MATCH_w_16_0 >> 6 & 0x3) 
01925                                           /* sz at 0 */]; 
01926                                     goto MATCH_label_a8; 
01927                                     
01928                                     break;
01929                                   case 3: 
01930                                     goto MATCH_label_a1; break;
01931                                   default: assert(0);
01932                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
01933                                       -- sz at 0 --*/ 
01934                               break;
01935                             case 3: 
01936                               
01937                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
01938                                       /* sz at 0 */) {
01939                                   case 0: 
01940                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01941                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
01942                                             /* iReg at 16 */ == 0 && 
01943                                       (MATCH_w_16_16 >> 11 & 0x1) 
01944                                             /* iSize at 16 */ == 0 && 
01945                                       (MATCH_w_16_16 >> 15 & 0x1) 
01946                                             /* iType at 16 */ == 0 && 
01947                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
01948                                             /* null at 16 */ && 
01949                                       (MATCH_w_16_16 >> 8 & 0x7) 
01950                                             /* null at 16 */ < 8) || 
01951                                       (MATCH_w_16_16 >> 12 & 0x7) 
01952                                             /* iReg at 16 */ == 0 && 
01953                                       (MATCH_w_16_16 >> 11 & 0x1) 
01954                                             /* iSize at 16 */ == 0 && 
01955                                       (MATCH_w_16_16 >> 15 & 0x1) 
01956                                             /* iType at 16 */ == 1 || 
01957                                       (MATCH_w_16_16 >> 12 & 0x7) 
01958                                             /* iReg at 16 */ == 0 && 
01959                                       (MATCH_w_16_16 >> 11 & 0x1) 
01960                                             /* iSize at 16 */ == 1 || 
01961                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
01962                                             /* iReg at 16 */ && 
01963                                       (MATCH_w_16_16 >> 12 & 0x7) 
01964                                             /* iReg at 16 */ < 8) 
01965                                       goto MATCH_label_a1;  /*opt-block+*/
01966                                     else { 
01967                                       MATCH_name = "addib.ex"; 
01968                                       goto MATCH_label_a6; 
01969                                       
01970                                     } /*opt-block*/
01971                                     
01972                                     break;
01973                                   case 1: 
01974                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01975                                     MATCH_name = 
01976                                       MATCH_name_sz_23[(MATCH_w_16_0 >> 6 & 0x3) 
01977                                           /* sz at 0 */]; 
01978                                     goto MATCH_label_a7; 
01979                                     
01980                                     break;
01981                                   case 2: 
01982                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
01983                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
01984                                     MATCH_name = 
01985                                       MATCH_name_sz_23[(MATCH_w_16_0 >> 6 & 0x3) 
01986                                           /* sz at 0 */]; 
01987                                     goto MATCH_label_a8; 
01988                                     
01989                                     break;
01990                                   case 3: 
01991                                     goto MATCH_label_a1; break;
01992                                   default: assert(0);
01993                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
01994                                       -- sz at 0 --*/ 
01995                               break;
01996                             case 4: 
01997                               
01998                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
01999                                       /* sz at 0 */) {
02000                                   case 0: 
02001                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02002                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02003                                             /* iReg at 16 */ == 0 && 
02004                                       (MATCH_w_16_16 >> 11 & 0x1) 
02005                                             /* iSize at 16 */ == 0 && 
02006                                       (MATCH_w_16_16 >> 15 & 0x1) 
02007                                             /* iType at 16 */ == 0 && 
02008                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02009                                             /* null at 16 */ && 
02010                                       (MATCH_w_16_16 >> 8 & 0x7) 
02011                                             /* null at 16 */ < 8) || 
02012                                       (MATCH_w_16_16 >> 12 & 0x7) 
02013                                             /* iReg at 16 */ == 0 && 
02014                                       (MATCH_w_16_16 >> 11 & 0x1) 
02015                                             /* iSize at 16 */ == 0 && 
02016                                       (MATCH_w_16_16 >> 15 & 0x1) 
02017                                             /* iType at 16 */ == 1 || 
02018                                       (MATCH_w_16_16 >> 12 & 0x7) 
02019                                             /* iReg at 16 */ == 0 && 
02020                                       (MATCH_w_16_16 >> 11 & 0x1) 
02021                                             /* iSize at 16 */ == 1 || 
02022                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02023                                             /* iReg at 16 */ && 
02024                                       (MATCH_w_16_16 >> 12 & 0x7) 
02025                                             /* iReg at 16 */ < 8) 
02026                                       goto MATCH_label_a1;  /*opt-block+*/
02027                                     else 
02028                                       goto MATCH_label_a9;  /*opt-block+*/
02029                                     
02030                                     break;
02031                                   case 1: 
02032                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02033                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02034                                             /* iReg at 16 */ == 0 && 
02035                                       (MATCH_w_16_16 >> 11 & 0x1) 
02036                                             /* iSize at 16 */ == 0 && 
02037                                       (MATCH_w_16_16 >> 15 & 0x1) 
02038                                             /* iType at 16 */ == 0 && 
02039                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02040                                             /* null at 16 */ && 
02041                                       (MATCH_w_16_16 >> 8 & 0x7) 
02042                                             /* null at 16 */ < 8) || 
02043                                       (MATCH_w_16_16 >> 12 & 0x7) 
02044                                             /* iReg at 16 */ == 0 && 
02045                                       (MATCH_w_16_16 >> 11 & 0x1) 
02046                                             /* iSize at 16 */ == 0 && 
02047                                       (MATCH_w_16_16 >> 15 & 0x1) 
02048                                             /* iType at 16 */ == 1 || 
02049                                       (MATCH_w_16_16 >> 12 & 0x7) 
02050                                             /* iReg at 16 */ == 0 && 
02051                                       (MATCH_w_16_16 >> 11 & 0x1) 
02052                                             /* iSize at 16 */ == 1 || 
02053                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02054                                             /* iReg at 16 */ && 
02055                                       (MATCH_w_16_16 >> 12 & 0x7) 
02056                                             /* iReg at 16 */ < 8) 
02057                                       goto MATCH_label_a1;  /*opt-block+*/
02058                                     else { 
02059                                       MATCH_name = "bchgi.ex"; 
02060                                       goto MATCH_label_a10; 
02061                                       
02062                                     } /*opt-block*/
02063                                     
02064                                     break;
02065                                   case 2: 
02066                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02067                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02068                                             /* iReg at 16 */ == 0 && 
02069                                       (MATCH_w_16_16 >> 11 & 0x1) 
02070                                             /* iSize at 16 */ == 0 && 
02071                                       (MATCH_w_16_16 >> 15 & 0x1) 
02072                                             /* iType at 16 */ == 0 && 
02073                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02074                                             /* null at 16 */ && 
02075                                       (MATCH_w_16_16 >> 8 & 0x7) 
02076                                             /* null at 16 */ < 8) || 
02077                                       (MATCH_w_16_16 >> 12 & 0x7) 
02078                                             /* iReg at 16 */ == 0 && 
02079                                       (MATCH_w_16_16 >> 11 & 0x1) 
02080                                             /* iSize at 16 */ == 0 && 
02081                                       (MATCH_w_16_16 >> 15 & 0x1) 
02082                                             /* iType at 16 */ == 1 || 
02083                                       (MATCH_w_16_16 >> 12 & 0x7) 
02084                                             /* iReg at 16 */ == 0 && 
02085                                       (MATCH_w_16_16 >> 11 & 0x1) 
02086                                             /* iSize at 16 */ == 1 || 
02087                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02088                                             /* iReg at 16 */ && 
02089                                       (MATCH_w_16_16 >> 12 & 0x7) 
02090                                             /* iReg at 16 */ < 8) 
02091                                       goto MATCH_label_a1;  /*opt-block+*/
02092                                     else { 
02093                                       MATCH_name = "bclri.ex"; 
02094                                       goto MATCH_label_a10; 
02095                                       
02096                                     } /*opt-block*/
02097                                     
02098                                     break;
02099                                   case 3: 
02100                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02101                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02102                                             /* iReg at 16 */ == 0 && 
02103                                       (MATCH_w_16_16 >> 11 & 0x1) 
02104                                             /* iSize at 16 */ == 0 && 
02105                                       (MATCH_w_16_16 >> 15 & 0x1) 
02106                                             /* iType at 16 */ == 0 && 
02107                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02108                                             /* null at 16 */ && 
02109                                       (MATCH_w_16_16 >> 8 & 0x7) 
02110                                             /* null at 16 */ < 8) || 
02111                                       (MATCH_w_16_16 >> 12 & 0x7) 
02112                                             /* iReg at 16 */ == 0 && 
02113                                       (MATCH_w_16_16 >> 11 & 0x1) 
02114                                             /* iSize at 16 */ == 0 && 
02115                                       (MATCH_w_16_16 >> 15 & 0x1) 
02116                                             /* iType at 16 */ == 1 || 
02117                                       (MATCH_w_16_16 >> 12 & 0x7) 
02118                                             /* iReg at 16 */ == 0 && 
02119                                       (MATCH_w_16_16 >> 11 & 0x1) 
02120                                             /* iSize at 16 */ == 1 || 
02121                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02122                                             /* iReg at 16 */ && 
02123                                       (MATCH_w_16_16 >> 12 & 0x7) 
02124                                             /* iReg at 16 */ < 8) 
02125                                       goto MATCH_label_a1;  /*opt-block+*/
02126                                     else { 
02127                                       MATCH_name = "bseti.ex"; 
02128                                       goto MATCH_label_a10; 
02129                                       
02130                                     } /*opt-block*/
02131                                     
02132                                     break;
02133                                   default: assert(0);
02134                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
02135                                       -- sz at 0 --*/ 
02136                               break;
02137                             case 5: 
02138                               
02139                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
02140                                       /* sz at 0 */) {
02141                                   case 0: 
02142                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02143                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02144                                             /* iReg at 16 */ == 0 && 
02145                                       (MATCH_w_16_16 >> 11 & 0x1) 
02146                                             /* iSize at 16 */ == 0 && 
02147                                       (MATCH_w_16_16 >> 15 & 0x1) 
02148                                             /* iType at 16 */ == 0 && 
02149                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02150                                             /* null at 16 */ && 
02151                                       (MATCH_w_16_16 >> 8 & 0x7) 
02152                                             /* null at 16 */ < 8) || 
02153                                       (MATCH_w_16_16 >> 12 & 0x7) 
02154                                             /* iReg at 16 */ == 0 && 
02155                                       (MATCH_w_16_16 >> 11 & 0x1) 
02156                                             /* iSize at 16 */ == 0 && 
02157                                       (MATCH_w_16_16 >> 15 & 0x1) 
02158                                             /* iType at 16 */ == 1 || 
02159                                       (MATCH_w_16_16 >> 12 & 0x7) 
02160                                             /* iReg at 16 */ == 0 && 
02161                                       (MATCH_w_16_16 >> 11 & 0x1) 
02162                                             /* iSize at 16 */ == 1 || 
02163                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02164                                             /* iReg at 16 */ && 
02165                                       (MATCH_w_16_16 >> 12 & 0x7) 
02166                                             /* iReg at 16 */ < 8) 
02167                                       goto MATCH_label_a1;  /*opt-block+*/
02168                                     else { 
02169                                       MATCH_name = "eorib.ex"; 
02170                                       goto MATCH_label_a6; 
02171                                       
02172                                     } /*opt-block*/
02173                                     
02174                                     break;
02175                                   case 1: 
02176                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02177                                     MATCH_name = 
02178                                       MATCH_name_sz_28[(MATCH_w_16_0 >> 6 & 0x3) 
02179                                           /* sz at 0 */]; 
02180                                     goto MATCH_label_a7; 
02181                                     
02182                                     break;
02183                                   case 2: 
02184                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02185                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
02186                                     MATCH_name = 
02187                                       MATCH_name_sz_28[(MATCH_w_16_0 >> 6 & 0x3) 
02188                                           /* sz at 0 */]; 
02189                                     goto MATCH_label_a8; 
02190                                     
02191                                     break;
02192                                   case 3: 
02193                                     goto MATCH_label_a1; break;
02194                                   default: assert(0);
02195                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
02196                                       -- sz at 0 --*/ 
02197                               break;
02198                             case 6: 
02199                               
02200                                 switch((MATCH_w_16_0 >> 6 & 0x3) 
02201                                       /* sz at 0 */) {
02202                                   case 0: 
02203                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02204                                     if ((MATCH_w_16_16 >> 12 & 0x7) 
02205                                             /* iReg at 16 */ == 0 && 
02206                                       (MATCH_w_16_16 >> 11 & 0x1) 
02207                                             /* iSize at 16 */ == 0 && 
02208                                       (MATCH_w_16_16 >> 15 & 0x1) 
02209                                             /* iType at 16 */ == 0 && 
02210                                       (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02211                                             /* null at 16 */ && 
02212                                       (MATCH_w_16_16 >> 8 & 0x7) 
02213                                             /* null at 16 */ < 8) || 
02214                                       (MATCH_w_16_16 >> 12 & 0x7) 
02215                                             /* iReg at 16 */ == 0 && 
02216                                       (MATCH_w_16_16 >> 11 & 0x1) 
02217                                             /* iSize at 16 */ == 0 && 
02218                                       (MATCH_w_16_16 >> 15 & 0x1) 
02219                                             /* iType at 16 */ == 1 || 
02220                                       (MATCH_w_16_16 >> 12 & 0x7) 
02221                                             /* iReg at 16 */ == 0 && 
02222                                       (MATCH_w_16_16 >> 11 & 0x1) 
02223                                             /* iSize at 16 */ == 1 || 
02224                                       1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02225                                             /* iReg at 16 */ && 
02226                                       (MATCH_w_16_16 >> 12 & 0x7) 
02227                                             /* iReg at 16 */ < 8) 
02228                                       goto MATCH_label_a1;  /*opt-block+*/
02229                                     else { 
02230                                       MATCH_name = "cmpib.ex"; 
02231                                       goto MATCH_label_a6; 
02232                                       
02233                                     } /*opt-block*/
02234                                     
02235                                     break;
02236                                   case 1: 
02237                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02238                                     MATCH_name = 
02239                                       MATCH_name_sz_30[(MATCH_w_16_0 >> 6 & 0x3) 
02240                                           /* sz at 0 */]; 
02241                                     goto MATCH_label_a7; 
02242                                     
02243                                     break;
02244                                   case 2: 
02245                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
02246                                     MATCH_w_16_32 = getWord(4 + MATCH_p); 
02247                                     MATCH_name = 
02248                                       MATCH_name_sz_30[(MATCH_w_16_0 >> 6 & 0x3) 
02249                                           /* sz at 0 */]; 
02250                                     goto MATCH_label_a8; 
02251                                     
02252                                     break;
02253                                   case 3: 
02254                                     goto MATCH_label_a1; break;
02255                                   default: assert(0);
02256                                 } /* (MATCH_w_16_0 >> 6 & 0x3) 
02257                                       -- sz at 0 --*/ 
02258                               break;
02259                             case 7: 
02260                               goto MATCH_label_a1; break;
02261                             default: assert(0);
02262                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/  
02263                       break;
02264                     case 2: case 3: 
02265                       if ((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */ == 0) 
02266                         if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
02267                           goto MATCH_label_a11;  /*opt-block+*/
02268                         else { 
02269                           MATCH_w_16_16 = getWord(2 + MATCH_p); 
02270                           if (0 <= (MATCH_w_16_0 >> 9 & 0x7) 
02271                                   /* reg1 at 0 */ && 
02272                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 4 || 
02273                             5 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
02274                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 8 || 
02275                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ == 4 && 
02276                             (MATCH_w_16_16 >> 12 & 0x7) 
02277                                   /* iReg at 16 */ == 0 && 
02278                             (MATCH_w_16_16 >> 11 & 0x1) 
02279                                   /* iSize at 16 */ == 0 && 
02280                             (MATCH_w_16_16 >> 15 & 0x1) 
02281                                   /* iType at 16 */ == 0 && 
02282                             (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02283                                   /* null at 16 */ && 
02284                             (MATCH_w_16_16 >> 8 & 0x7) 
02285                                   /* null at 16 */ < 8) || 
02286                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ == 4 && 
02287                             (MATCH_w_16_16 >> 12 & 0x7) 
02288                                   /* iReg at 16 */ == 0 && 
02289                             (MATCH_w_16_16 >> 11 & 0x1) 
02290                                   /* iSize at 16 */ == 0 && 
02291                             (MATCH_w_16_16 >> 15 & 0x1) 
02292                                   /* iType at 16 */ == 1 || 
02293                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ == 4 && 
02294                             (MATCH_w_16_16 >> 12 & 0x7) 
02295                                   /* iReg at 16 */ == 0 && 
02296                             (MATCH_w_16_16 >> 11 & 0x1) 
02297                                   /* iSize at 16 */ == 1 || 
02298                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ == 4 && 
02299                             (1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02300                                   /* iReg at 16 */ && 
02301                             (MATCH_w_16_16 >> 12 & 0x7) 
02302                                   /* iReg at 16 */ < 8)) 
02303                             goto MATCH_label_a1;  /*opt-block+*/
02304                           else 
02305                             goto MATCH_label_a9;  /*opt-block+*/
02306                           
02307                         } /*opt-block*/ 
02308                       else 
02309                         goto MATCH_label_a1;  /*opt-block+*/
02310                       break;
02311                     case 4: 
02312                       if ((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */ == 0) 
02313                         if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
02314                           goto MATCH_label_a11;  /*opt-block+*/
02315                         else 
02316                           
02317                             switch((MATCH_w_16_0 >> 9 & 0x7) 
02318                                   /* reg1 at 0 */) {
02319                               case 0: 
02320                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02321                                 if ((MATCH_w_16_16 >> 12 & 0x7) 
02322                                         /* iReg at 16 */ == 0 && 
02323                                   (MATCH_w_16_16 >> 11 & 0x1) 
02324                                         /* iSize at 16 */ == 0 && 
02325                                   (MATCH_w_16_16 >> 15 & 0x1) 
02326                                         /* iType at 16 */ == 0 && 
02327                                   (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02328                                         /* null at 16 */ && 
02329                                   (MATCH_w_16_16 >> 8 & 0x7) 
02330                                         /* null at 16 */ < 8) || 
02331                                   (MATCH_w_16_16 >> 12 & 0x7) 
02332                                         /* iReg at 16 */ == 0 && 
02333                                   (MATCH_w_16_16 >> 11 & 0x1) 
02334                                         /* iSize at 16 */ == 0 && 
02335                                   (MATCH_w_16_16 >> 15 & 0x1) 
02336                                         /* iType at 16 */ == 1 || 
02337                                   (MATCH_w_16_16 >> 12 & 0x7) 
02338                                         /* iReg at 16 */ == 0 && 
02339                                   (MATCH_w_16_16 >> 11 & 0x1) 
02340                                         /* iSize at 16 */ == 1 || 
02341                                   1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02342                                         /* iReg at 16 */ && 
02343                                   (MATCH_w_16_16 >> 12 & 0x7) 
02344                                         /* iReg at 16 */ < 8) 
02345                                   goto MATCH_label_a1;  /*opt-block+*/
02346                                 else { 
02347                                   MATCH_name = "oriToCCR"; 
02348                                   goto MATCH_label_a13; 
02349                                   
02350                                 } /*opt-block*/
02351                                 
02352                                 break;
02353                               case 1: 
02354                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02355                                 if ((MATCH_w_16_16 >> 12 & 0x7) 
02356                                         /* iReg at 16 */ == 0 && 
02357                                   (MATCH_w_16_16 >> 11 & 0x1) 
02358                                         /* iSize at 16 */ == 0 && 
02359                                   (MATCH_w_16_16 >> 15 & 0x1) 
02360                                         /* iType at 16 */ == 0 && 
02361                                   (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02362                                         /* null at 16 */ && 
02363                                   (MATCH_w_16_16 >> 8 & 0x7) 
02364                                         /* null at 16 */ < 8) || 
02365                                   (MATCH_w_16_16 >> 12 & 0x7) 
02366                                         /* iReg at 16 */ == 0 && 
02367                                   (MATCH_w_16_16 >> 11 & 0x1) 
02368                                         /* iSize at 16 */ == 0 && 
02369                                   (MATCH_w_16_16 >> 15 & 0x1) 
02370                                         /* iType at 16 */ == 1 || 
02371                                   (MATCH_w_16_16 >> 12 & 0x7) 
02372                                         /* iReg at 16 */ == 0 && 
02373                                   (MATCH_w_16_16 >> 11 & 0x1) 
02374                                         /* iSize at 16 */ == 1 || 
02375                                   1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02376                                         /* iReg at 16 */ && 
02377                                   (MATCH_w_16_16 >> 12 & 0x7) 
02378                                         /* iReg at 16 */ < 8) 
02379                                   goto MATCH_label_a1;  /*opt-block+*/
02380                                 else { 
02381                                   MATCH_name = "andiToCCR"; 
02382                                   goto MATCH_label_a13; 
02383                                   
02384                                 } /*opt-block*/
02385                                 
02386                                 break;
02387                               case 2: case 3: case 6: case 7: 
02388                                 goto MATCH_label_a1; break;
02389                               case 4: 
02390                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02391                                 if ((MATCH_w_16_16 >> 12 & 0x7) 
02392                                         /* iReg at 16 */ == 0 && 
02393                                   (MATCH_w_16_16 >> 11 & 0x1) 
02394                                         /* iSize at 16 */ == 0 && 
02395                                   (MATCH_w_16_16 >> 15 & 0x1) 
02396                                         /* iType at 16 */ == 0 && 
02397                                   (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02398                                         /* null at 16 */ && 
02399                                   (MATCH_w_16_16 >> 8 & 0x7) 
02400                                         /* null at 16 */ < 8) || 
02401                                   (MATCH_w_16_16 >> 12 & 0x7) 
02402                                         /* iReg at 16 */ == 0 && 
02403                                   (MATCH_w_16_16 >> 11 & 0x1) 
02404                                         /* iSize at 16 */ == 0 && 
02405                                   (MATCH_w_16_16 >> 15 & 0x1) 
02406                                         /* iType at 16 */ == 1 || 
02407                                   (MATCH_w_16_16 >> 12 & 0x7) 
02408                                         /* iReg at 16 */ == 0 && 
02409                                   (MATCH_w_16_16 >> 11 & 0x1) 
02410                                         /* iSize at 16 */ == 1 || 
02411                                   1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02412                                         /* iReg at 16 */ && 
02413                                   (MATCH_w_16_16 >> 12 & 0x7) 
02414                                         /* iReg at 16 */ < 8) 
02415                                   goto MATCH_label_a1;  /*opt-block+*/
02416                                 else 
02417                                   goto MATCH_label_a9;  /*opt-block+*/
02418                                 
02419                                 break;
02420                               case 5: 
02421                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02422                                 if ((MATCH_w_16_16 >> 12 & 0x7) 
02423                                         /* iReg at 16 */ == 0 && 
02424                                   (MATCH_w_16_16 >> 11 & 0x1) 
02425                                         /* iSize at 16 */ == 0 && 
02426                                   (MATCH_w_16_16 >> 15 & 0x1) 
02427                                         /* iType at 16 */ == 0 && 
02428                                   (1 <= (MATCH_w_16_16 >> 8 & 0x7) 
02429                                         /* null at 16 */ && 
02430                                   (MATCH_w_16_16 >> 8 & 0x7) 
02431                                         /* null at 16 */ < 8) || 
02432                                   (MATCH_w_16_16 >> 12 & 0x7) 
02433                                         /* iReg at 16 */ == 0 && 
02434                                   (MATCH_w_16_16 >> 11 & 0x1) 
02435                                         /* iSize at 16 */ == 0 && 
02436                                   (MATCH_w_16_16 >> 15 & 0x1) 
02437                                         /* iType at 16 */ == 1 || 
02438                                   (MATCH_w_16_16 >> 12 & 0x7) 
02439                                         /* iReg at 16 */ == 0 && 
02440                                   (MATCH_w_16_16 >> 11 & 0x1) 
02441                                         /* iSize at 16 */ == 1 || 
02442                                   1 <= (MATCH_w_16_16 >> 12 & 0x7) 
02443                                         /* iReg at 16 */ && 
02444                                   (MATCH_w_16_16 >> 12 & 0x7) 
02445                                         /* iReg at 16 */ < 8) 
02446                                   goto MATCH_label_a1;  /*opt-block+*/
02447                                 else { 
02448                                   MATCH_name = "eoriToCCR"; 
02449                                   goto MATCH_label_a13; 
02450                                   
02451                                 } /*opt-block*/
02452                                 
02453                                 break;
02454                               default: assert(0);
02455                             } /* (MATCH_w_16_0 >> 9 & 0x7) 
02456                                   -- reg1 at 0 --*/   
02457                       else 
02458                         goto MATCH_label_a1;  /*opt-block+*/
02459                       break;
02460                     case 5: case 6: case 7: 
02461                       goto MATCH_label_a1; break;
02462                     default: assert(0);
02463                   } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02464                 break;
02465               default: assert(0);
02466             } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02467           break;
02468         case 1: 
02469           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
02470             if ((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */ == 3) 
02471               if (0 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
02472                 (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 2) 
02473                 
02474                   switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02475                     case 0: case 1: case 2: case 3: case 4: 
02476                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
02477                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
02478                         MATCH_name = 
02479                           MATCH_name_MDadrm_39[(MATCH_w_16_0 >> 6 & 0x7) 
02480                               /* MDadrm at 0 */]; 
02481                         goto MATCH_label_a17; 
02482                         
02483                       } /*opt-block*/
02484                       else { 
02485                         MATCH_name = 
02486                           MATCH_name_MDadrm_39[(MATCH_w_16_0 >> 6 & 0x7) 
02487                               /* MDadrm at 0 */]; 
02488                         goto MATCH_label_a14; 
02489                         
02490                       } /*opt-block*/
02491                       
02492                       break;
02493                     case 5: case 6: 
02494                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
02495                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
02496                         MATCH_name = 
02497                           MATCH_name_MDadrm_40[(MATCH_w_16_0 >> 6 & 0x7) 
02498                               /* MDadrm at 0 */]; 
02499                         goto MATCH_label_a18; 
02500                         
02501                       } /*opt-block*/
02502                       else { 
02503                         MATCH_name = 
02504                           MATCH_name_MDadrm_40[(MATCH_w_16_0 >> 6 & 0x7) 
02505                               /* MDadrm at 0 */]; 
02506                         goto MATCH_label_a15; 
02507                         
02508                       } /*opt-block*/
02509                       
02510                       break;
02511                     case 7: 
02512                       
02513                         switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02514                           case 0: case 2: case 3: case 4: 
02515                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
02516                                     /* MDadrm at 0 */ && 
02517                               (MATCH_w_16_0 >> 6 & 0x7) 
02518                                     /* MDadrm at 0 */ < 8) { 
02519                               MATCH_name = 
02520                                 MATCH_name_MDadrm_40[(MATCH_w_16_0 >> 6 & 0x7) 
02521                                     /* MDadrm at 0 */]; 
02522                               goto MATCH_label_a18; 
02523                               
02524                             } /*opt-block*/
02525                             else { 
02526                               MATCH_name = 
02527                                 MATCH_name_MDadrm_40[(MATCH_w_16_0 >> 6 & 0x7) 
02528                                     /* MDadrm at 0 */]; 
02529                               goto MATCH_label_a15; 
02530                               
02531                             } /*opt-block*/
02532                             
02533                             break;
02534                           case 1: 
02535                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
02536                                     /* MDadrm at 0 */ && 
02537                               (MATCH_w_16_0 >> 6 & 0x7) 
02538                                     /* MDadrm at 0 */ < 8) { 
02539                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02540                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02541                               MATCH_name = 
02542                                 MATCH_name_MDadrm_41[(MATCH_w_16_0 >> 6 & 0x7) 
02543                                     /* MDadrm at 0 */]; 
02544                               goto MATCH_label_a19; 
02545                               
02546                             } /*opt-block*/
02547                             else { 
02548                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02549                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02550                               MATCH_name = 
02551                                 MATCH_name_MDadrm_41[(MATCH_w_16_0 >> 6 & 0x7) 
02552                                     /* MDadrm at 0 */]; 
02553                               goto MATCH_label_a16; 
02554                               
02555                             } /*opt-block*/
02556                             
02557                             break;
02558                           case 5: case 6: case 7: 
02559                             goto MATCH_label_a1; break;
02560                           default: assert(0);
02561                         } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02562                       break;
02563                     default: assert(0);
02564                   } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
02565               else 
02566                 
02567                   switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
02568                     case 0: case 1: case 2: case 3: case 4: 
02569                       
02570                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02571                           case 0: case 1: case 2: case 3: case 4: 
02572                             MATCH_name = 
02573                               MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02574                                   /* adrm at 0 */]; 
02575                             goto MATCH_label_a14; 
02576                             
02577                             break;
02578                           case 5: case 6: 
02579                             MATCH_name = 
02580                               MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02581                                   /* adrm at 0 */]; 
02582                             goto MATCH_label_a15; 
02583                             
02584                             break;
02585                           case 7: 
02586                             
02587                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02588                                 case 0: case 2: case 3: case 4: 
02589                                   MATCH_name = 
02590                                     MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02591                                         /* reg2 at 0 */]; 
02592                                   goto MATCH_label_a15; 
02593                                   
02594                                   break;
02595                                 case 1: 
02596                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
02597                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
02598                                   MATCH_name = 
02599                                     MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02600                                         /* reg2 at 0 */]; 
02601                                   goto MATCH_label_a16; 
02602                                   
02603                                   break;
02604                                 case 5: case 6: case 7: 
02605                                   goto MATCH_label_a1; break;
02606                                 default: assert(0);
02607                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02608                             break;
02609                           default: assert(0);
02610                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02611                       break;
02612                     case 5: case 6: 
02613                       
02614                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02615                           case 0: case 1: case 2: case 3: case 4: 
02616                             MATCH_name = 
02617                               MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02618                                   /* adrm at 0 */]; 
02619                             goto MATCH_label_a17; 
02620                             
02621                             break;
02622                           case 5: case 6: 
02623                             MATCH_name = 
02624                               MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02625                                   /* adrm at 0 */]; 
02626                             goto MATCH_label_a18; 
02627                             
02628                             break;
02629                           case 7: 
02630                             
02631                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02632                                 case 0: case 2: case 3: case 4: 
02633                                   MATCH_name = 
02634                                     MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02635                                         /* reg2 at 0 */]; 
02636                                   goto MATCH_label_a18; 
02637                                   
02638                                   break;
02639                                 case 1: 
02640                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
02641                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
02642                                   MATCH_name = 
02643                                     MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02644                                         /* reg2 at 0 */]; 
02645                                   goto MATCH_label_a19; 
02646                                   
02647                                   break;
02648                                 case 5: case 6: case 7: 
02649                                   goto MATCH_label_a1; break;
02650                                 default: assert(0);
02651                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02652                             break;
02653                           default: assert(0);
02654                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02655                       break;
02656                     case 7: 
02657                       goto MATCH_label_a1; break;
02658                     default: assert(0);
02659                   } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
02660             else 
02661               
02662                 switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
02663                   case 0: case 1: case 2: case 3: case 4: 
02664                     
02665                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02666                         case 0: case 1: case 2: case 3: case 4: 
02667                           MATCH_name = 
02668                             MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02669                                 /* adrm at 0 */]; 
02670                           goto MATCH_label_a14; 
02671                           
02672                           break;
02673                         case 5: case 6: 
02674                           MATCH_name = 
02675                             MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02676                                 /* adrm at 0 */]; 
02677                           goto MATCH_label_a15; 
02678                           
02679                           break;
02680                         case 7: 
02681                           
02682                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02683                               case 0: case 2: case 3: case 4: 
02684                                 MATCH_name = 
02685                                   MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02686                                       /* reg2 at 0 */]; 
02687                                 goto MATCH_label_a15; 
02688                                 
02689                                 break;
02690                               case 1: 
02691                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02692                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
02693                                 MATCH_name = 
02694                                   MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02695                                       /* reg2 at 0 */]; 
02696                                 goto MATCH_label_a16; 
02697                                 
02698                                 break;
02699                               case 5: case 6: case 7: 
02700                                 goto MATCH_label_a1; break;
02701                               default: assert(0);
02702                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02703                           break;
02704                         default: assert(0);
02705                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02706                     break;
02707                   case 5: case 6: 
02708                     
02709                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02710                         case 0: case 1: case 2: case 3: case 4: 
02711                           MATCH_name = 
02712                             MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02713                                 /* adrm at 0 */]; 
02714                           goto MATCH_label_a17; 
02715                           
02716                           break;
02717                         case 5: case 6: 
02718                           MATCH_name = 
02719                             MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02720                                 /* adrm at 0 */]; 
02721                           goto MATCH_label_a18; 
02722                           
02723                           break;
02724                         case 7: 
02725                           
02726                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02727                               case 0: case 2: case 3: case 4: 
02728                                 MATCH_name = 
02729                                   MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02730                                       /* reg2 at 0 */]; 
02731                                 goto MATCH_label_a18; 
02732                                 
02733                                 break;
02734                               case 1: 
02735                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
02736                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
02737                                 MATCH_name = 
02738                                   MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02739                                       /* reg2 at 0 */]; 
02740                                 goto MATCH_label_a19; 
02741                                 
02742                                 break;
02743                               case 5: case 6: case 7: 
02744                                 goto MATCH_label_a1; break;
02745                               default: assert(0);
02746                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02747                           break;
02748                         default: assert(0);
02749                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02750                     break;
02751                   case 7: 
02752                     goto MATCH_label_a1; break;
02753                   default: assert(0);
02754                 } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
02755           else 
02756             
02757               switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
02758                 case 0: case 1: case 2: case 3: case 4: 
02759                   
02760                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02761                       case 0: case 1: case 2: case 3: case 4: 
02762                         MATCH_name = 
02763                           MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02764                               /* adrm at 0 */]; 
02765                         goto MATCH_label_a14; 
02766                         
02767                         break;
02768                       case 5: case 6: 
02769                         MATCH_name = 
02770                           MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
02771                               /* adrm at 0 */]; 
02772                         goto MATCH_label_a15; 
02773                         
02774                         break;
02775                       case 7: 
02776                         
02777                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02778                             case 0: case 2: case 3: case 4: 
02779                               MATCH_name = 
02780                                 MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02781                                     /* reg2 at 0 */]; 
02782                               goto MATCH_label_a15; 
02783                               
02784                               break;
02785                             case 1: 
02786                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02787                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02788                               MATCH_name = 
02789                                 MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
02790                                     /* reg2 at 0 */]; 
02791                               goto MATCH_label_a16; 
02792                               
02793                               break;
02794                             case 5: case 6: case 7: 
02795                               goto MATCH_label_a1; break;
02796                             default: assert(0);
02797                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02798                         break;
02799                       default: assert(0);
02800                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02801                   break;
02802                 case 5: case 6: 
02803                   
02804                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02805                       case 0: case 1: case 2: case 3: case 4: 
02806                         MATCH_name = 
02807                           MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02808                               /* adrm at 0 */]; 
02809                         goto MATCH_label_a17; 
02810                         
02811                         break;
02812                       case 5: case 6: 
02813                         MATCH_name = 
02814                           MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
02815                               /* adrm at 0 */]; 
02816                         goto MATCH_label_a18; 
02817                         
02818                         break;
02819                       case 7: 
02820                         
02821                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02822                             case 0: case 2: case 3: case 4: 
02823                               MATCH_name = 
02824                                 MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02825                                     /* reg2 at 0 */]; 
02826                               goto MATCH_label_a18; 
02827                               
02828                               break;
02829                             case 1: 
02830                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02831                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02832                               MATCH_name = 
02833                                 MATCH_name_reg2_38[(MATCH_w_16_0 & 0x7) 
02834                                     /* reg2 at 0 */]; 
02835                               goto MATCH_label_a19; 
02836                               
02837                               break;
02838                             case 5: case 6: case 7: 
02839                               goto MATCH_label_a1; break;
02840                             default: assert(0);
02841                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02842                         break;
02843                       default: assert(0);
02844                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02845                   break;
02846                 case 7: 
02847                   goto MATCH_label_a1; break;
02848                 default: assert(0);
02849               } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/  
02850           break;
02851         case 2: 
02852           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
02853             if ((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */ == 3) 
02854               if (0 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
02855                 (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 2) 
02856                 
02857                   switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02858                     case 0: case 1: case 2: case 3: case 4: 
02859                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
02860                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
02861                         MATCH_name = 
02862                           MATCH_name_MDadrm_46[(MATCH_w_16_0 >> 6 & 0x7) 
02863                               /* MDadrm at 0 */]; 
02864                         goto MATCH_label_a17; 
02865                         
02866                       } /*opt-block*/
02867                       else { 
02868                         MATCH_name = 
02869                           MATCH_name_MDadrm_46[(MATCH_w_16_0 >> 6 & 0x7) 
02870                               /* MDadrm at 0 */]; 
02871                         goto MATCH_label_a14; 
02872                         
02873                       } /*opt-block*/
02874                       
02875                       break;
02876                     case 5: case 6: 
02877                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
02878                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
02879                         MATCH_name = 
02880                           MATCH_name_MDadrm_47[(MATCH_w_16_0 >> 6 & 0x7) 
02881                               /* MDadrm at 0 */]; 
02882                         goto MATCH_label_a18; 
02883                         
02884                       } /*opt-block*/
02885                       else { 
02886                         MATCH_name = 
02887                           MATCH_name_MDadrm_47[(MATCH_w_16_0 >> 6 & 0x7) 
02888                               /* MDadrm at 0 */]; 
02889                         goto MATCH_label_a15; 
02890                         
02891                       } /*opt-block*/
02892                       
02893                       break;
02894                     case 7: 
02895                       
02896                         switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02897                           case 0: case 2: case 3: 
02898                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
02899                                     /* MDadrm at 0 */ && 
02900                               (MATCH_w_16_0 >> 6 & 0x7) 
02901                                     /* MDadrm at 0 */ < 8) { 
02902                               MATCH_name = 
02903                                 MATCH_name_MDadrm_47[(MATCH_w_16_0 >> 6 & 0x7) 
02904                                     /* MDadrm at 0 */]; 
02905                               goto MATCH_label_a18; 
02906                               
02907                             } /*opt-block*/
02908                             else { 
02909                               MATCH_name = 
02910                                 MATCH_name_MDadrm_47[(MATCH_w_16_0 >> 6 & 0x7) 
02911                                     /* MDadrm at 0 */]; 
02912                               goto MATCH_label_a15; 
02913                               
02914                             } /*opt-block*/
02915                             
02916                             break;
02917                           case 1: case 4: 
02918                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
02919                                     /* MDadrm at 0 */ && 
02920                               (MATCH_w_16_0 >> 6 & 0x7) 
02921                                     /* MDadrm at 0 */ < 8) { 
02922                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02923                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02924                               MATCH_name = 
02925                                 MATCH_name_MDadrm_48[(MATCH_w_16_0 >> 6 & 0x7) 
02926                                     /* MDadrm at 0 */]; 
02927                               goto MATCH_label_a19; 
02928                               
02929                             } /*opt-block*/
02930                             else { 
02931                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
02932                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
02933                               MATCH_name = 
02934                                 MATCH_name_MDadrm_48[(MATCH_w_16_0 >> 6 & 0x7) 
02935                                     /* MDadrm at 0 */]; 
02936                               goto MATCH_label_a16; 
02937                               
02938                             } /*opt-block*/
02939                             
02940                             break;
02941                           case 5: case 6: case 7: 
02942                             goto MATCH_label_a1; break;
02943                           default: assert(0);
02944                         } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02945                       break;
02946                     default: assert(0);
02947                   } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
02948               else 
02949                 
02950                   switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
02951                     case 0: case 1: case 2: case 3: case 4: 
02952                       
02953                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02954                           case 0: case 1: case 2: case 3: case 4: 
02955                             MATCH_name = 
02956                               MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
02957                                   /* adrm at 0 */]; 
02958                             goto MATCH_label_a14; 
02959                             
02960                             break;
02961                           case 5: case 6: 
02962                             MATCH_name = 
02963                               MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
02964                                   /* adrm at 0 */]; 
02965                             goto MATCH_label_a15; 
02966                             
02967                             break;
02968                           case 7: 
02969                             
02970                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
02971                                 case 0: case 2: case 3: 
02972                                   MATCH_name = 
02973                                     MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
02974                                         /* reg2 at 0 */]; 
02975                                   goto MATCH_label_a15; 
02976                                   
02977                                   break;
02978                                 case 1: case 4: 
02979                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
02980                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
02981                                   MATCH_name = 
02982                                     MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
02983                                         /* reg2 at 0 */]; 
02984                                   goto MATCH_label_a16; 
02985                                   
02986                                   break;
02987                                 case 5: case 6: case 7: 
02988                                   goto MATCH_label_a1; break;
02989                                 default: assert(0);
02990                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
02991                             break;
02992                           default: assert(0);
02993                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
02994                       break;
02995                     case 5: case 6: 
02996                       
02997                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
02998                           case 0: case 1: case 2: case 3: case 4: 
02999                             MATCH_name = 
03000                               MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03001                                   /* adrm at 0 */]; 
03002                             goto MATCH_label_a17; 
03003                             
03004                             break;
03005                           case 5: case 6: 
03006                             MATCH_name = 
03007                               MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03008                                   /* adrm at 0 */]; 
03009                             goto MATCH_label_a18; 
03010                             
03011                             break;
03012                           case 7: 
03013                             
03014                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03015                                 case 0: case 2: case 3: 
03016                                   MATCH_name = 
03017                                     MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03018                                         /* reg2 at 0 */]; 
03019                                   goto MATCH_label_a18; 
03020                                   
03021                                   break;
03022                                 case 1: case 4: 
03023                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
03024                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
03025                                   MATCH_name = 
03026                                     MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03027                                         /* reg2 at 0 */]; 
03028                                   goto MATCH_label_a19; 
03029                                   
03030                                   break;
03031                                 case 5: case 6: case 7: 
03032                                   goto MATCH_label_a1; break;
03033                                 default: assert(0);
03034                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03035                             break;
03036                           default: assert(0);
03037                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03038                       break;
03039                     case 7: 
03040                       goto MATCH_label_a1; break;
03041                     default: assert(0);
03042                   } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
03043             else 
03044               
03045                 switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
03046                   case 0: case 1: case 2: case 3: case 4: 
03047                     
03048                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03049                         case 0: case 1: case 2: case 3: case 4: 
03050                           MATCH_name = 
03051                             MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
03052                                 /* adrm at 0 */]; 
03053                           goto MATCH_label_a14; 
03054                           
03055                           break;
03056                         case 5: case 6: 
03057                           MATCH_name = 
03058                             MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
03059                                 /* adrm at 0 */]; 
03060                           goto MATCH_label_a15; 
03061                           
03062                           break;
03063                         case 7: 
03064                           
03065                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03066                               case 0: case 2: case 3: 
03067                                 MATCH_name = 
03068                                   MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
03069                                       /* reg2 at 0 */]; 
03070                                 goto MATCH_label_a15; 
03071                                 
03072                                 break;
03073                               case 1: case 4: 
03074                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
03075                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
03076                                 MATCH_name = 
03077                                   MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
03078                                       /* reg2 at 0 */]; 
03079                                 goto MATCH_label_a16; 
03080                                 
03081                                 break;
03082                               case 5: case 6: case 7: 
03083                                 goto MATCH_label_a1; break;
03084                               default: assert(0);
03085                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03086                           break;
03087                         default: assert(0);
03088                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03089                     break;
03090                   case 5: case 6: 
03091                     
03092                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03093                         case 0: case 1: case 2: case 3: case 4: 
03094                           MATCH_name = 
03095                             MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03096                                 /* adrm at 0 */]; 
03097                           goto MATCH_label_a17; 
03098                           
03099                           break;
03100                         case 5: case 6: 
03101                           MATCH_name = 
03102                             MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03103                                 /* adrm at 0 */]; 
03104                           goto MATCH_label_a18; 
03105                           
03106                           break;
03107                         case 7: 
03108                           
03109                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03110                               case 0: case 2: case 3: 
03111                                 MATCH_name = 
03112                                   MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03113                                       /* reg2 at 0 */]; 
03114                                 goto MATCH_label_a18; 
03115                                 
03116                                 break;
03117                               case 1: case 4: 
03118                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
03119                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
03120                                 MATCH_name = 
03121                                   MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03122                                       /* reg2 at 0 */]; 
03123                                 goto MATCH_label_a19; 
03124                                 
03125                                 break;
03126                               case 5: case 6: case 7: 
03127                                 goto MATCH_label_a1; break;
03128                               default: assert(0);
03129                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03130                           break;
03131                         default: assert(0);
03132                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03133                     break;
03134                   case 7: 
03135                     goto MATCH_label_a1; break;
03136                   default: assert(0);
03137                 } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
03138           else 
03139             
03140               switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
03141                 case 0: case 1: case 2: case 3: case 4: 
03142                   
03143                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03144                       case 0: case 1: case 2: case 3: case 4: 
03145                         MATCH_name = 
03146                           MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
03147                               /* adrm at 0 */]; 
03148                         goto MATCH_label_a14; 
03149                         
03150                         break;
03151                       case 5: case 6: 
03152                         MATCH_name = 
03153                           MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
03154                               /* adrm at 0 */]; 
03155                         goto MATCH_label_a15; 
03156                         
03157                         break;
03158                       case 7: 
03159                         
03160                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03161                             case 0: case 2: case 3: 
03162                               MATCH_name = 
03163                                 MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
03164                                     /* reg2 at 0 */]; 
03165                               goto MATCH_label_a15; 
03166                               
03167                               break;
03168                             case 1: case 4: 
03169                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03170                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03171                               MATCH_name = 
03172                                 MATCH_name_reg2_43[(MATCH_w_16_0 & 0x7) 
03173                                     /* reg2 at 0 */]; 
03174                               goto MATCH_label_a16; 
03175                               
03176                               break;
03177                             case 5: case 6: case 7: 
03178                               goto MATCH_label_a1; break;
03179                             default: assert(0);
03180                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03181                         break;
03182                       default: assert(0);
03183                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03184                   break;
03185                 case 5: case 6: 
03186                   
03187                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03188                       case 0: case 1: case 2: case 3: case 4: 
03189                         MATCH_name = 
03190                           MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03191                               /* adrm at 0 */]; 
03192                         goto MATCH_label_a17; 
03193                         
03194                         break;
03195                       case 5: case 6: 
03196                         MATCH_name = 
03197                           MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
03198                               /* adrm at 0 */]; 
03199                         goto MATCH_label_a18; 
03200                         
03201                         break;
03202                       case 7: 
03203                         
03204                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03205                             case 0: case 2: case 3: 
03206                               MATCH_name = 
03207                                 MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03208                                     /* reg2 at 0 */]; 
03209                               goto MATCH_label_a18; 
03210                               
03211                               break;
03212                             case 1: case 4: 
03213                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03214                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03215                               MATCH_name = 
03216                                 MATCH_name_reg2_45[(MATCH_w_16_0 & 0x7) 
03217                                     /* reg2 at 0 */]; 
03218                               goto MATCH_label_a19; 
03219                               
03220                               break;
03221                             case 5: case 6: case 7: 
03222                               goto MATCH_label_a1; break;
03223                             default: assert(0);
03224                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03225                         break;
03226                       default: assert(0);
03227                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03228                   break;
03229                 case 7: 
03230                   goto MATCH_label_a1; break;
03231                 default: assert(0);
03232               } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/  
03233           break;
03234         case 3: 
03235           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
03236             if ((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */ == 3) 
03237               if (0 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
03238                 (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 2) 
03239                 
03240                   switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03241                     case 0: case 1: case 2: case 3: case 4: 
03242                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
03243                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
03244                         MATCH_name = 
03245                           MATCH_name_MDadrm_53[(MATCH_w_16_0 >> 6 & 0x7) 
03246                               /* MDadrm at 0 */]; 
03247                         goto MATCH_label_a17; 
03248                         
03249                       } /*opt-block*/
03250                       else { 
03251                         MATCH_name = 
03252                           MATCH_name_MDadrm_53[(MATCH_w_16_0 >> 6 & 0x7) 
03253                               /* MDadrm at 0 */]; 
03254                         goto MATCH_label_a14; 
03255                         
03256                       } /*opt-block*/
03257                       
03258                       break;
03259                     case 5: case 6: 
03260                       if (5 <= (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ && 
03261                         (MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */ < 8) { 
03262                         MATCH_name = 
03263                           MATCH_name_MDadrm_54[(MATCH_w_16_0 >> 6 & 0x7) 
03264                               /* MDadrm at 0 */]; 
03265                         goto MATCH_label_a18; 
03266                         
03267                       } /*opt-block*/
03268                       else { 
03269                         MATCH_name = 
03270                           MATCH_name_MDadrm_54[(MATCH_w_16_0 >> 6 & 0x7) 
03271                               /* MDadrm at 0 */]; 
03272                         goto MATCH_label_a15; 
03273                         
03274                       } /*opt-block*/
03275                       
03276                       break;
03277                     case 7: 
03278                       
03279                         switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03280                           case 0: case 2: case 3: case 4: 
03281                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
03282                                     /* MDadrm at 0 */ && 
03283                               (MATCH_w_16_0 >> 6 & 0x7) 
03284                                     /* MDadrm at 0 */ < 8) { 
03285                               MATCH_name = 
03286                                 MATCH_name_MDadrm_54[(MATCH_w_16_0 >> 6 & 0x7) 
03287                                     /* MDadrm at 0 */]; 
03288                               goto MATCH_label_a18; 
03289                               
03290                             } /*opt-block*/
03291                             else { 
03292                               MATCH_name = 
03293                                 MATCH_name_MDadrm_54[(MATCH_w_16_0 >> 6 & 0x7) 
03294                                     /* MDadrm at 0 */]; 
03295                               goto MATCH_label_a15; 
03296                               
03297                             } /*opt-block*/
03298                             
03299                             break;
03300                           case 1: 
03301                             if (5 <= (MATCH_w_16_0 >> 6 & 0x7) 
03302                                     /* MDadrm at 0 */ && 
03303                               (MATCH_w_16_0 >> 6 & 0x7) 
03304                                     /* MDadrm at 0 */ < 8) { 
03305                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03306                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03307                               MATCH_name = 
03308                                 MATCH_name_MDadrm_55[(MATCH_w_16_0 >> 6 & 0x7) 
03309                                     /* MDadrm at 0 */]; 
03310                               goto MATCH_label_a19; 
03311                               
03312                             } /*opt-block*/
03313                             else { 
03314                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03315                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03316                               MATCH_name = 
03317                                 MATCH_name_MDadrm_55[(MATCH_w_16_0 >> 6 & 0x7) 
03318                                     /* MDadrm at 0 */]; 
03319                               goto MATCH_label_a16; 
03320                               
03321                             } /*opt-block*/
03322                             
03323                             break;
03324                           case 5: case 6: case 7: 
03325                             goto MATCH_label_a1; break;
03326                           default: assert(0);
03327                         } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03328                       break;
03329                     default: assert(0);
03330                   } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
03331               else 
03332                 
03333                   switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
03334                     case 0: case 1: case 2: case 3: case 4: 
03335                       
03336                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03337                           case 0: case 1: case 2: case 3: case 4: 
03338                             MATCH_name = 
03339                               MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03340                                   /* adrm at 0 */]; 
03341                             goto MATCH_label_a14; 
03342                             
03343                             break;
03344                           case 5: case 6: 
03345                             MATCH_name = 
03346                               MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03347                                   /* adrm at 0 */]; 
03348                             goto MATCH_label_a15; 
03349                             
03350                             break;
03351                           case 7: 
03352                             
03353                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03354                                 case 0: case 2: case 3: case 4: 
03355                                   MATCH_name = 
03356                                     MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03357                                         /* reg2 at 0 */]; 
03358                                   goto MATCH_label_a15; 
03359                                   
03360                                   break;
03361                                 case 1: 
03362                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
03363                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
03364                                   MATCH_name = 
03365                                     MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03366                                         /* reg2 at 0 */]; 
03367                                   goto MATCH_label_a16; 
03368                                   
03369                                   break;
03370                                 case 5: case 6: case 7: 
03371                                   goto MATCH_label_a1; break;
03372                                 default: assert(0);
03373                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03374                             break;
03375                           default: assert(0);
03376                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03377                       break;
03378                     case 5: case 6: 
03379                       
03380                         switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03381                           case 0: case 1: case 2: case 3: case 4: 
03382                             MATCH_name = 
03383                               MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03384                                   /* adrm at 0 */]; 
03385                             goto MATCH_label_a17; 
03386                             
03387                             break;
03388                           case 5: case 6: 
03389                             MATCH_name = 
03390                               MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03391                                   /* adrm at 0 */]; 
03392                             goto MATCH_label_a18; 
03393                             
03394                             break;
03395                           case 7: 
03396                             
03397                               switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03398                                 case 0: case 2: case 3: case 4: 
03399                                   MATCH_name = 
03400                                     MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03401                                         /* reg2 at 0 */]; 
03402                                   goto MATCH_label_a18; 
03403                                   
03404                                   break;
03405                                 case 1: 
03406                                   MATCH_w_16_16 = getWord(2 + MATCH_p); 
03407                                   MATCH_w_16_32 = getWord(4 + MATCH_p); 
03408                                   MATCH_name = 
03409                                     MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03410                                         /* reg2 at 0 */]; 
03411                                   goto MATCH_label_a19; 
03412                                   
03413                                   break;
03414                                 case 5: case 6: case 7: 
03415                                   goto MATCH_label_a1; break;
03416                                 default: assert(0);
03417                               } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03418                             break;
03419                           default: assert(0);
03420                         } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03421                       break;
03422                     case 7: 
03423                       goto MATCH_label_a1; break;
03424                     default: assert(0);
03425                   } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
03426             else 
03427               
03428                 switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
03429                   case 0: case 1: case 2: case 3: case 4: 
03430                     
03431                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03432                         case 0: case 1: case 2: case 3: case 4: 
03433                           MATCH_name = 
03434                             MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03435                                 /* adrm at 0 */]; 
03436                           goto MATCH_label_a14; 
03437                           
03438                           break;
03439                         case 5: case 6: 
03440                           MATCH_name = 
03441                             MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03442                                 /* adrm at 0 */]; 
03443                           goto MATCH_label_a15; 
03444                           
03445                           break;
03446                         case 7: 
03447                           
03448                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03449                               case 0: case 2: case 3: case 4: 
03450                                 MATCH_name = 
03451                                   MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03452                                       /* reg2 at 0 */]; 
03453                                 goto MATCH_label_a15; 
03454                                 
03455                                 break;
03456                               case 1: 
03457                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
03458                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
03459                                 MATCH_name = 
03460                                   MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03461                                       /* reg2 at 0 */]; 
03462                                 goto MATCH_label_a16; 
03463                                 
03464                                 break;
03465                               case 5: case 6: case 7: 
03466                                 goto MATCH_label_a1; break;
03467                               default: assert(0);
03468                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03469                           break;
03470                         default: assert(0);
03471                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03472                     break;
03473                   case 5: case 6: 
03474                     
03475                       switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03476                         case 0: case 1: case 2: case 3: case 4: 
03477                           MATCH_name = 
03478                             MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03479                                 /* adrm at 0 */]; 
03480                           goto MATCH_label_a17; 
03481                           
03482                           break;
03483                         case 5: case 6: 
03484                           MATCH_name = 
03485                             MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03486                                 /* adrm at 0 */]; 
03487                           goto MATCH_label_a18; 
03488                           
03489                           break;
03490                         case 7: 
03491                           
03492                             switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03493                               case 0: case 2: case 3: case 4: 
03494                                 MATCH_name = 
03495                                   MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03496                                       /* reg2 at 0 */]; 
03497                                 goto MATCH_label_a18; 
03498                                 
03499                                 break;
03500                               case 1: 
03501                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
03502                                 MATCH_w_16_32 = getWord(4 + MATCH_p); 
03503                                 MATCH_name = 
03504                                   MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03505                                       /* reg2 at 0 */]; 
03506                                 goto MATCH_label_a19; 
03507                                 
03508                                 break;
03509                               case 5: case 6: case 7: 
03510                                 goto MATCH_label_a1; break;
03511                               default: assert(0);
03512                             } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03513                           break;
03514                         default: assert(0);
03515                       } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03516                     break;
03517                   case 7: 
03518                     goto MATCH_label_a1; break;
03519                   default: assert(0);
03520                 } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/   
03521           else 
03522             
03523               switch((MATCH_w_16_0 >> 6 & 0x7) /* MDadrm at 0 */) {
03524                 case 0: case 1: case 2: case 3: case 4: 
03525                   
03526                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03527                       case 0: case 1: case 2: case 3: case 4: 
03528                         MATCH_name = 
03529                           MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03530                               /* adrm at 0 */]; 
03531                         goto MATCH_label_a14; 
03532                         
03533                         break;
03534                       case 5: case 6: 
03535                         MATCH_name = 
03536                           MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
03537                               /* adrm at 0 */]; 
03538                         goto MATCH_label_a15; 
03539                         
03540                         break;
03541                       case 7: 
03542                         
03543                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03544                             case 0: case 2: case 3: case 4: 
03545                               MATCH_name = 
03546                                 MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03547                                     /* reg2 at 0 */]; 
03548                               goto MATCH_label_a15; 
03549                               
03550                               break;
03551                             case 1: 
03552                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03553                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03554                               MATCH_name = 
03555                                 MATCH_name_reg2_50[(MATCH_w_16_0 & 0x7) 
03556                                     /* reg2 at 0 */]; 
03557                               goto MATCH_label_a16; 
03558                               
03559                               break;
03560                             case 5: case 6: case 7: 
03561                               goto MATCH_label_a1; break;
03562                             default: assert(0);
03563                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03564                         break;
03565                       default: assert(0);
03566                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03567                   break;
03568                 case 5: case 6: 
03569                   
03570                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03571                       case 0: case 1: case 2: case 3: case 4: 
03572                         MATCH_name = 
03573                           MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03574                               /* adrm at 0 */]; 
03575                         goto MATCH_label_a17; 
03576                         
03577                         break;
03578                       case 5: case 6: 
03579                         MATCH_name = 
03580                           MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
03581                               /* adrm at 0 */]; 
03582                         goto MATCH_label_a18; 
03583                         
03584                         break;
03585                       case 7: 
03586                         
03587                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03588                             case 0: case 2: case 3: case 4: 
03589                               MATCH_name = 
03590                                 MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03591                                     /* reg2 at 0 */]; 
03592                               goto MATCH_label_a18; 
03593                               
03594                               break;
03595                             case 1: 
03596                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
03597                               MATCH_w_16_32 = getWord(4 + MATCH_p); 
03598                               MATCH_name = 
03599                                 MATCH_name_reg2_52[(MATCH_w_16_0 & 0x7) 
03600                                     /* reg2 at 0 */]; 
03601                               goto MATCH_label_a19; 
03602                               
03603                               break;
03604                             case 5: case 6: case 7: 
03605                               goto MATCH_label_a1; break;
03606                             default: assert(0);
03607                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03608                         break;
03609                       default: assert(0);
03610                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03611                   break;
03612                 case 7: 
03613                   goto MATCH_label_a1; break;
03614                 default: assert(0);
03615               } /* (MATCH_w_16_0 >> 6 & 0x7) -- MDadrm at 0 --*/  
03616           break;
03617         case 4: 
03618           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
03619             
03620               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
03621                 case 0: case 1: 
03622                   goto MATCH_label_a1; break;
03623                 case 2: 
03624                   
03625                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03626                       case 0: case 2: 
03627                         MATCH_name = 
03628                           MATCH_name_adrm_82[(MATCH_w_16_0 >> 3 & 0x7) 
03629                               /* adrm at 0 */]; 
03630                         goto MATCH_label_a41; 
03631                         
03632                         break;
03633                       case 1: 
03634                         goto MATCH_label_a1; break;
03635                       case 3: 
03636                         MATCH_name = 
03637                           MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
03638                               /* adrm at 0 */]; 
03639                         goto MATCH_label_a41; 
03640                         
03641                         break;
03642                       case 4: 
03643                         MATCH_name = 
03644                           MATCH_name_adrm_78[(MATCH_w_16_0 >> 3 & 0x7) 
03645                               /* adrm at 0 */]; 
03646                         goto MATCH_label_a41; 
03647                         
03648                         break;
03649                       case 5: case 6: 
03650                         MATCH_name = 
03651                           MATCH_name_adrm_82[(MATCH_w_16_0 >> 3 & 0x7) 
03652                               /* adrm at 0 */]; 
03653                         goto MATCH_label_a42; 
03654                         
03655                         break;
03656                       case 7: 
03657                         
03658                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03659                             case 0: case 1: 
03660                               MATCH_name = 
03661                                 MATCH_name_reg2_83[(MATCH_w_16_0 & 0x7) 
03662                                     /* reg2 at 0 */]; 
03663                               goto MATCH_label_a42; 
03664                               
03665                               break;
03666                             case 2: 
03667                               MATCH_name = 
03668                                 MATCH_name_reg2_65[(MATCH_w_16_0 & 0x7) 
03669                                     /* reg2 at 0 */]; 
03670                               goto MATCH_label_a42; 
03671                               
03672                               break;
03673                             case 3: 
03674                               MATCH_name = 
03675                                 MATCH_name_reg2_67[(MATCH_w_16_0 & 0x7) 
03676                                     /* reg2 at 0 */]; 
03677                               goto MATCH_label_a42; 
03678                               
03679                               break;
03680                             case 4: 
03681                               MATCH_name = 
03682                                 MATCH_name_reg2_63[(MATCH_w_16_0 & 0x7) 
03683                                     /* reg2 at 0 */]; 
03684                               goto MATCH_label_a42; 
03685                               
03686                               break;
03687                             case 5: case 6: case 7: 
03688                               goto MATCH_label_a1; break;
03689                             default: assert(0);
03690                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03691                         break;
03692                       default: assert(0);
03693                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03694                   break;
03695                 case 3: 
03696                   
03697                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03698                       case 0: case 1: case 3: case 4: 
03699                         goto MATCH_label_a1; break;
03700                       case 2: 
03701                         { 
03702                           unsigned ea = addressToPC(MATCH_p);
03703                           unsigned n = 
03704                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
03705                           
03706                           #line 619 "machine/mc68k/decoder_low.m"
03707                            { 
03708 
03709                                   // lea    
03710 
03711                                       RTs = instantiate (pc, "lea", cEA (ea, pc, 32), DIS_AN); 
03712 
03713                                   }  
03714 
03715                           
03716 
03717                           
03718                           
03719                           
03720                         }
03721                         
03722                         break;
03723                       case 5: case 6: 
03724                         goto MATCH_label_a43; break;
03725                       case 7: 
03726                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
03727                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 4) 
03728                           goto MATCH_label_a43;  /*opt-block+*/
03729                         else 
03730                           goto MATCH_label_a1;  /*opt-block+*/
03731                         
03732                         break;
03733                       default: assert(0);
03734                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03735                   break;
03736                 default: assert(0);
03737               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
03738           else 
03739             
03740               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
03741                 case 0: 
03742                   
03743                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03744                       case 0: case 2: case 3: case 4: 
03745                         if (0 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
03746                           (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 6) { 
03747                           MATCH_name = 
03748                             MATCH_name_reg1_56[(MATCH_w_16_0 >> 9 & 0x7) 
03749                                 /* reg1 at 0 */]; 
03750                           goto MATCH_label_a20; 
03751                           
03752                         } /*opt-block*/
03753                         else 
03754                           goto MATCH_label_a1;  /*opt-block+*/
03755                         
03756                         break;
03757                       case 1: 
03758                         goto MATCH_label_a1; break;
03759                       case 5: case 6: 
03760                         if (0 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
03761                           (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 6) { 
03762                           MATCH_name = 
03763                             MATCH_name_reg1_57[(MATCH_w_16_0 >> 9 & 0x7) 
03764                                 /* reg1 at 0 */]; 
03765                           goto MATCH_label_a21; 
03766                           
03767                         } /*opt-block*/
03768                         else 
03769                           goto MATCH_label_a1;  /*opt-block+*/
03770                         
03771                         break;
03772                       case 7: 
03773                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
03774                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2 && 
03775                           (6 <= (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ && 
03776                           (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */ < 8) || 
03777                           2 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
03778                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 8) 
03779                           goto MATCH_label_a1;  /*opt-block+*/
03780                         else { 
03781                           MATCH_name = 
03782                             MATCH_name_reg1_57[(MATCH_w_16_0 >> 9 & 0x7) 
03783                                 /* reg1 at 0 */]; 
03784                           goto MATCH_label_a21; 
03785                           
03786                         } /*opt-block*/
03787                         
03788                         break;
03789                       default: assert(0);
03790                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03791                   break;
03792                 case 1: 
03793                   
03794                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
03795                       case 0: 
03796                         
03797                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03798                             case 0: case 2: case 3: case 4: 
03799                               MATCH_name = 
03800                                 MATCH_name_adrm_58[(MATCH_w_16_0 >> 3 & 0x7) 
03801                                     /* adrm at 0 */]; 
03802                               goto MATCH_label_a22; 
03803                               
03804                               break;
03805                             case 1: 
03806                               goto MATCH_label_a1; break;
03807                             case 5: case 6: 
03808                               MATCH_name = 
03809                                 MATCH_name_adrm_58[(MATCH_w_16_0 >> 3 & 0x7) 
03810                                     /* adrm at 0 */]; 
03811                               goto MATCH_label_a23; 
03812                               
03813                               break;
03814                             case 7: 
03815                               if (0 <= (MATCH_w_16_0 & 0x7) 
03816                                       /* reg2 at 0 */ && 
03817                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
03818                                 MATCH_name = 
03819                                   MATCH_name_reg2_59[(MATCH_w_16_0 & 0x7) 
03820                                       /* reg2 at 0 */]; 
03821                                 goto MATCH_label_a23; 
03822                                 
03823                               } /*opt-block*/
03824                               else 
03825                                 goto MATCH_label_a1;  /*opt-block+*/
03826                               
03827                               break;
03828                             default: assert(0);
03829                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03830                         break;
03831                       case 1: 
03832                         
03833                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03834                             case 0: case 2: case 3: case 4: 
03835                               MATCH_name = 
03836                                 MATCH_name_adrm_60[(MATCH_w_16_0 >> 3 & 0x7) 
03837                                     /* adrm at 0 */]; 
03838                               goto MATCH_label_a22; 
03839                               
03840                               break;
03841                             case 1: 
03842                               goto MATCH_label_a1; break;
03843                             case 5: case 6: 
03844                               MATCH_name = 
03845                                 MATCH_name_adrm_60[(MATCH_w_16_0 >> 3 & 0x7) 
03846                                     /* adrm at 0 */]; 
03847                               goto MATCH_label_a23; 
03848                               
03849                               break;
03850                             case 7: 
03851                               if (0 <= (MATCH_w_16_0 & 0x7) 
03852                                       /* reg2 at 0 */ && 
03853                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
03854                                 MATCH_name = 
03855                                   MATCH_name_reg2_61[(MATCH_w_16_0 & 0x7) 
03856                                       /* reg2 at 0 */]; 
03857                                 goto MATCH_label_a23; 
03858                                 
03859                               } /*opt-block*/
03860                               else 
03861                                 goto MATCH_label_a1;  /*opt-block+*/
03862                               
03863                               break;
03864                             default: assert(0);
03865                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03866                         break;
03867                       case 2: 
03868                         
03869                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03870                             case 0: case 2: case 3: case 4: 
03871                               MATCH_name = 
03872                                 MATCH_name_adrm_62[(MATCH_w_16_0 >> 3 & 0x7) 
03873                                     /* adrm at 0 */]; 
03874                               goto MATCH_label_a22; 
03875                               
03876                               break;
03877                             case 1: 
03878                               goto MATCH_label_a1; break;
03879                             case 5: case 6: 
03880                               MATCH_name = 
03881                                 MATCH_name_adrm_62[(MATCH_w_16_0 >> 3 & 0x7) 
03882                                     /* adrm at 0 */]; 
03883                               goto MATCH_label_a23; 
03884                               
03885                               break;
03886                             case 7: 
03887                               if (0 <= (MATCH_w_16_0 & 0x7) 
03888                                       /* reg2 at 0 */ && 
03889                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
03890                                 MATCH_name = 
03891                                   MATCH_name_reg2_63[(MATCH_w_16_0 & 0x7) 
03892                                       /* reg2 at 0 */]; 
03893                                 goto MATCH_label_a23; 
03894                                 
03895                               } /*opt-block*/
03896                               else 
03897                                 goto MATCH_label_a1;  /*opt-block+*/
03898                               
03899                               break;
03900                             default: assert(0);
03901                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03902                         break;
03903                       case 3: 
03904                         
03905                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03906                             case 0: case 2: case 3: case 4: 
03907                               MATCH_name = 
03908                                 MATCH_name_adrm_64[(MATCH_w_16_0 >> 3 & 0x7) 
03909                                     /* adrm at 0 */]; 
03910                               goto MATCH_label_a22; 
03911                               
03912                               break;
03913                             case 1: 
03914                               goto MATCH_label_a1; break;
03915                             case 5: case 6: 
03916                               MATCH_name = 
03917                                 MATCH_name_adrm_64[(MATCH_w_16_0 >> 3 & 0x7) 
03918                                     /* adrm at 0 */]; 
03919                               goto MATCH_label_a23; 
03920                               
03921                               break;
03922                             case 7: 
03923                               if (0 <= (MATCH_w_16_0 & 0x7) 
03924                                       /* reg2 at 0 */ && 
03925                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
03926                                 MATCH_name = 
03927                                   MATCH_name_reg2_65[(MATCH_w_16_0 & 0x7) 
03928                                       /* reg2 at 0 */]; 
03929                                 goto MATCH_label_a23; 
03930                                 
03931                               } /*opt-block*/
03932                               else 
03933                                 goto MATCH_label_a1;  /*opt-block+*/
03934                               
03935                               break;
03936                             default: assert(0);
03937                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03938                         break;
03939                       case 4: 
03940                         
03941                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03942                             case 0: 
03943                               MATCH_name = 
03944                                 MATCH_name_adrm_66[(MATCH_w_16_0 >> 3 & 0x7) 
03945                                     /* adrm at 0 */]; 
03946                               goto MATCH_label_a24; 
03947                               
03948                               break;
03949                             case 1: case 3: case 4: 
03950                               goto MATCH_label_a1; break;
03951                             case 2: 
03952                               MATCH_name = 
03953                                 MATCH_name_adrm_66[(MATCH_w_16_0 >> 3 & 0x7) 
03954                                     /* adrm at 0 */]; 
03955                               goto MATCH_label_a25; 
03956                               
03957                               break;
03958                             case 5: case 6: 
03959                               MATCH_name = 
03960                                 MATCH_name_adrm_66[(MATCH_w_16_0 >> 3 & 0x7) 
03961                                     /* adrm at 0 */]; 
03962                               goto MATCH_label_a26; 
03963                               
03964                               break;
03965                             case 7: 
03966                               
03967                                 switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
03968                                   case 0: case 1: 
03969                                     MATCH_name = 
03970                                       MATCH_name_reg2_67[(MATCH_w_16_0 & 0x7) 
03971                                           /* reg2 at 0 */]; 
03972                                     goto MATCH_label_a26; 
03973                                     
03974                                     break;
03975                                   case 2: case 3: 
03976                                     MATCH_name = 
03977                                       MATCH_name_reg2_59[(MATCH_w_16_0 & 0x7) 
03978                                           /* reg2 at 0 */]; 
03979                                     goto MATCH_label_a26; 
03980                                     
03981                                     break;
03982                                   case 4: case 5: case 6: case 7: 
03983                                     goto MATCH_label_a1; break;
03984                                   default: assert(0);
03985                                 } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
03986                               break;
03987                             default: assert(0);
03988                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
03989                         break;
03990                       case 5: 
03991                         
03992                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
03993                             case 0: case 2: 
03994                               MATCH_name = 
03995                                 MATCH_name_adrm_68[(MATCH_w_16_0 >> 3 & 0x7) 
03996                                     /* adrm at 0 */]; 
03997                               goto MATCH_label_a22; 
03998                               
03999                               break;
04000                             case 1: 
04001                               goto MATCH_label_a1; break;
04002                             case 3: case 4: 
04003                               MATCH_name = 
04004                                 MATCH_name_adrm_66[(MATCH_w_16_0 >> 3 & 0x7) 
04005                                     /* adrm at 0 */]; 
04006                               goto MATCH_label_a22; 
04007                               
04008                               break;
04009                             case 5: case 6: 
04010                               MATCH_name = 
04011                                 MATCH_name_adrm_68[(MATCH_w_16_0 >> 3 & 0x7) 
04012                                     /* adrm at 0 */]; 
04013                               goto MATCH_label_a23; 
04014                               
04015                               break;
04016                             case 7: 
04017                               if (0 <= (MATCH_w_16_0 & 0x7) 
04018                                       /* reg2 at 0 */ && 
04019                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04020                                 MATCH_name = 
04021                                   MATCH_name_reg2_69[(MATCH_w_16_0 & 0x7) 
04022                                       /* reg2 at 0 */]; 
04023                                 goto MATCH_label_a23; 
04024                                 
04025                               } /*opt-block*/
04026                               else 
04027                                 goto MATCH_label_a1;  /*opt-block+*/
04028                               
04029                               break;
04030                             default: assert(0);
04031                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04032                         break;
04033                       case 6: 
04034                         goto MATCH_label_a1; break;
04035                       case 7: 
04036                         
04037                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04038                             case 0: case 1: case 4: case 5: case 7: 
04039                               if ((MATCH_w_16_0 >> 4 & 0x3) 
04040                                       /* adrb at 0 */ == 0) 
04041                                 goto MATCH_label_a27;  /*opt-block+*/
04042                               else 
04043                                 goto MATCH_label_a1;  /*opt-block+*/
04044                               
04045                               break;
04046                             case 2: 
04047                               if ((MATCH_w_16_0 >> 4 & 0x3) 
04048                                       /* adrb at 0 */ == 0) 
04049                                 goto MATCH_label_a27;  /*opt-block+*/
04050                               else { 
04051                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
04052                                 MATCH_name = "link"; 
04053                                 { 
04054                                   char *name = MATCH_name;
04055                                   int /* [~32768..32767] */ i16 = 
04056                                     sign_extend(
04057                                                 (MATCH_w_16_16 & 0xffff) 
04058                                                       /* d16 at 16 */, 16);
04059                                   unsigned n = 
04060                                     (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
04061                                   
04062                                   #line 549 "machine/mc68k/decoder_low.m"
04063                                    { 
04064 
04065                                           // link
04066 
04067                                               RTs = instantiate (pc, name, DIS_AN, DIS_I16); 
04068 
04069                                               result.numBytes += 2; 
04070 
04071                                           // moveFromUSP, moveToUSP privileged
04072 
04073                                                       }
04074 
04075                                       
04076 
04077                                   
04078                                   
04079                                   
04080                                 }
04081                                 
04082                               } /*opt-block*/
04083                               
04084                               break;
04085                             case 3: 
04086                               MATCH_name = 
04087                                 MATCH_name_adrm_68[(MATCH_w_16_0 >> 3 & 0x7) 
04088                                     /* adrm at 0 */]; 
04089                               { 
04090                                 char *name = MATCH_name;
04091                                 unsigned n = 
04092                                   (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
04093                                 
04094                                 #line 499 "machine/mc68k/decoder_low.m"
04095                                  { 
04096 
04097                                         // unlk
04098 
04099                                             RTs = instantiate (pc, name, DIS_AN); 
04100 
04101                                         }
04102 
04103                                     
04104 
04105                                 
04106                                 
04107                                 
04108                               }
04109                               
04110                               break;
04111                             case 6: 
04112                               
04113                                 switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
04114                                   case 0: case 1: 
04115                                     MATCH_name = 
04116                                       MATCH_name_reg2_71[(MATCH_w_16_0 & 0x7) 
04117                                           /* reg2 at 0 */]; 
04118                                     goto MATCH_label_a28; 
04119                                     
04120                                     break;
04121                                   case 2: case 4: 
04122                                     if ((MATCH_w_16_0 >> 4 & 0x3) 
04123                                             /* adrb at 0 */ == 0) 
04124                                       goto MATCH_label_a27;  /*opt-block+*/
04125                                     else 
04126                                       goto MATCH_label_a1;  /*opt-block+*/
04127                                     
04128                                     break;
04129                                   case 3: 
04130                                     MATCH_name = 
04131                                       MATCH_name_reg2_61[(MATCH_w_16_0 & 0x7) 
04132                                           /* reg2 at 0 */]; 
04133                                     goto MATCH_label_a28; 
04134                                     
04135                                     break;
04136                                   case 5: case 6: case 7: 
04137                                     MATCH_name = 
04138                                       MATCH_name_reg2_36[(MATCH_w_16_0 & 0x7) 
04139                                           /* reg2 at 0 */]; 
04140                                     goto MATCH_label_a28; 
04141                                     
04142                                     break;
04143                                   default: assert(0);
04144                                 } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
04145                               break;
04146                             default: assert(0);
04147                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04148                         break;
04149                       default: assert(0);
04150                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04151                   break;
04152                 case 2: 
04153                   
04154                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04155                       case 0: 
04156                         
04157                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04158                             case 0: case 1: case 2: case 3: case 5: 
04159                               MATCH_name = 
04160                                 MATCH_name_reg1_72[(MATCH_w_16_0 >> 9 & 0x7) 
04161                                     /* reg1 at 0 */]; 
04162                               goto MATCH_label_a29; 
04163                               
04164                               break;
04165                             case 4: 
04166                               MATCH_name = 
04167                                 MATCH_name_reg1_72[(MATCH_w_16_0 >> 9 & 0x7) 
04168                                     /* reg1 at 0 */]; 
04169                               goto MATCH_label_a24; 
04170                               
04171                               break;
04172                             case 6: case 7: 
04173                               goto MATCH_label_a1; break;
04174                             default: assert(0);
04175                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04176                         break;
04177                       case 1: 
04178                         goto MATCH_label_a1; break;
04179                       case 2: 
04180                         
04181                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04182                             case 0: case 1: case 2: case 3: case 5: 
04183                               MATCH_name = 
04184                                 MATCH_name_reg1_72[(MATCH_w_16_0 >> 9 & 0x7) 
04185                                     /* reg1 at 0 */]; 
04186                               goto MATCH_label_a29; 
04187                               
04188                               break;
04189                             case 4: 
04190                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04191                               goto MATCH_label_a30; 
04192                               
04193                               break;
04194                             case 6: 
04195                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04196                               goto MATCH_label_a31; 
04197                               
04198                               break;
04199                             case 7: 
04200                               MATCH_name = 
04201                                 MATCH_name_reg1_56[(MATCH_w_16_0 >> 9 & 0x7) 
04202                                     /* reg1 at 0 */]; 
04203                               goto MATCH_label_a25; 
04204                               
04205                               break;
04206                             default: assert(0);
04207                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04208                         break;
04209                       case 3: 
04210                         
04211                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04212                             case 0: case 1: case 2: case 3: case 5: 
04213                               MATCH_name = 
04214                                 MATCH_name_reg1_72[(MATCH_w_16_0 >> 9 & 0x7) 
04215                                     /* reg1 at 0 */]; 
04216                               goto MATCH_label_a29; 
04217                               
04218                               break;
04219                             case 4: case 7: 
04220                               goto MATCH_label_a1; break;
04221                             case 6: 
04222                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04223                               goto MATCH_label_a31; 
04224                               
04225                               break;
04226                             default: assert(0);
04227                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04228                         break;
04229                       case 4: 
04230                         
04231                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04232                             case 0: case 1: case 2: case 3: case 5: 
04233                               MATCH_name = 
04234                                 MATCH_name_reg1_72[(MATCH_w_16_0 >> 9 & 0x7) 
04235                                     /* reg1 at 0 */]; 
04236                               goto MATCH_label_a29; 
04237                               
04238                               break;
04239                             case 4: 
04240                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04241                               goto MATCH_label_a30; 
04242                               
04243                               break;
04244                             case 6: case 7: 
04245                               goto MATCH_label_a1; break;
04246                             default: assert(0);
04247                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04248                         break;
04249                       case 5: case 6: 
04250                         
04251                           switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04252                             case 0: case 1: case 2: case 3: case 5: 
04253                               MATCH_name = 
04254                                 MATCH_name_reg1_73[(MATCH_w_16_0 >> 9 & 0x7) 
04255                                     /* reg1 at 0 */]; 
04256                               goto MATCH_label_a32; 
04257                               
04258                               break;
04259                             case 4: 
04260                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04261                               goto MATCH_label_a33; 
04262                               
04263                               break;
04264                             case 6: 
04265                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04266                               goto MATCH_label_a34; 
04267                               
04268                               break;
04269                             case 7: 
04270                               MATCH_name = 
04271                                 MATCH_name_reg1_57[(MATCH_w_16_0 >> 9 & 0x7) 
04272                                     /* reg1 at 0 */]; 
04273                               goto MATCH_label_a26; 
04274                               
04275                               break;
04276                             default: assert(0);
04277                           } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04278                         break;
04279                       case 7: 
04280                         
04281                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
04282                             case 0: case 1: 
04283                               
04284                                 switch((MATCH_w_16_0 >> 9 & 0x7) 
04285                                       /* reg1 at 0 */) {
04286                                   case 0: case 1: case 2: case 3: case 5: 
04287                                     MATCH_name = 
04288                                       MATCH_name_reg1_73[(MATCH_w_16_0 >> 9 & 0x7) 
04289                                           /* reg1 at 0 */]; 
04290                                     goto MATCH_label_a32; 
04291                                     
04292                                     break;
04293                                   case 4: 
04294                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
04295                                     goto MATCH_label_a33; 
04296                                     
04297                                     break;
04298                                   case 6: 
04299                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
04300                                     goto MATCH_label_a34; 
04301                                     
04302                                     break;
04303                                   case 7: 
04304                                     MATCH_name = 
04305                                       MATCH_name_reg1_57[(MATCH_w_16_0 >> 9 & 0x7) 
04306                                           /* reg1 at 0 */]; 
04307                                     goto MATCH_label_a26; 
04308                                     
04309                                     break;
04310                                   default: assert(0);
04311                                 } /* (MATCH_w_16_0 >> 9 & 0x7) 
04312                                       -- reg1 at 0 --*/ 
04313                               break;
04314                             case 2: case 3: 
04315                               
04316                                 switch((MATCH_w_16_0 >> 9 & 0x7) 
04317                                       /* reg1 at 0 */) {
04318                                   case 0: case 1: case 2: case 3: case 4: 
04319                                   case 5: 
04320                                     goto MATCH_label_a1; break;
04321                                   case 6: 
04322                                     MATCH_w_16_16 = getWord(2 + MATCH_p); 
04323                                     goto MATCH_label_a34; 
04324                                     
04325                                     break;
04326                                   case 7: 
04327                                     MATCH_name = 
04328                                       MATCH_name_reg1_57[(MATCH_w_16_0 >> 9 & 0x7) 
04329                                           /* reg1 at 0 */]; 
04330                                     goto MATCH_label_a26; 
04331                                     
04332                                     break;
04333                                   default: assert(0);
04334                                 } /* (MATCH_w_16_0 >> 9 & 0x7) 
04335                                       -- reg1 at 0 --*/ 
04336                               break;
04337                             case 4: case 5: case 6: case 7: 
04338                               goto MATCH_label_a1; break;
04339                             default: assert(0);
04340                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
04341                         break;
04342                       default: assert(0);
04343                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04344                   break;
04345                 case 3: 
04346                   
04347                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
04348                       case 0: case 3: 
04349                         goto MATCH_label_a1; break;
04350                       case 1: 
04351                         
04352                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04353                             case 0: case 2: case 3: 
04354                               MATCH_name = 
04355                                 MATCH_name_adrm_74[(MATCH_w_16_0 >> 3 & 0x7) 
04356                                     /* adrm at 0 */]; 
04357                               goto MATCH_label_a35; 
04358                               
04359                               break;
04360                             case 1: 
04361                               goto MATCH_label_a1; break;
04362                             case 4: 
04363                               MATCH_name = 
04364                                 MATCH_name_adrm_68[(MATCH_w_16_0 >> 3 & 0x7) 
04365                                     /* adrm at 0 */]; 
04366                               goto MATCH_label_a35; 
04367                               
04368                               break;
04369                             case 5: case 6: 
04370                               MATCH_name = 
04371                                 MATCH_name_adrm_74[(MATCH_w_16_0 >> 3 & 0x7) 
04372                                     /* adrm at 0 */]; 
04373                               goto MATCH_label_a36; 
04374                               
04375                               break;
04376                             case 7: 
04377                               if (0 <= (MATCH_w_16_0 & 0x7) 
04378                                       /* reg2 at 0 */ && 
04379                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04380                                 MATCH_name = 
04381                                   MATCH_name_reg2_75[(MATCH_w_16_0 & 0x7) 
04382                                       /* reg2 at 0 */]; 
04383                                 goto MATCH_label_a36; 
04384                                 
04385                               } /*opt-block*/
04386                               else 
04387                                 goto MATCH_label_a1;  /*opt-block+*/
04388                               
04389                               break;
04390                             default: assert(0);
04391                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04392                         break;
04393                       case 2: 
04394                         
04395                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04396                             case 0: case 2: case 3: 
04397                               MATCH_name = 
04398                                 MATCH_name_adrm_76[(MATCH_w_16_0 >> 3 & 0x7) 
04399                                     /* adrm at 0 */]; 
04400                               goto MATCH_label_a37; 
04401                               
04402                               break;
04403                             case 1: 
04404                               goto MATCH_label_a1; break;
04405                             case 4: 
04406                               MATCH_name = 
04407                                 MATCH_name_adrm_74[(MATCH_w_16_0 >> 3 & 0x7) 
04408                                     /* adrm at 0 */]; 
04409                               goto MATCH_label_a37; 
04410                               
04411                               break;
04412                             case 5: case 6: 
04413                               MATCH_name = 
04414                                 MATCH_name_adrm_76[(MATCH_w_16_0 >> 3 & 0x7) 
04415                                     /* adrm at 0 */]; 
04416                               goto MATCH_label_a38; 
04417                               
04418                               break;
04419                             case 7: 
04420                               
04421                                 switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
04422                                   case 0: case 1: 
04423                                     MATCH_name = 
04424                                       MATCH_name_reg2_77[(MATCH_w_16_0 & 0x7) 
04425                                           /* reg2 at 0 */]; 
04426                                     goto MATCH_label_a38; 
04427                                     
04428                                     break;
04429                                   case 2: 
04430                                     MATCH_name = 
04431                                       MATCH_name_reg2_61[(MATCH_w_16_0 & 0x7) 
04432                                           /* reg2 at 0 */]; 
04433                                     goto MATCH_label_a38; 
04434                                     
04435                                     break;
04436                                   case 3: 
04437                                     MATCH_name = 
04438                                       MATCH_name_reg2_63[(MATCH_w_16_0 & 0x7) 
04439                                           /* reg2 at 0 */]; 
04440                                     goto MATCH_label_a38; 
04441                                     
04442                                     break;
04443                                   case 4: 
04444                                     MATCH_name = 
04445                                       MATCH_name_reg2_59[(MATCH_w_16_0 & 0x7) 
04446                                           /* reg2 at 0 */]; 
04447                                     goto MATCH_label_a38; 
04448                                     
04449                                     break;
04450                                   case 5: case 6: case 7: 
04451                                     goto MATCH_label_a1; break;
04452                                   default: assert(0);
04453                                 } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
04454                               break;
04455                             default: assert(0);
04456                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04457                         break;
04458                       case 4: 
04459                         
04460                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04461                             case 0: 
04462                               MATCH_name = 
04463                                 MATCH_name_adrm_78[(MATCH_w_16_0 >> 3 & 0x7) 
04464                                     /* adrm at 0 */]; 
04465                               goto MATCH_label_a24; 
04466                               
04467                               break;
04468                             case 1: case 3: 
04469                               goto MATCH_label_a1; break;
04470                             case 2: case 4: 
04471                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04472                               { 
04473                                 unsigned ea = addressToPC(MATCH_p);
04474                                 unsigned i16 = 
04475                                   (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
04476                                 
04477                                 #line 589 "machine/mc68k/decoder_low.m"
04478                                  { 
04479 
04480                                             // HACK! Needs work
04481 
04482                                             int bump = 0, bumpr;
04483 
04484                                             RTs = instantiate (pc, "storem.l", DIS_I16,
04485 
04486                                                 rmEA (ea, pc, bump, bumpr, 32));
04487 
04488                                             result.numBytes += 2; 
04489 
04490                                             ADDBUMP;
04491 
04492                                         } 
04493 
04494                                 
04495 
04496                                 
04497                                 
04498                                 
04499                               }
04500                               
04501                               break;
04502                             case 5: case 6: 
04503                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04504                               goto MATCH_label_a39; 
04505                               
04506                               break;
04507                             case 7: 
04508                               if (0 <= (MATCH_w_16_0 & 0x7) 
04509                                       /* reg2 at 0 */ && 
04510                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04511                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
04512                                 goto MATCH_label_a39; 
04513                                 
04514                               } /*opt-block*/
04515                               else 
04516                                 goto MATCH_label_a1;  /*opt-block+*/
04517                               
04518                               break;
04519                             default: assert(0);
04520                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04521                         break;
04522                       case 5: 
04523                         
04524                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04525                             case 0: 
04526                               MATCH_name = 
04527                                 MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
04528                                     /* adrm at 0 */]; 
04529                               goto MATCH_label_a20; 
04530                               
04531                               break;
04532                             case 1: 
04533                               goto MATCH_label_a1; break;
04534                             case 2: case 3: 
04535                               MATCH_name = 
04536                                 MATCH_name_adrm_78[(MATCH_w_16_0 >> 3 & 0x7) 
04537                                     /* adrm at 0 */]; 
04538                               goto MATCH_label_a20; 
04539                               
04540                               break;
04541                             case 4: 
04542                               MATCH_name = 
04543                                 MATCH_name_adrm_76[(MATCH_w_16_0 >> 3 & 0x7) 
04544                                     /* adrm at 0 */]; 
04545                               goto MATCH_label_a20; 
04546                               
04547                               break;
04548                             case 5: case 6: 
04549                               MATCH_name = 
04550                                 MATCH_name_adrm_78[(MATCH_w_16_0 >> 3 & 0x7) 
04551                                     /* adrm at 0 */]; 
04552                               goto MATCH_label_a21; 
04553                               
04554                               break;
04555                             case 7: 
04556                               
04557                                 switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
04558                                   case 0: case 1: 
04559                                     MATCH_name = 
04560                                       MATCH_name_reg2_80[(MATCH_w_16_0 & 0x7) 
04561                                           /* reg2 at 0 */]; 
04562                                     goto MATCH_label_a21; 
04563                                     
04564                                     break;
04565                                   case 2: case 3: case 5: case 6: case 7: 
04566                                     goto MATCH_label_a1; break;
04567                                   case 4: 
04568                                     MATCH_name = 
04569                                       MATCH_name_reg2_61[(MATCH_w_16_0 & 0x7) 
04570                                           /* reg2 at 0 */]; 
04571                                     goto MATCH_label_a28; 
04572                                     
04573                                     break;
04574                                   default: assert(0);
04575                                 } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
04576                               break;
04577                             default: assert(0);
04578                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04579                         break;
04580                       case 6: 
04581                         
04582                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04583                             case 0: case 1: case 4: 
04584                               goto MATCH_label_a1; break;
04585                             case 2: case 3: 
04586                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04587                               { 
04588                                 unsigned ea = addressToPC(MATCH_p);
04589                                 unsigned i16 = 
04590                                   (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
04591                                 
04592                                 #line 604 "machine/mc68k/decoder_low.m"
04593                                  {
04594 
04595                                         // HACK! Requires work
04596 
04597                                             int bump = 0, bumpr;
04598 
04599                                             RTs = instantiate (pc, "loadm.l", DIS_I16,
04600 
04601                                                 mrEA (ea, pc, bump, bumpr, 32));
04602 
04603                                             result.numBytes += 2; 
04604 
04605                                             ADDBUMP;
04606 
04607                                         } 
04608 
04609                                 
04610 
04611                                 
04612                                 
04613                                 
04614                               }
04615                               
04616                               break;
04617                             case 5: case 6: 
04618                               MATCH_w_16_16 = getWord(2 + MATCH_p); 
04619                               goto MATCH_label_a40; 
04620                               
04621                               break;
04622                             case 7: 
04623                               if (0 <= (MATCH_w_16_0 & 0x7) 
04624                                       /* reg2 at 0 */ && 
04625                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 4) { 
04626                                 MATCH_w_16_16 = getWord(2 + MATCH_p); 
04627                                 goto MATCH_label_a40; 
04628                                 
04629                               } /*opt-block*/
04630                               else 
04631                                 goto MATCH_label_a1;  /*opt-block+*/
04632                               
04633                               break;
04634                             default: assert(0);
04635                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04636                         break;
04637                       case 7: 
04638                         
04639                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04640                             case 0: case 1: case 3: case 4: 
04641                               goto MATCH_label_a1; break;
04642                             case 2: 
04643                               MATCH_name = 
04644                                 MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
04645                                     /* adrm at 0 */]; 
04646                               goto MATCH_label_a25; 
04647                               
04648                               break;
04649                             case 5: case 6: 
04650                               MATCH_name = 
04651                                 MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
04652                                     /* adrm at 0 */]; 
04653                               goto MATCH_label_a26; 
04654                               
04655                               break;
04656                             case 7: 
04657                               
04658                                 switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
04659                                   case 0: case 1: 
04660                                     MATCH_name = 
04661                                       MATCH_name_reg2_81[(MATCH_w_16_0 & 0x7) 
04662                                           /* reg2 at 0 */]; 
04663                                     goto MATCH_label_a26; 
04664                                     
04665                                     break;
04666                                   case 2: 
04667                                     MATCH_name = 
04668                                       MATCH_name_reg2_63[(MATCH_w_16_0 & 0x7) 
04669                                           /* reg2 at 0 */]; 
04670                                     goto MATCH_label_a26; 
04671                                     
04672                                     break;
04673                                   case 3: 
04674                                     MATCH_name = 
04675                                       MATCH_name_reg2_65[(MATCH_w_16_0 & 0x7) 
04676                                           /* reg2 at 0 */]; 
04677                                     goto MATCH_label_a26; 
04678                                     
04679                                     break;
04680                                   case 4: case 5: case 6: case 7: 
04681                                     goto MATCH_label_a1; break;
04682                                   default: assert(0);
04683                                 } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
04684                               break;
04685                             default: assert(0);
04686                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
04687                         break;
04688                       default: assert(0);
04689                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
04690                   break;
04691                 default: assert(0);
04692               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
04693           break;
04694         case 5: 
04695           
04696             switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
04697               case 0: 
04698                 if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
04699                   
04700                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04701                       case 0: case 2: 
04702                         MATCH_name = 
04703                           MATCH_name_adrm_86[(MATCH_w_16_0 >> 3 & 0x7) 
04704                               /* adrm at 0 */]; 
04705                         goto MATCH_label_a44; 
04706                         
04707                         break;
04708                       case 1: 
04709                         MATCH_name = 
04710                           MATCH_name_adrm_60[(MATCH_w_16_0 >> 3 & 0x7) 
04711                               /* adrm at 0 */]; 
04712                         goto MATCH_label_a44; 
04713                         
04714                         break;
04715                       case 3: 
04716                         MATCH_name = 
04717                           MATCH_name_adrm_84[(MATCH_w_16_0 >> 3 & 0x7) 
04718                               /* adrm at 0 */]; 
04719                         goto MATCH_label_a44; 
04720                         
04721                         break;
04722                       case 4: 
04723                         MATCH_name = 
04724                           MATCH_name_adrm_82[(MATCH_w_16_0 >> 3 & 0x7) 
04725                               /* adrm at 0 */]; 
04726                         goto MATCH_label_a44; 
04727                         
04728                         break;
04729                       case 5: case 6: 
04730                         MATCH_name = 
04731                           MATCH_name_adrm_86[(MATCH_w_16_0 >> 3 & 0x7) 
04732                               /* adrm at 0 */]; 
04733                         goto MATCH_label_a45; 
04734                         
04735                         break;
04736                       case 7: 
04737                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
04738                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04739                           MATCH_name = 
04740                             MATCH_name_reg2_87[(MATCH_w_16_0 & 0x7) 
04741                                 /* reg2 at 0 */]; 
04742                           goto MATCH_label_a45; 
04743                           
04744                         } /*opt-block*/
04745                         else 
04746                           goto MATCH_label_a1;  /*opt-block+*/
04747                         
04748                         break;
04749                       default: assert(0);
04750                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
04751                 else 
04752                   
04753                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04754                       case 0: case 2: 
04755                         MATCH_name = 
04756                           MATCH_name_adrm_84[(MATCH_w_16_0 >> 3 & 0x7) 
04757                               /* adrm at 0 */]; 
04758                         goto MATCH_label_a44; 
04759                         
04760                         break;
04761                       case 1: 
04762                         MATCH_name = 
04763                           MATCH_name_adrm_58[(MATCH_w_16_0 >> 3 & 0x7) 
04764                               /* adrm at 0 */]; 
04765                         goto MATCH_label_a44; 
04766                         
04767                         break;
04768                       case 3: 
04769                         MATCH_name = 
04770                           MATCH_name_adrm_82[(MATCH_w_16_0 >> 3 & 0x7) 
04771                               /* adrm at 0 */]; 
04772                         goto MATCH_label_a44; 
04773                         
04774                         break;
04775                       case 4: 
04776                         MATCH_name = 
04777                           MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
04778                               /* adrm at 0 */]; 
04779                         goto MATCH_label_a44; 
04780                         
04781                         break;
04782                       case 5: case 6: 
04783                         MATCH_name = 
04784                           MATCH_name_adrm_84[(MATCH_w_16_0 >> 3 & 0x7) 
04785                               /* adrm at 0 */]; 
04786                         goto MATCH_label_a45; 
04787                         
04788                         break;
04789                       case 7: 
04790                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
04791                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04792                           MATCH_name = 
04793                             MATCH_name_reg2_85[(MATCH_w_16_0 & 0x7) 
04794                                 /* reg2 at 0 */]; 
04795                           goto MATCH_label_a45; 
04796                           
04797                         } /*opt-block*/
04798                         else 
04799                           goto MATCH_label_a1;  /*opt-block+*/
04800                         
04801                         break;
04802                       default: assert(0);
04803                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
04804                 break;
04805               case 1: 
04806                 if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
04807                   
04808                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04809                       case 0: case 2: 
04810                         MATCH_name = 
04811                           MATCH_name_adrm_90[(MATCH_w_16_0 >> 3 & 0x7) 
04812                               /* adrm at 0 */]; 
04813                         goto MATCH_label_a46; 
04814                         
04815                         break;
04816                       case 1: 
04817                         MATCH_name = 
04818                           MATCH_name_adrm_64[(MATCH_w_16_0 >> 3 & 0x7) 
04819                               /* adrm at 0 */]; 
04820                         goto MATCH_label_a46; 
04821                         
04822                         break;
04823                       case 3: 
04824                         MATCH_name = 
04825                           MATCH_name_adrm_88[(MATCH_w_16_0 >> 3 & 0x7) 
04826                               /* adrm at 0 */]; 
04827                         goto MATCH_label_a46; 
04828                         
04829                         break;
04830                       case 4: 
04831                         MATCH_name = 
04832                           MATCH_name_adrm_86[(MATCH_w_16_0 >> 3 & 0x7) 
04833                               /* adrm at 0 */]; 
04834                         goto MATCH_label_a46; 
04835                         
04836                         break;
04837                       case 5: case 6: 
04838                         MATCH_name = 
04839                           MATCH_name_adrm_90[(MATCH_w_16_0 >> 3 & 0x7) 
04840                               /* adrm at 0 */]; 
04841                         goto MATCH_label_a47; 
04842                         
04843                         break;
04844                       case 7: 
04845                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
04846                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04847                           MATCH_name = 
04848                             MATCH_name_reg2_91[(MATCH_w_16_0 & 0x7) 
04849                                 /* reg2 at 0 */]; 
04850                           goto MATCH_label_a47; 
04851                           
04852                         } /*opt-block*/
04853                         else 
04854                           goto MATCH_label_a1;  /*opt-block+*/
04855                         
04856                         break;
04857                       default: assert(0);
04858                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
04859                 else 
04860                   
04861                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04862                       case 0: case 2: 
04863                         MATCH_name = 
04864                           MATCH_name_adrm_88[(MATCH_w_16_0 >> 3 & 0x7) 
04865                               /* adrm at 0 */]; 
04866                         goto MATCH_label_a46; 
04867                         
04868                         break;
04869                       case 1: 
04870                         MATCH_name = 
04871                           MATCH_name_adrm_62[(MATCH_w_16_0 >> 3 & 0x7) 
04872                               /* adrm at 0 */]; 
04873                         goto MATCH_label_a46; 
04874                         
04875                         break;
04876                       case 3: 
04877                         MATCH_name = 
04878                           MATCH_name_adrm_86[(MATCH_w_16_0 >> 3 & 0x7) 
04879                               /* adrm at 0 */]; 
04880                         goto MATCH_label_a46; 
04881                         
04882                         break;
04883                       case 4: 
04884                         MATCH_name = 
04885                           MATCH_name_adrm_84[(MATCH_w_16_0 >> 3 & 0x7) 
04886                               /* adrm at 0 */]; 
04887                         goto MATCH_label_a46; 
04888                         
04889                         break;
04890                       case 5: case 6: 
04891                         MATCH_name = 
04892                           MATCH_name_adrm_88[(MATCH_w_16_0 >> 3 & 0x7) 
04893                               /* adrm at 0 */]; 
04894                         goto MATCH_label_a47; 
04895                         
04896                         break;
04897                       case 7: 
04898                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
04899                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04900                           MATCH_name = 
04901                             MATCH_name_reg2_89[(MATCH_w_16_0 & 0x7) 
04902                                 /* reg2 at 0 */]; 
04903                           goto MATCH_label_a47; 
04904                           
04905                         } /*opt-block*/
04906                         else 
04907                           goto MATCH_label_a1;  /*opt-block+*/
04908                         
04909                         break;
04910                       default: assert(0);
04911                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
04912                 break;
04913               case 2: 
04914                 if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
04915                   
04916                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04917                       case 0: case 2: 
04918                         MATCH_name = 
04919                           MATCH_name_adrm_94[(MATCH_w_16_0 >> 3 & 0x7) 
04920                               /* adrm at 0 */]; 
04921                         goto MATCH_label_a48; 
04922                         
04923                         break;
04924                       case 1: 
04925                         MATCH_name = 
04926                           MATCH_name_adrm_68[(MATCH_w_16_0 >> 3 & 0x7) 
04927                               /* adrm at 0 */]; 
04928                         goto MATCH_label_a48; 
04929                         
04930                         break;
04931                       case 3: 
04932                         MATCH_name = 
04933                           MATCH_name_adrm_92[(MATCH_w_16_0 >> 3 & 0x7) 
04934                               /* adrm at 0 */]; 
04935                         goto MATCH_label_a48; 
04936                         
04937                         break;
04938                       case 4: 
04939                         MATCH_name = 
04940                           MATCH_name_adrm_90[(MATCH_w_16_0 >> 3 & 0x7) 
04941                               /* adrm at 0 */]; 
04942                         goto MATCH_label_a48; 
04943                         
04944                         break;
04945                       case 5: case 6: 
04946                         MATCH_name = 
04947                           MATCH_name_adrm_94[(MATCH_w_16_0 >> 3 & 0x7) 
04948                               /* adrm at 0 */]; 
04949                         goto MATCH_label_a49; 
04950                         
04951                         break;
04952                       case 7: 
04953                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
04954                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
04955                           MATCH_name = 
04956                             MATCH_name_reg2_95[(MATCH_w_16_0 & 0x7) 
04957                                 /* reg2 at 0 */]; 
04958                           goto MATCH_label_a49; 
04959                           
04960                         } /*opt-block*/
04961                         else 
04962                           goto MATCH_label_a1;  /*opt-block+*/
04963                         
04964                         break;
04965                       default: assert(0);
04966                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
04967                 else 
04968                   
04969                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
04970                       case 0: case 2: 
04971                         MATCH_name = 
04972                           MATCH_name_adrm_92[(MATCH_w_16_0 >> 3 & 0x7) 
04973                               /* adrm at 0 */]; 
04974                         goto MATCH_label_a48; 
04975                         
04976                         break;
04977                       case 1: 
04978                         MATCH_name = 
04979                           MATCH_name_adrm_66[(MATCH_w_16_0 >> 3 & 0x7) 
04980                               /* adrm at 0 */]; 
04981                         goto MATCH_label_a48; 
04982                         
04983                         break;
04984                       case 3: 
04985                         MATCH_name = 
04986                           MATCH_name_adrm_90[(MATCH_w_16_0 >> 3 & 0x7) 
04987                               /* adrm at 0 */]; 
04988                         goto MATCH_label_a48; 
04989                         
04990                         break;
04991                       case 4: 
04992                         MATCH_name = 
04993                           MATCH_name_adrm_88[(MATCH_w_16_0 >> 3 & 0x7) 
04994                               /* adrm at 0 */]; 
04995                         goto MATCH_label_a48; 
04996                         
04997                         break;
04998                       case 5: case 6: 
04999                         MATCH_name = 
05000                           MATCH_name_adrm_92[(MATCH_w_16_0 >> 3 & 0x7) 
05001                               /* adrm at 0 */]; 
05002                         goto MATCH_label_a49; 
05003                         
05004                         break;
05005                       case 7: 
05006                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05007                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05008                           MATCH_name = 
05009                             MATCH_name_reg2_93[(MATCH_w_16_0 & 0x7) 
05010                                 /* reg2 at 0 */]; 
05011                           goto MATCH_label_a49; 
05012                           
05013                         } /*opt-block*/
05014                         else 
05015                           goto MATCH_label_a1;  /*opt-block+*/
05016                         
05017                         break;
05018                       default: assert(0);
05019                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
05020                 break;
05021               case 3: 
05022                 if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05023                   (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) 
05024                   
05025                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05026                       case 0: case 2: case 3: case 4: 
05027                         MATCH_name = 
05028                           MATCH_name_cond_96[(MATCH_w_16_0 >> 8 & 0xf) 
05029                               /* cond at 0 */]; 
05030                         goto MATCH_label_a50; 
05031                         
05032                         break;
05033                       case 1: 
05034                         MATCH_w_16_16 = getWord(2 + MATCH_p); 
05035                         MATCH_name = 
05036                           MATCH_name_cond_97[(MATCH_w_16_0 >> 8 & 0xf) 
05037                               /* cond at 0 */]; 
05038                         goto MATCH_label_a51; 
05039                         
05040                         break;
05041                       case 5: case 6: case 7: 
05042                         MATCH_name = 
05043                           MATCH_name_cond_98[(MATCH_w_16_0 >> 8 & 0xf) 
05044                               /* cond at 0 */]; 
05045                         goto MATCH_label_a52; 
05046                         
05047                         break;
05048                       default: assert(0);
05049                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
05050                 else 
05051                   
05052                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05053                       case 0: case 2: case 3: case 4: 
05054                         MATCH_name = 
05055                           MATCH_name_cond_96[(MATCH_w_16_0 >> 8 & 0xf) 
05056                               /* cond at 0 */]; 
05057                         goto MATCH_label_a50; 
05058                         
05059                         break;
05060                       case 1: 
05061                         MATCH_w_16_16 = getWord(2 + MATCH_p); 
05062                         MATCH_name = 
05063                           MATCH_name_cond_97[(MATCH_w_16_0 >> 8 & 0xf) 
05064                               /* cond at 0 */]; 
05065                         goto MATCH_label_a51; 
05066                         
05067                         break;
05068                       case 5: case 6: 
05069                         MATCH_name = 
05070                           MATCH_name_cond_98[(MATCH_w_16_0 >> 8 & 0xf) 
05071                               /* cond at 0 */]; 
05072                         goto MATCH_label_a52; 
05073                         
05074                         break;
05075                       case 7: 
05076                         goto MATCH_label_a1; break;
05077                       default: assert(0);
05078                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
05079                 break;
05080               default: assert(0);
05081             } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
05082           break;
05083         case 6: 
05084           if (2 <= (MATCH_w_16_0 >> 8 & 0xf) /* cond at 0 */ && 
05085             (MATCH_w_16_0 >> 8 & 0xf) /* cond at 0 */ < 16) { 
05086             MATCH_name = 
05087               MATCH_name_cond_99[(MATCH_w_16_0 >> 8 & 0xf) /* cond at 0 */]; 
05088             { 
05089               char *name = MATCH_name;
05090               unsigned a = addressToPC(MATCH_p);
05091               
05092               #line 729 "machine/mc68k/decoder_low.m"
05093                { 
05094 
05095                       // Bcc
05096 
05097                           RTs = instantiate (pc, name, BTA (a, result, pc)); 
05098 
05099                       }
05100 
05101               
05102 
05103               
05104               
05105               
05106             }
05107             
05108           } /*opt-block*/
05109           else { 
05110             MATCH_name = 
05111               MATCH_name_cond_99[(MATCH_w_16_0 >> 8 & 0xf) /* cond at 0 */]; 
05112             { 
05113               char *name = MATCH_name;
05114               unsigned a = addressToPC(MATCH_p);
05115               
05116               #line 721 "machine/mc68k/decoder_low.m"
05117                { 
05118 
05119                       // _uBranch is  bra | bsr
05120 
05121                           strcpy(sslName, name);
05122 
05123                           if (strcmp (sslName, "bsr") == 0)
05124 
05125                               strcpy (sslName, "jsr"); 
05126 
05127                           RTs = instantiate (pc, sslName, BTA (a, result, pc)); 
05128 
05129                       }
05130 
05131               
05132 
05133               
05134               
05135               
05136             }
05137             
05138           } /*opt-block*/
05139           
05140           break;
05141         case 7: 
05142           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 0) { 
05143             unsigned i8 = (MATCH_w_16_0 & 0xff) /* data8 at 0 */;
05144             unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
05145             
05146             #line 734 "machine/mc68k/decoder_low.m"
05147              { 
05148 
05149                     // moveq (semantics of move immediate long)
05150 
05151                         RTs = instantiate (pc, "movel", DIS_I8, DIS_DN(32)); 
05152 
05153                     } 
05154 
05155             
05156 
05157             
05158             
05159             
05160           } /*opt-block*//*opt-block+*/
05161           else 
05162             goto MATCH_label_a1;  /*opt-block+*/
05163           
05164           break;
05165         case 8: 
05166           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
05167             
05168               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05169                 case 0: 
05170                   
05171                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05172                       case 0: 
05173                         MATCH_name = 
05174                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
05175                               /* adrm at 0 */]; 
05176                         goto MATCH_label_a59; 
05177                         
05178                         break;
05179                       case 1: 
05180                         MATCH_name = 
05181                           MATCH_name_adrm_74[(MATCH_w_16_0 >> 3 & 0x7) 
05182                               /* adrm at 0 */]; 
05183                         goto MATCH_label_a60; 
05184                         
05185                         break;
05186                       case 2: 
05187                         MATCH_name = 
05188                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
05189                               /* adrm at 0 */]; 
05190                         goto MATCH_label_a61; 
05191                         
05192                         break;
05193                       case 3: 
05194                         MATCH_name = 
05195                           MATCH_name_adrm_94[(MATCH_w_16_0 >> 3 & 0x7) 
05196                               /* adrm at 0 */]; 
05197                         goto MATCH_label_a61; 
05198                         
05199                         break;
05200                       case 4: 
05201                         MATCH_name = 
05202                           MATCH_name_adrm_92[(MATCH_w_16_0 >> 3 & 0x7) 
05203                               /* adrm at 0 */]; 
05204                         goto MATCH_label_a61; 
05205                         
05206                         break;
05207                       case 5: case 6: 
05208                         MATCH_name = 
05209                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
05210                               /* adrm at 0 */]; 
05211                         goto MATCH_label_a62; 
05212                         
05213                         break;
05214                       case 7: 
05215                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05216                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05217                           MATCH_name = 
05218                             MATCH_name_reg2_103[(MATCH_w_16_0 & 0x7) 
05219                                 /* reg2 at 0 */]; 
05220                           goto MATCH_label_a62; 
05221                           
05222                         } /*opt-block*/
05223                         else 
05224                           goto MATCH_label_a1;  /*opt-block+*/
05225                         
05226                         break;
05227                       default: assert(0);
05228                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05229                   break;
05230                 case 1: 
05231                   
05232                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05233                       case 0: case 1: 
05234                         goto MATCH_label_a1; break;
05235                       case 2: 
05236                         MATCH_name = 
05237                           MATCH_name_adrm_104[(MATCH_w_16_0 >> 3 & 0x7) 
05238                               /* adrm at 0 */]; 
05239                         goto MATCH_label_a63; 
05240                         
05241                         break;
05242                       case 3: 
05243                         MATCH_name = 
05244                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
05245                               /* adrm at 0 */]; 
05246                         goto MATCH_label_a63; 
05247                         
05248                         break;
05249                       case 4: 
05250                         MATCH_name = 
05251                           MATCH_name_adrm_94[(MATCH_w_16_0 >> 3 & 0x7) 
05252                               /* adrm at 0 */]; 
05253                         goto MATCH_label_a63; 
05254                         
05255                         break;
05256                       case 5: case 6: 
05257                         MATCH_name = 
05258                           MATCH_name_adrm_104[(MATCH_w_16_0 >> 3 & 0x7) 
05259                               /* adrm at 0 */]; 
05260                         goto MATCH_label_a64; 
05261                         
05262                         break;
05263                       case 7: 
05264                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05265                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05266                           MATCH_name = 
05267                             MATCH_name_reg2_105[(MATCH_w_16_0 & 0x7) 
05268                                 /* reg2 at 0 */]; 
05269                           goto MATCH_label_a64; 
05270                           
05271                         } /*opt-block*/
05272                         else 
05273                           goto MATCH_label_a1;  /*opt-block+*/
05274                         
05275                         break;
05276                       default: assert(0);
05277                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05278                   break;
05279                 case 2: 
05280                   
05281                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05282                       case 0: case 1: 
05283                         goto MATCH_label_a1; break;
05284                       case 2: 
05285                         MATCH_name = 
05286                           MATCH_name_adrm_106[(MATCH_w_16_0 >> 3 & 0x7) 
05287                               /* adrm at 0 */]; 
05288                         goto MATCH_label_a65; 
05289                         
05290                         break;
05291                       case 3: 
05292                         MATCH_name = 
05293                           MATCH_name_adrm_104[(MATCH_w_16_0 >> 3 & 0x7) 
05294                               /* adrm at 0 */]; 
05295                         goto MATCH_label_a65; 
05296                         
05297                         break;
05298                       case 4: 
05299                         MATCH_name = 
05300                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
05301                               /* adrm at 0 */]; 
05302                         goto MATCH_label_a65; 
05303                         
05304                         break;
05305                       case 5: case 6: 
05306                         MATCH_name = 
05307                           MATCH_name_adrm_106[(MATCH_w_16_0 >> 3 & 0x7) 
05308                               /* adrm at 0 */]; 
05309                         goto MATCH_label_a66; 
05310                         
05311                         break;
05312                       case 7: 
05313                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05314                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05315                           MATCH_name = 
05316                             MATCH_name_reg2_107[(MATCH_w_16_0 & 0x7) 
05317                                 /* reg2 at 0 */]; 
05318                           goto MATCH_label_a66; 
05319                           
05320                         } /*opt-block*/
05321                         else 
05322                           goto MATCH_label_a1;  /*opt-block+*/
05323                         
05324                         break;
05325                       default: assert(0);
05326                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05327                   break;
05328                 case 3: 
05329                   
05330                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05331                       case 0: case 4: 
05332                         MATCH_name = 
05333                           MATCH_name_adrm_104[(MATCH_w_16_0 >> 3 & 0x7) 
05334                               /* adrm at 0 */]; 
05335                         goto MATCH_label_a55; 
05336                         
05337                         break;
05338                       case 1: 
05339                         goto MATCH_label_a1; break;
05340                       case 2: 
05341                         MATCH_name = 
05342                           MATCH_name_adrm_108[(MATCH_w_16_0 >> 3 & 0x7) 
05343                               /* adrm at 0 */]; 
05344                         goto MATCH_label_a55; 
05345                         
05346                         break;
05347                       case 3: 
05348                         MATCH_name = 
05349                           MATCH_name_adrm_106[(MATCH_w_16_0 >> 3 & 0x7) 
05350                               /* adrm at 0 */]; 
05351                         goto MATCH_label_a55; 
05352                         
05353                         break;
05354                       case 5: case 6: 
05355                         MATCH_name = 
05356                           MATCH_name_adrm_108[(MATCH_w_16_0 >> 3 & 0x7) 
05357                               /* adrm at 0 */]; 
05358                         goto MATCH_label_a58; 
05359                         
05360                         break;
05361                       case 7: 
05362                         
05363                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
05364                             case 0: case 1: 
05365                               MATCH_name = 
05366                                 MATCH_name_reg2_109[(MATCH_w_16_0 & 0x7) 
05367                                     /* reg2 at 0 */]; 
05368                               goto MATCH_label_a58; 
05369                               
05370                               break;
05371                             case 2: 
05372                               MATCH_name = 
05373                                 MATCH_name_reg2_67[(MATCH_w_16_0 & 0x7) 
05374                                     /* reg2 at 0 */]; 
05375                               goto MATCH_label_a58; 
05376                               
05377                               break;
05378                             case 3: 
05379                               MATCH_name = 
05380                                 MATCH_name_reg2_69[(MATCH_w_16_0 & 0x7) 
05381                                     /* reg2 at 0 */]; 
05382                               goto MATCH_label_a58; 
05383                               
05384                               break;
05385                             case 4: 
05386                               MATCH_name = 
05387                                 MATCH_name_reg2_65[(MATCH_w_16_0 & 0x7) 
05388                                     /* reg2 at 0 */]; 
05389                               goto MATCH_label_a58; 
05390                               
05391                               break;
05392                             case 5: case 6: case 7: 
05393                               goto MATCH_label_a1; break;
05394                             default: assert(0);
05395                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
05396                         break;
05397                       default: assert(0);
05398                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05399                   break;
05400                 default: assert(0);
05401               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
05402           else 
05403             
05404               switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05405                 case 0: case 2: case 3: case 4: 
05406                   
05407                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05408                       case 0: 
05409                         MATCH_name = 
05410                           MATCH_name_sz_1[(MATCH_w_16_0 >> 6 & 0x3) 
05411                               /* sz at 0 */]; 
05412                         goto MATCH_label_a53; 
05413                         
05414                         break;
05415                       case 1: 
05416                         MATCH_name = 
05417                           MATCH_name_sz_100[(MATCH_w_16_0 >> 6 & 0x3) 
05418                               /* sz at 0 */]; 
05419                         goto MATCH_label_a41; 
05420                         
05421                         break;
05422                       case 2: 
05423                         MATCH_name = 
05424                           MATCH_name_sz_100[(MATCH_w_16_0 >> 6 & 0x3) 
05425                               /* sz at 0 */]; 
05426                         goto MATCH_label_a54; 
05427                         
05428                         break;
05429                       case 3: 
05430                         MATCH_name = 
05431                           MATCH_name_sz_5[(MATCH_w_16_0 >> 6 & 0x3) 
05432                               /* sz at 0 */]; 
05433                         goto MATCH_label_a55; 
05434                         
05435                         break;
05436                       default: assert(0);
05437                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
05438                   break;
05439                 case 1: 
05440                   goto MATCH_label_a1; break;
05441                 case 5: case 6: 
05442                   
05443                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05444                       case 0: 
05445                         MATCH_name = 
05446                           MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
05447                               /* sz at 0 */]; 
05448                         goto MATCH_label_a56; 
05449                         
05450                         break;
05451                       case 1: 
05452                         MATCH_name = 
05453                           MATCH_name_sz_101[(MATCH_w_16_0 >> 6 & 0x3) 
05454                               /* sz at 0 */]; 
05455                         goto MATCH_label_a42; 
05456                         
05457                         break;
05458                       case 2: 
05459                         MATCH_name = 
05460                           MATCH_name_sz_101[(MATCH_w_16_0 >> 6 & 0x3) 
05461                               /* sz at 0 */]; 
05462                         goto MATCH_label_a57; 
05463                         
05464                         break;
05465                       case 3: 
05466                         MATCH_name = 
05467                           MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
05468                               /* sz at 0 */]; 
05469                         goto MATCH_label_a58; 
05470                         
05471                         break;
05472                       default: assert(0);
05473                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
05474                   break;
05475                 case 7: 
05476                   if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05477                     (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 5) 
05478                     
05479                       switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05480                         case 0: 
05481                           MATCH_name = 
05482                             MATCH_name_sz_3[(MATCH_w_16_0 >> 6 & 0x3) 
05483                                 /* sz at 0 */]; 
05484                           goto MATCH_label_a56; 
05485                           
05486                           break;
05487                         case 1: 
05488                           MATCH_name = 
05489                             MATCH_name_sz_101[(MATCH_w_16_0 >> 6 & 0x3) 
05490                                 /* sz at 0 */]; 
05491                           goto MATCH_label_a42; 
05492                           
05493                           break;
05494                         case 2: 
05495                           MATCH_name = 
05496                             MATCH_name_sz_101[(MATCH_w_16_0 >> 6 & 0x3) 
05497                                 /* sz at 0 */]; 
05498                           goto MATCH_label_a57; 
05499                           
05500                           break;
05501                         case 3: 
05502                           MATCH_name = 
05503                             MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
05504                                 /* sz at 0 */]; 
05505                           goto MATCH_label_a58; 
05506                           
05507                           break;
05508                         default: assert(0);
05509                       } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
05510                   else 
05511                     goto MATCH_label_a1;  /*opt-block+*/
05512                   break;
05513                 default: assert(0);
05514               } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
05515           break;
05516         case 9: 
05517           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
05518             
05519               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05520                 case 0: 
05521                   
05522                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05523                       case 0: 
05524                         MATCH_name = 
05525                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
05526                               /* adrm at 0 */]; 
05527                         goto MATCH_label_a59; 
05528                         
05529                         break;
05530                       case 1: 
05531                         MATCH_name = 
05532                           MATCH_name_adrm_84[(MATCH_w_16_0 >> 3 & 0x7) 
05533                               /* adrm at 0 */]; 
05534                         goto MATCH_label_a60; 
05535                         
05536                         break;
05537                       case 2: 
05538                         MATCH_name = 
05539                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
05540                               /* adrm at 0 */]; 
05541                         goto MATCH_label_a61; 
05542                         
05543                         break;
05544                       case 3: 
05545                         MATCH_name = 
05546                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
05547                               /* adrm at 0 */]; 
05548                         goto MATCH_label_a61; 
05549                         
05550                         break;
05551                       case 4: 
05552                         MATCH_name = 
05553                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
05554                               /* adrm at 0 */]; 
05555                         goto MATCH_label_a61; 
05556                         
05557                         break;
05558                       case 5: case 6: 
05559                         MATCH_name = 
05560                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
05561                               /* adrm at 0 */]; 
05562                         goto MATCH_label_a62; 
05563                         
05564                         break;
05565                       case 7: 
05566                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05567                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05568                           MATCH_name = "submb.ex"; 
05569                           goto MATCH_label_a62; 
05570                           
05571                         } /*opt-block*/
05572                         else 
05573                           goto MATCH_label_a1;  /*opt-block+*/
05574                         
05575                         break;
05576                       default: assert(0);
05577                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05578                   break;
05579                 case 1: 
05580                   
05581                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05582                       case 0: 
05583                         MATCH_name = 
05584                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
05585                               /* adrm at 0 */]; 
05586                         goto MATCH_label_a75; 
05587                         
05588                         break;
05589                       case 1: 
05590                         MATCH_name = 
05591                           MATCH_name_adrm_86[(MATCH_w_16_0 >> 3 & 0x7) 
05592                               /* adrm at 0 */]; 
05593                         goto MATCH_label_a76; 
05594                         
05595                         break;
05596                       case 2: 
05597                         MATCH_name = 
05598                           MATCH_name_adrm_120[(MATCH_w_16_0 >> 3 & 0x7) 
05599                               /* adrm at 0 */]; 
05600                         goto MATCH_label_a63; 
05601                         
05602                         break;
05603                       case 3: 
05604                         MATCH_name = 
05605                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
05606                               /* adrm at 0 */]; 
05607                         goto MATCH_label_a63; 
05608                         
05609                         break;
05610                       case 4: 
05611                         MATCH_name = 
05612                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
05613                               /* adrm at 0 */]; 
05614                         goto MATCH_label_a63; 
05615                         
05616                         break;
05617                       case 5: case 6: 
05618                         MATCH_name = 
05619                           MATCH_name_adrm_120[(MATCH_w_16_0 >> 3 & 0x7) 
05620                               /* adrm at 0 */]; 
05621                         goto MATCH_label_a64; 
05622                         
05623                         break;
05624                       case 7: 
05625                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05626                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05627                           MATCH_name = "submw.ex"; 
05628                           goto MATCH_label_a64; 
05629                           
05630                         } /*opt-block*/
05631                         else 
05632                           goto MATCH_label_a1;  /*opt-block+*/
05633                         
05634                         break;
05635                       default: assert(0);
05636                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05637                   break;
05638                 case 2: 
05639                   
05640                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05641                       case 0: 
05642                         MATCH_name = 
05643                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
05644                               /* adrm at 0 */]; 
05645                         goto MATCH_label_a77; 
05646                         
05647                         break;
05648                       case 1: 
05649                         MATCH_name = 
05650                           MATCH_name_adrm_88[(MATCH_w_16_0 >> 3 & 0x7) 
05651                               /* adrm at 0 */]; 
05652                         goto MATCH_label_a78; 
05653                         
05654                         break;
05655                       case 2: 
05656                         MATCH_name = 
05657                           MATCH_name_adrm_122[(MATCH_w_16_0 >> 3 & 0x7) 
05658                               /* adrm at 0 */]; 
05659                         goto MATCH_label_a65; 
05660                         
05661                         break;
05662                       case 3: 
05663                         MATCH_name = 
05664                           MATCH_name_adrm_120[(MATCH_w_16_0 >> 3 & 0x7) 
05665                               /* adrm at 0 */]; 
05666                         goto MATCH_label_a65; 
05667                         
05668                         break;
05669                       case 4: 
05670                         MATCH_name = 
05671                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
05672                               /* adrm at 0 */]; 
05673                         goto MATCH_label_a65; 
05674                         
05675                         break;
05676                       case 5: case 6: 
05677                         MATCH_name = 
05678                           MATCH_name_adrm_122[(MATCH_w_16_0 >> 3 & 0x7) 
05679                               /* adrm at 0 */]; 
05680                         goto MATCH_label_a66; 
05681                         
05682                         break;
05683                       case 7: 
05684                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
05685                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
05686                           MATCH_name = "subml.ex"; 
05687                           goto MATCH_label_a66; 
05688                           
05689                         } /*opt-block*/
05690                         else 
05691                           goto MATCH_label_a1;  /*opt-block+*/
05692                         
05693                         break;
05694                       default: assert(0);
05695                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05696                   break;
05697                 case 3: 
05698                   
05699                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05700                       case 0: case 4: 
05701                         MATCH_name = 
05702                           MATCH_name_adrm_120[(MATCH_w_16_0 >> 3 & 0x7) 
05703                               /* adrm at 0 */]; 
05704                         goto MATCH_label_a79; 
05705                         
05706                         break;
05707                       case 1: 
05708                         MATCH_name = 
05709                           MATCH_name_adrm_90[(MATCH_w_16_0 >> 3 & 0x7) 
05710                               /* adrm at 0 */]; 
05711                         goto MATCH_label_a79; 
05712                         
05713                         break;
05714                       case 2: 
05715                         MATCH_name = 
05716                           MATCH_name_adrm_124[(MATCH_w_16_0 >> 3 & 0x7) 
05717                               /* adrm at 0 */]; 
05718                         goto MATCH_label_a79; 
05719                         
05720                         break;
05721                       case 3: 
05722                         MATCH_name = 
05723                           MATCH_name_adrm_122[(MATCH_w_16_0 >> 3 & 0x7) 
05724                               /* adrm at 0 */]; 
05725                         goto MATCH_label_a79; 
05726                         
05727                         break;
05728                       case 5: case 6: 
05729                         MATCH_name = 
05730                           MATCH_name_adrm_124[(MATCH_w_16_0 >> 3 & 0x7) 
05731                               /* adrm at 0 */]; 
05732                         goto MATCH_label_a80; 
05733                         
05734                         break;
05735                       case 7: 
05736                         
05737                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
05738                             case 0: case 1: 
05739                               MATCH_name = "subal.ex"; 
05740                               goto MATCH_label_a80; 
05741                               
05742                               break;
05743                             case 2: 
05744                               MATCH_name = 
05745                                 MATCH_name_reg2_80[(MATCH_w_16_0 & 0x7) 
05746                                     /* reg2 at 0 */]; 
05747                               goto MATCH_label_a80; 
05748                               
05749                               break;
05750                             case 3: 
05751                               MATCH_name = 
05752                                 MATCH_name_reg2_81[(MATCH_w_16_0 & 0x7) 
05753                                     /* reg2 at 0 */]; 
05754                               goto MATCH_label_a80; 
05755                               
05756                               break;
05757                             case 4: 
05758                               MATCH_name = 
05759                                 MATCH_name_reg2_77[(MATCH_w_16_0 & 0x7) 
05760                                     /* reg2 at 0 */]; 
05761                               goto MATCH_label_a80; 
05762                               
05763                               break;
05764                             case 5: case 6: case 7: 
05765                               goto MATCH_label_a1; break;
05766                             default: assert(0);
05767                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
05768                         break;
05769                       default: assert(0);
05770                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05771                   break;
05772                 default: assert(0);
05773               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
05774           else 
05775             
05776               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
05777                 case 0: 
05778                   
05779                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05780                       case 0: case 4: 
05781                         MATCH_name = 
05782                           MATCH_name_adrm_106[(MATCH_w_16_0 >> 3 & 0x7) 
05783                               /* adrm at 0 */]; 
05784                         goto MATCH_label_a67; 
05785                         
05786                         break;
05787                       case 1: 
05788                         MATCH_name = 
05789                           MATCH_name_adrm_76[(MATCH_w_16_0 >> 3 & 0x7) 
05790                               /* adrm at 0 */]; 
05791                         goto MATCH_label_a67; 
05792                         
05793                         break;
05794                       case 2: 
05795                         MATCH_name = 
05796                           MATCH_name_adrm_110[(MATCH_w_16_0 >> 3 & 0x7) 
05797                               /* adrm at 0 */]; 
05798                         goto MATCH_label_a67; 
05799                         
05800                         break;
05801                       case 3: 
05802                         MATCH_name = 
05803                           MATCH_name_adrm_108[(MATCH_w_16_0 >> 3 & 0x7) 
05804                               /* adrm at 0 */]; 
05805                         goto MATCH_label_a67; 
05806                         
05807                         break;
05808                       case 5: case 6: 
05809                         MATCH_name = 
05810                           MATCH_name_adrm_110[(MATCH_w_16_0 >> 3 & 0x7) 
05811                               /* adrm at 0 */]; 
05812                         goto MATCH_label_a68; 
05813                         
05814                         break;
05815                       case 7: 
05816                         
05817                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
05818                             case 0: case 1: 
05819                               MATCH_name = "subrb.ex"; 
05820                               goto MATCH_label_a68; 
05821                               
05822                               break;
05823                             case 2: 
05824                               MATCH_name = 
05825                                 MATCH_name_reg2_69[(MATCH_w_16_0 & 0x7) 
05826                                     /* reg2 at 0 */]; 
05827                               goto MATCH_label_a68; 
05828                               
05829                               break;
05830                             case 3: 
05831                               MATCH_name = 
05832                                 MATCH_name_reg2_71[(MATCH_w_16_0 & 0x7) 
05833                                     /* reg2 at 0 */]; 
05834                               goto MATCH_label_a68; 
05835                               
05836                               break;
05837                             case 4: 
05838                               MATCH_name = 
05839                                 MATCH_name_reg2_67[(MATCH_w_16_0 & 0x7) 
05840                                     /* reg2 at 0 */]; 
05841                               goto MATCH_label_a68; 
05842                               
05843                               break;
05844                             case 5: case 6: case 7: 
05845                               goto MATCH_label_a1; break;
05846                             default: assert(0);
05847                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
05848                         break;
05849                       default: assert(0);
05850                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05851                   break;
05852                 case 1: 
05853                   
05854                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05855                       case 0: case 4: 
05856                         MATCH_name = 
05857                           MATCH_name_adrm_108[(MATCH_w_16_0 >> 3 & 0x7) 
05858                               /* adrm at 0 */]; 
05859                         goto MATCH_label_a69; 
05860                         
05861                         break;
05862                       case 1: 
05863                         MATCH_name = 
05864                           MATCH_name_adrm_78[(MATCH_w_16_0 >> 3 & 0x7) 
05865                               /* adrm at 0 */]; 
05866                         goto MATCH_label_a69; 
05867                         
05868                         break;
05869                       case 2: 
05870                         MATCH_name = 
05871                           MATCH_name_adrm_112[(MATCH_w_16_0 >> 3 & 0x7) 
05872                               /* adrm at 0 */]; 
05873                         goto MATCH_label_a69; 
05874                         
05875                         break;
05876                       case 3: 
05877                         MATCH_name = 
05878                           MATCH_name_adrm_110[(MATCH_w_16_0 >> 3 & 0x7) 
05879                               /* adrm at 0 */]; 
05880                         goto MATCH_label_a69; 
05881                         
05882                         break;
05883                       case 5: case 6: 
05884                         MATCH_name = 
05885                           MATCH_name_adrm_112[(MATCH_w_16_0 >> 3 & 0x7) 
05886                               /* adrm at 0 */]; 
05887                         goto MATCH_label_a70; 
05888                         
05889                         break;
05890                       case 7: 
05891                         
05892                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
05893                             case 0: case 1: 
05894                               MATCH_name = "subrw.ex"; 
05895                               goto MATCH_label_a70; 
05896                               
05897                               break;
05898                             case 2: 
05899                               MATCH_name = 
05900                                 MATCH_name_reg2_71[(MATCH_w_16_0 & 0x7) 
05901                                     /* reg2 at 0 */]; 
05902                               goto MATCH_label_a70; 
05903                               
05904                               break;
05905                             case 3: 
05906                               MATCH_name = 
05907                                 MATCH_name_reg2_75[(MATCH_w_16_0 & 0x7) 
05908                                     /* reg2 at 0 */]; 
05909                               goto MATCH_label_a70; 
05910                               
05911                               break;
05912                             case 4: 
05913                               MATCH_name = 
05914                                 MATCH_name_reg2_69[(MATCH_w_16_0 & 0x7) 
05915                                     /* reg2 at 0 */]; 
05916                               goto MATCH_label_a70; 
05917                               
05918                               break;
05919                             case 5: case 6: case 7: 
05920                               goto MATCH_label_a1; break;
05921                             default: assert(0);
05922                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
05923                         break;
05924                       default: assert(0);
05925                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
05926                   break;
05927                 case 2: 
05928                   
05929                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
05930                       case 0: case 4: 
05931                         MATCH_name = 
05932                           MATCH_name_adrm_110[(MATCH_w_16_0 >> 3 & 0x7) 
05933                               /* adrm at 0 */]; 
05934                         goto MATCH_label_a71; 
05935                         
05936                         break;
05937                       case 1: 
05938                         MATCH_name = 
05939                           MATCH_name_adrm_79[(MATCH_w_16_0 >> 3 & 0x7) 
05940                               /* adrm at 0 */]; 
05941                         goto MATCH_label_a71; 
05942                         
05943                         break;
05944                       case 2: 
05945                         MATCH_name = 
05946                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
05947                               /* adrm at 0 */]; 
05948                         goto MATCH_label_a71; 
05949                         
05950                         break;
05951                       case 3: 
05952                         MATCH_name = 
05953                           MATCH_name_adrm_112[(MATCH_w_16_0 >> 3 & 0x7) 
05954                               /* adrm at 0 */]; 
05955                         goto MATCH_label_a71; 
05956                         
05957                         break;
05958                       case 5: case 6: 
05959                         MATCH_name = 
05960                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
05961                               /* adrm at 0 */]; 
05962                         goto MATCH_label_a72; 
05963                         
05964                         break;
05965                       case 7: 
05966                         
05967                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
05968                             case 0: case 1: 
05969                               MATCH_name = "subrl.ex"; 
05970                               goto MATCH_label_a72; 
05971                               
05972                               break;
05973                             case 2: 
05974                               MATCH_name = 
05975                                 MATCH_name_reg2_75[(MATCH_w_16_0 & 0x7) 
05976                                     /* reg2 at 0 */]; 
05977                               goto MATCH_label_a72; 
05978                               
05979                               break;
05980                             case 3: 
05981                               MATCH_name = 
05982                                 MATCH_name_reg2_77[(MATCH_w_16_0 & 0x7) 
05983                                     /* reg2 at 0 */]; 
05984                               goto MATCH_label_a72; 
05985                               
05986                               break;
05987                             case 4: 
05988                               MATCH_name = 
05989                                 MATCH_name_reg2_71[(MATCH_w_16_0 & 0x7) 
05990                                     /* reg2 at 0 */]; 
05991                               goto MATCH_label_a72; 
05992                               
05993                               break;
05994                             case 5: case 6: case 7: 
05995                               goto MATCH_label_a1; break;
05996                             default: assert(0);
05997                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
05998                         break;
05999                       default: assert(0);
06000                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06001                   break;
06002                 case 3: 
06003                   
06004                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06005                       case 0: case 4: 
06006                         MATCH_name = 
06007                           MATCH_name_adrm_112[(MATCH_w_16_0 >> 3 & 0x7) 
06008                               /* adrm at 0 */]; 
06009                         goto MATCH_label_a73; 
06010                         
06011                         break;
06012                       case 1: 
06013                         MATCH_name = 
06014                           MATCH_name_adrm_82[(MATCH_w_16_0 >> 3 & 0x7) 
06015                               /* adrm at 0 */]; 
06016                         goto MATCH_label_a73; 
06017                         
06018                         break;
06019                       case 2: 
06020                         MATCH_name = 
06021                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
06022                               /* adrm at 0 */]; 
06023                         goto MATCH_label_a73; 
06024                         
06025                         break;
06026                       case 3: 
06027                         MATCH_name = 
06028                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
06029                               /* adrm at 0 */]; 
06030                         goto MATCH_label_a73; 
06031                         
06032                         break;
06033                       case 5: case 6: 
06034                         MATCH_name = 
06035                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
06036                               /* adrm at 0 */]; 
06037                         goto MATCH_label_a74; 
06038                         
06039                         break;
06040                       case 7: 
06041                         
06042                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06043                             case 0: case 1: 
06044                               MATCH_name = "subaw.ex"; 
06045                               goto MATCH_label_a74; 
06046                               
06047                               break;
06048                             case 2: 
06049                               MATCH_name = 
06050                                 MATCH_name_reg2_77[(MATCH_w_16_0 & 0x7) 
06051                                     /* reg2 at 0 */]; 
06052                               goto MATCH_label_a74; 
06053                               
06054                               break;
06055                             case 3: 
06056                               MATCH_name = 
06057                                 MATCH_name_reg2_80[(MATCH_w_16_0 & 0x7) 
06058                                     /* reg2 at 0 */]; 
06059                               goto MATCH_label_a74; 
06060                               
06061                               break;
06062                             case 4: 
06063                               MATCH_name = 
06064                                 MATCH_name_reg2_75[(MATCH_w_16_0 & 0x7) 
06065                                     /* reg2 at 0 */]; 
06066                               goto MATCH_label_a74; 
06067                               
06068                               break;
06069                             case 5: case 6: case 7: 
06070                               goto MATCH_label_a1; break;
06071                             default: assert(0);
06072                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06073                         break;
06074                       default: assert(0);
06075                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06076                   break;
06077                 default: assert(0);
06078               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
06079           break;
06080         case 10: case 15: 
06081           goto MATCH_label_a1; break;
06082         case 11: 
06083           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
06084             
06085               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
06086                 case 0: 
06087                   
06088                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06089                       case 0: case 4: 
06090                         MATCH_name = 
06091                           MATCH_name_adrm_130[(MATCH_w_16_0 >> 3 & 0x7) 
06092                               /* adrm at 0 */]; 
06093                         goto MATCH_label_a81; 
06094                         
06095                         break;
06096                       case 1: 
06097                         MATCH_name = 
06098                           MATCH_name_adrm_106[(MATCH_w_16_0 >> 3 & 0x7) 
06099                               /* adrm at 0 */]; 
06100                         goto MATCH_label_a60; 
06101                         
06102                         break;
06103                       case 2: 
06104                         MATCH_name = 
06105                           MATCH_name_adrm_134[(MATCH_w_16_0 >> 3 & 0x7) 
06106                               /* adrm at 0 */]; 
06107                         goto MATCH_label_a81; 
06108                         
06109                         break;
06110                       case 3: 
06111                         MATCH_name = 
06112                           MATCH_name_adrm_132[(MATCH_w_16_0 >> 3 & 0x7) 
06113                               /* adrm at 0 */]; 
06114                         goto MATCH_label_a81; 
06115                         
06116                         break;
06117                       case 5: case 6: 
06118                         MATCH_name = 
06119                           MATCH_name_adrm_134[(MATCH_w_16_0 >> 3 & 0x7) 
06120                               /* adrm at 0 */]; 
06121                         goto MATCH_label_a82; 
06122                         
06123                         break;
06124                       case 7: 
06125                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06126                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06127                           MATCH_name = "eorb.ex"; 
06128                           goto MATCH_label_a82; 
06129                           
06130                         } /*opt-block*/
06131                         else 
06132                           goto MATCH_label_a1;  /*opt-block+*/
06133                         
06134                         break;
06135                       default: assert(0);
06136                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06137                   break;
06138                 case 1: 
06139                   
06140                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06141                       case 0: case 4: 
06142                         MATCH_name = 
06143                           MATCH_name_adrm_132[(MATCH_w_16_0 >> 3 & 0x7) 
06144                               /* adrm at 0 */]; 
06145                         goto MATCH_label_a83; 
06146                         
06147                         break;
06148                       case 1: 
06149                         MATCH_name = 
06150                           MATCH_name_adrm_108[(MATCH_w_16_0 >> 3 & 0x7) 
06151                               /* adrm at 0 */]; 
06152                         goto MATCH_label_a76; 
06153                         
06154                         break;
06155                       case 2: 
06156                         MATCH_name = 
06157                           MATCH_name_adrm_136[(MATCH_w_16_0 >> 3 & 0x7) 
06158                               /* adrm at 0 */]; 
06159                         goto MATCH_label_a83; 
06160                         
06161                         break;
06162                       case 3: 
06163                         MATCH_name = 
06164                           MATCH_name_adrm_134[(MATCH_w_16_0 >> 3 & 0x7) 
06165                               /* adrm at 0 */]; 
06166                         goto MATCH_label_a83; 
06167                         
06168                         break;
06169                       case 5: case 6: 
06170                         MATCH_name = 
06171                           MATCH_name_adrm_136[(MATCH_w_16_0 >> 3 & 0x7) 
06172                               /* adrm at 0 */]; 
06173                         goto MATCH_label_a84; 
06174                         
06175                         break;
06176                       case 7: 
06177                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06178                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06179                           MATCH_name = "eorw.ex"; 
06180                           goto MATCH_label_a84; 
06181                           
06182                         } /*opt-block*/
06183                         else 
06184                           goto MATCH_label_a1;  /*opt-block+*/
06185                         
06186                         break;
06187                       default: assert(0);
06188                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06189                   break;
06190                 case 2: 
06191                   
06192                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06193                       case 0: case 4: 
06194                         MATCH_name = 
06195                           MATCH_name_adrm_134[(MATCH_w_16_0 >> 3 & 0x7) 
06196                               /* adrm at 0 */]; 
06197                         goto MATCH_label_a85; 
06198                         
06199                         break;
06200                       case 1: 
06201                         MATCH_name = 
06202                           MATCH_name_adrm_110[(MATCH_w_16_0 >> 3 & 0x7) 
06203                               /* adrm at 0 */]; 
06204                         goto MATCH_label_a78; 
06205                         
06206                         break;
06207                       case 2: 
06208                         MATCH_name = 
06209                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
06210                               /* adrm at 0 */]; 
06211                         goto MATCH_label_a85; 
06212                         
06213                         break;
06214                       case 3: 
06215                         MATCH_name = 
06216                           MATCH_name_adrm_136[(MATCH_w_16_0 >> 3 & 0x7) 
06217                               /* adrm at 0 */]; 
06218                         goto MATCH_label_a85; 
06219                         
06220                         break;
06221                       case 5: case 6: 
06222                         MATCH_name = 
06223                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
06224                               /* adrm at 0 */]; 
06225                         goto MATCH_label_a86; 
06226                         
06227                         break;
06228                       case 7: 
06229                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06230                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06231                           MATCH_name = "eorl.ex"; 
06232                           goto MATCH_label_a86; 
06233                           
06234                         } /*opt-block*/
06235                         else 
06236                           goto MATCH_label_a1;  /*opt-block+*/
06237                         
06238                         break;
06239                       default: assert(0);
06240                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06241                   break;
06242                 case 3: 
06243                   
06244                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06245                       case 0: case 4: 
06246                         MATCH_name = 
06247                           MATCH_name_adrm_136[(MATCH_w_16_0 >> 3 & 0x7) 
06248                               /* adrm at 0 */]; 
06249                         goto MATCH_label_a79; 
06250                         
06251                         break;
06252                       case 1: 
06253                         MATCH_name = 
06254                           MATCH_name_adrm_112[(MATCH_w_16_0 >> 3 & 0x7) 
06255                               /* adrm at 0 */]; 
06256                         goto MATCH_label_a79; 
06257                         
06258                         break;
06259                       case 2: 
06260                         MATCH_name = 
06261                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
06262                               /* adrm at 0 */]; 
06263                         goto MATCH_label_a79; 
06264                         
06265                         break;
06266                       case 3: 
06267                         MATCH_name = 
06268                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
06269                               /* adrm at 0 */]; 
06270                         goto MATCH_label_a79; 
06271                         
06272                         break;
06273                       case 5: case 6: 
06274                         MATCH_name = 
06275                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
06276                               /* adrm at 0 */]; 
06277                         goto MATCH_label_a80; 
06278                         
06279                         break;
06280                       case 7: 
06281                         
06282                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06283                             case 0: case 1: 
06284                               MATCH_name = "cmpal.ex"; 
06285                               goto MATCH_label_a80; 
06286                               
06287                               break;
06288                             case 2: 
06289                               MATCH_name = 
06290                                 MATCH_name_reg2_89[(MATCH_w_16_0 & 0x7) 
06291                                     /* reg2 at 0 */]; 
06292                               goto MATCH_label_a80; 
06293                               
06294                               break;
06295                             case 3: 
06296                               MATCH_name = 
06297                                 MATCH_name_reg2_91[(MATCH_w_16_0 & 0x7) 
06298                                     /* reg2 at 0 */]; 
06299                               goto MATCH_label_a80; 
06300                               
06301                               break;
06302                             case 4: 
06303                               MATCH_name = 
06304                                 MATCH_name_reg2_87[(MATCH_w_16_0 & 0x7) 
06305                                     /* reg2 at 0 */]; 
06306                               goto MATCH_label_a80; 
06307                               
06308                               break;
06309                             case 5: case 6: case 7: 
06310                               goto MATCH_label_a1; break;
06311                             default: assert(0);
06312                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06313                         break;
06314                       default: assert(0);
06315                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06316                   break;
06317                 default: assert(0);
06318               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
06319           else 
06320             
06321               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
06322                 case 0: 
06323                   
06324                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06325                       case 0: case 4: 
06326                         MATCH_name = 
06327                           MATCH_name_adrm_122[(MATCH_w_16_0 >> 3 & 0x7) 
06328                               /* adrm at 0 */]; 
06329                         goto MATCH_label_a67; 
06330                         
06331                         break;
06332                       case 1: 
06333                         MATCH_name = 
06334                           MATCH_name_adrm_92[(MATCH_w_16_0 >> 3 & 0x7) 
06335                               /* adrm at 0 */]; 
06336                         goto MATCH_label_a67; 
06337                         
06338                         break;
06339                       case 2: 
06340                         MATCH_name = 
06341                           MATCH_name_adrm_126[(MATCH_w_16_0 >> 3 & 0x7) 
06342                               /* adrm at 0 */]; 
06343                         goto MATCH_label_a67; 
06344                         
06345                         break;
06346                       case 3: 
06347                         MATCH_name = 
06348                           MATCH_name_adrm_124[(MATCH_w_16_0 >> 3 & 0x7) 
06349                               /* adrm at 0 */]; 
06350                         goto MATCH_label_a67; 
06351                         
06352                         break;
06353                       case 5: case 6: 
06354                         MATCH_name = 
06355                           MATCH_name_adrm_126[(MATCH_w_16_0 >> 3 & 0x7) 
06356                               /* adrm at 0 */]; 
06357                         goto MATCH_label_a68; 
06358                         
06359                         break;
06360                       case 7: 
06361                         
06362                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06363                             case 0: case 1: 
06364                               MATCH_name = "cmpb.ex"; 
06365                               goto MATCH_label_a68; 
06366                               
06367                               break;
06368                             case 2: 
06369                               MATCH_name = 
06370                                 MATCH_name_reg2_81[(MATCH_w_16_0 & 0x7) 
06371                                     /* reg2 at 0 */]; 
06372                               goto MATCH_label_a68; 
06373                               
06374                               break;
06375                             case 3: 
06376                               MATCH_name = 
06377                                 MATCH_name_reg2_83[(MATCH_w_16_0 & 0x7) 
06378                                     /* reg2 at 0 */]; 
06379                               goto MATCH_label_a68; 
06380                               
06381                               break;
06382                             case 4: 
06383                               MATCH_name = 
06384                                 MATCH_name_reg2_80[(MATCH_w_16_0 & 0x7) 
06385                                     /* reg2 at 0 */]; 
06386                               goto MATCH_label_a68; 
06387                               
06388                               break;
06389                             case 5: case 6: case 7: 
06390                               goto MATCH_label_a1; break;
06391                             default: assert(0);
06392                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06393                         break;
06394                       default: assert(0);
06395                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06396                   break;
06397                 case 1: 
06398                   
06399                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06400                       case 0: case 4: 
06401                         MATCH_name = 
06402                           MATCH_name_adrm_124[(MATCH_w_16_0 >> 3 & 0x7) 
06403                               /* adrm at 0 */]; 
06404                         goto MATCH_label_a69; 
06405                         
06406                         break;
06407                       case 1: 
06408                         MATCH_name = 
06409                           MATCH_name_adrm_94[(MATCH_w_16_0 >> 3 & 0x7) 
06410                               /* adrm at 0 */]; 
06411                         goto MATCH_label_a69; 
06412                         
06413                         break;
06414                       case 2: 
06415                         MATCH_name = 
06416                           MATCH_name_adrm_128[(MATCH_w_16_0 >> 3 & 0x7) 
06417                               /* adrm at 0 */]; 
06418                         goto MATCH_label_a69; 
06419                         
06420                         break;
06421                       case 3: 
06422                         MATCH_name = 
06423                           MATCH_name_adrm_126[(MATCH_w_16_0 >> 3 & 0x7) 
06424                               /* adrm at 0 */]; 
06425                         goto MATCH_label_a69; 
06426                         
06427                         break;
06428                       case 5: case 6: 
06429                         MATCH_name = 
06430                           MATCH_name_adrm_128[(MATCH_w_16_0 >> 3 & 0x7) 
06431                               /* adrm at 0 */]; 
06432                         goto MATCH_label_a70; 
06433                         
06434                         break;
06435                       case 7: 
06436                         
06437                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06438                             case 0: case 1: 
06439                               MATCH_name = "cmpw.ex"; 
06440                               goto MATCH_label_a70; 
06441                               
06442                               break;
06443                             case 2: 
06444                               MATCH_name = 
06445                                 MATCH_name_reg2_83[(MATCH_w_16_0 & 0x7) 
06446                                     /* reg2 at 0 */]; 
06447                               goto MATCH_label_a70; 
06448                               
06449                               break;
06450                             case 3: 
06451                               MATCH_name = 
06452                                 MATCH_name_reg2_85[(MATCH_w_16_0 & 0x7) 
06453                                     /* reg2 at 0 */]; 
06454                               goto MATCH_label_a70; 
06455                               
06456                               break;
06457                             case 4: 
06458                               MATCH_name = 
06459                                 MATCH_name_reg2_81[(MATCH_w_16_0 & 0x7) 
06460                                     /* reg2 at 0 */]; 
06461                               goto MATCH_label_a70; 
06462                               
06463                               break;
06464                             case 5: case 6: case 7: 
06465                               goto MATCH_label_a1; break;
06466                             default: assert(0);
06467                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06468                         break;
06469                       default: assert(0);
06470                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06471                   break;
06472                 case 2: 
06473                   
06474                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06475                       case 0: case 4: 
06476                         MATCH_name = 
06477                           MATCH_name_adrm_126[(MATCH_w_16_0 >> 3 & 0x7) 
06478                               /* adrm at 0 */]; 
06479                         goto MATCH_label_a71; 
06480                         
06481                         break;
06482                       case 1: 
06483                         MATCH_name = 
06484                           MATCH_name_adrm_102[(MATCH_w_16_0 >> 3 & 0x7) 
06485                               /* adrm at 0 */]; 
06486                         goto MATCH_label_a71; 
06487                         
06488                         break;
06489                       case 2: 
06490                         MATCH_name = 
06491                           MATCH_name_adrm_130[(MATCH_w_16_0 >> 3 & 0x7) 
06492                               /* adrm at 0 */]; 
06493                         goto MATCH_label_a71; 
06494                         
06495                         break;
06496                       case 3: 
06497                         MATCH_name = 
06498                           MATCH_name_adrm_128[(MATCH_w_16_0 >> 3 & 0x7) 
06499                               /* adrm at 0 */]; 
06500                         goto MATCH_label_a71; 
06501                         
06502                         break;
06503                       case 5: case 6: 
06504                         MATCH_name = 
06505                           MATCH_name_adrm_130[(MATCH_w_16_0 >> 3 & 0x7) 
06506                               /* adrm at 0 */]; 
06507                         goto MATCH_label_a72; 
06508                         
06509                         break;
06510                       case 7: 
06511                         
06512                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06513                             case 0: case 1: 
06514                               MATCH_name = "cmpl.ex"; 
06515                               goto MATCH_label_a72; 
06516                               
06517                               break;
06518                             case 2: 
06519                               MATCH_name = 
06520                                 MATCH_name_reg2_85[(MATCH_w_16_0 & 0x7) 
06521                                     /* reg2 at 0 */]; 
06522                               goto MATCH_label_a72; 
06523                               
06524                               break;
06525                             case 3: 
06526                               MATCH_name = 
06527                                 MATCH_name_reg2_87[(MATCH_w_16_0 & 0x7) 
06528                                     /* reg2 at 0 */]; 
06529                               goto MATCH_label_a72; 
06530                               
06531                               break;
06532                             case 4: 
06533                               MATCH_name = 
06534                                 MATCH_name_reg2_83[(MATCH_w_16_0 & 0x7) 
06535                                     /* reg2 at 0 */]; 
06536                               goto MATCH_label_a72; 
06537                               
06538                               break;
06539                             case 5: case 6: case 7: 
06540                               goto MATCH_label_a1; break;
06541                             default: assert(0);
06542                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06543                         break;
06544                       default: assert(0);
06545                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06546                   break;
06547                 case 3: 
06548                   
06549                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06550                       case 0: case 4: 
06551                         MATCH_name = 
06552                           MATCH_name_adrm_128[(MATCH_w_16_0 >> 3 & 0x7) 
06553                               /* adrm at 0 */]; 
06554                         goto MATCH_label_a73; 
06555                         
06556                         break;
06557                       case 1: 
06558                         MATCH_name = 
06559                           MATCH_name_adrm_104[(MATCH_w_16_0 >> 3 & 0x7) 
06560                               /* adrm at 0 */]; 
06561                         goto MATCH_label_a73; 
06562                         
06563                         break;
06564                       case 2: 
06565                         MATCH_name = 
06566                           MATCH_name_adrm_132[(MATCH_w_16_0 >> 3 & 0x7) 
06567                               /* adrm at 0 */]; 
06568                         goto MATCH_label_a73; 
06569                         
06570                         break;
06571                       case 3: 
06572                         MATCH_name = 
06573                           MATCH_name_adrm_130[(MATCH_w_16_0 >> 3 & 0x7) 
06574                               /* adrm at 0 */]; 
06575                         goto MATCH_label_a73; 
06576                         
06577                         break;
06578                       case 5: case 6: 
06579                         MATCH_name = 
06580                           MATCH_name_adrm_132[(MATCH_w_16_0 >> 3 & 0x7) 
06581                               /* adrm at 0 */]; 
06582                         goto MATCH_label_a74; 
06583                         
06584                         break;
06585                       case 7: 
06586                         
06587                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06588                             case 0: case 1: 
06589                               MATCH_name = "cmpaw.ex"; 
06590                               goto MATCH_label_a74; 
06591                               
06592                               break;
06593                             case 2: 
06594                               MATCH_name = 
06595                                 MATCH_name_reg2_87[(MATCH_w_16_0 & 0x7) 
06596                                     /* reg2 at 0 */]; 
06597                               goto MATCH_label_a74; 
06598                               
06599                               break;
06600                             case 3: 
06601                               MATCH_name = 
06602                                 MATCH_name_reg2_89[(MATCH_w_16_0 & 0x7) 
06603                                     /* reg2 at 0 */]; 
06604                               goto MATCH_label_a74; 
06605                               
06606                               break;
06607                             case 4: 
06608                               MATCH_name = 
06609                                 MATCH_name_reg2_85[(MATCH_w_16_0 & 0x7) 
06610                                     /* reg2 at 0 */]; 
06611                               goto MATCH_label_a74; 
06612                               
06613                               break;
06614                             case 5: case 6: case 7: 
06615                               goto MATCH_label_a1; break;
06616                             default: assert(0);
06617                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06618                         break;
06619                       default: assert(0);
06620                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06621                   break;
06622                 default: assert(0);
06623               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
06624           break;
06625         case 12: 
06626           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
06627             
06628               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
06629                 case 0: 
06630                   
06631                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06632                       case 0: 
06633                         MATCH_name = 
06634                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
06635                               /* adrm at 0 */]; 
06636                         goto MATCH_label_a59; 
06637                         
06638                         break;
06639                       case 1: 
06640                         MATCH_name = 
06641                           MATCH_name_adrm_114[(MATCH_w_16_0 >> 3 & 0x7) 
06642                               /* adrm at 0 */]; 
06643                         goto MATCH_label_a60; 
06644                         
06645                         break;
06646                       case 2: 
06647                         MATCH_name = 
06648                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
06649                               /* adrm at 0 */]; 
06650                         goto MATCH_label_a61; 
06651                         
06652                         break;
06653                       case 3: 
06654                         MATCH_name = 
06655                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
06656                               /* adrm at 0 */]; 
06657                         goto MATCH_label_a61; 
06658                         
06659                         break;
06660                       case 4: 
06661                         MATCH_name = 
06662                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
06663                               /* adrm at 0 */]; 
06664                         goto MATCH_label_a61; 
06665                         
06666                         break;
06667                       case 5: case 6: 
06668                         MATCH_name = 
06669                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
06670                               /* adrm at 0 */]; 
06671                         goto MATCH_label_a62; 
06672                         
06673                         break;
06674                       case 7: 
06675                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06676                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06677                           MATCH_name = "andmb.ex"; 
06678                           goto MATCH_label_a62; 
06679                           
06680                         } /*opt-block*/
06681                         else 
06682                           goto MATCH_label_a1;  /*opt-block+*/
06683                         
06684                         break;
06685                       default: assert(0);
06686                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06687                   break;
06688                 case 1: 
06689                   
06690                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06691                       case 0: 
06692                         MATCH_name = 
06693                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
06694                               /* adrm at 0 */]; 
06695                         { 
06696                           char *name = MATCH_name;
06697                           unsigned n = 
06698                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
06699                           unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
06700                           
06701                           #line 970 "machine/mc68k/decoder_low.m"
06702                            {
06703 
06704                                       RTs = instantiate (pc, name, DIS_DN(32), DIS_DN2(32));
06705 
06706                                   }
06707 
06708                           
06709 
06710                           
06711                           
06712                           
06713                         }
06714                         
06715                         break;
06716                       case 1: 
06717                         MATCH_name = 
06718                           MATCH_name_adrm_116[(MATCH_w_16_0 >> 3 & 0x7) 
06719                               /* adrm at 0 */]; 
06720                         { 
06721                           char *name = MATCH_name;
06722                           unsigned n = 
06723                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
06724                           unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
06725                           
06726                           #line 974 "machine/mc68k/decoder_low.m"
06727                            {
06728 
06729                                       RTs = instantiate (pc, name, DIS_AN, DIS_AN2);
06730 
06731                                   }
06732 
06733                           
06734 
06735                           
06736                           
06737                           
06738                         }
06739                         
06740                         break;
06741                       case 2: 
06742                         MATCH_name = 
06743                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
06744                               /* adrm at 0 */]; 
06745                         goto MATCH_label_a63; 
06746                         
06747                         break;
06748                       case 3: 
06749                         MATCH_name = 
06750                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
06751                               /* adrm at 0 */]; 
06752                         goto MATCH_label_a63; 
06753                         
06754                         break;
06755                       case 4: 
06756                         MATCH_name = 
06757                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
06758                               /* adrm at 0 */]; 
06759                         goto MATCH_label_a63; 
06760                         
06761                         break;
06762                       case 5: case 6: 
06763                         MATCH_name = 
06764                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
06765                               /* adrm at 0 */]; 
06766                         goto MATCH_label_a64; 
06767                         
06768                         break;
06769                       case 7: 
06770                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06771                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06772                           MATCH_name = "andmw.ex"; 
06773                           goto MATCH_label_a64; 
06774                           
06775                         } /*opt-block*/
06776                         else 
06777                           goto MATCH_label_a1;  /*opt-block+*/
06778                         
06779                         break;
06780                       default: assert(0);
06781                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06782                   break;
06783                 case 2: 
06784                   
06785                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06786                       case 0: 
06787                         goto MATCH_label_a1; break;
06788                       case 1: 
06789                         MATCH_name = 
06790                           MATCH_name_adrm_118[(MATCH_w_16_0 >> 3 & 0x7) 
06791                               /* adrm at 0 */]; 
06792                         { 
06793                           char *name = MATCH_name;
06794                           unsigned n = 
06795                             (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
06796                           unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
06797                           
06798                           #line 978 "machine/mc68k/decoder_low.m"
06799                            {
06800 
06801                                       RTs = instantiate (pc, name, DIS_DN(32), DIS_AN2);
06802 
06803                                   }
06804 
06805                           
06806 
06807                               
06808 
06809                           
06810                           
06811                           
06812                         }
06813                         
06814                         break;
06815                       case 2: 
06816                         MATCH_name = 
06817                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
06818                               /* adrm at 0 */]; 
06819                         goto MATCH_label_a65; 
06820                         
06821                         break;
06822                       case 3: 
06823                         MATCH_name = 
06824                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
06825                               /* adrm at 0 */]; 
06826                         goto MATCH_label_a65; 
06827                         
06828                         break;
06829                       case 4: 
06830                         MATCH_name = 
06831                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
06832                               /* adrm at 0 */]; 
06833                         goto MATCH_label_a65; 
06834                         
06835                         break;
06836                       case 5: case 6: 
06837                         MATCH_name = 
06838                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
06839                               /* adrm at 0 */]; 
06840                         goto MATCH_label_a66; 
06841                         
06842                         break;
06843                       case 7: 
06844                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
06845                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
06846                           MATCH_name = "andml.ex"; 
06847                           goto MATCH_label_a66; 
06848                           
06849                         } /*opt-block*/
06850                         else 
06851                           goto MATCH_label_a1;  /*opt-block+*/
06852                         
06853                         break;
06854                       default: assert(0);
06855                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06856                   break;
06857                 case 3: 
06858                   
06859                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06860                       case 0: 
06861                         MATCH_name = 
06862                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
06863                               /* adrm at 0 */]; 
06864                         goto MATCH_label_a55; 
06865                         
06866                         break;
06867                       case 1: 
06868                         goto MATCH_label_a1; break;
06869                       case 2: 
06870                         MATCH_name = 
06871                           MATCH_name_adrm_150[(MATCH_w_16_0 >> 3 & 0x7) 
06872                               /* adrm at 0 */]; 
06873                         goto MATCH_label_a55; 
06874                         
06875                         break;
06876                       case 3: 
06877                         MATCH_name = 
06878                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
06879                               /* adrm at 0 */]; 
06880                         goto MATCH_label_a55; 
06881                         
06882                         break;
06883                       case 4: 
06884                         MATCH_name = 
06885                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
06886                               /* adrm at 0 */]; 
06887                         goto MATCH_label_a55; 
06888                         
06889                         break;
06890                       case 5: case 6: 
06891                         MATCH_name = 
06892                           MATCH_name_adrm_150[(MATCH_w_16_0 >> 3 & 0x7) 
06893                               /* adrm at 0 */]; 
06894                         goto MATCH_label_a58; 
06895                         
06896                         break;
06897                       case 7: 
06898                         
06899                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
06900                             case 0: case 1: 
06901                               MATCH_name = "muls.ex"; 
06902                               goto MATCH_label_a58; 
06903                               
06904                               break;
06905                             case 2: 
06906                               MATCH_name = 
06907                                 MATCH_name_reg2_91[(MATCH_w_16_0 & 0x7) 
06908                                     /* reg2 at 0 */]; 
06909                               goto MATCH_label_a58; 
06910                               
06911                               break;
06912                             case 3: 
06913                               MATCH_name = 
06914                                 MATCH_name_reg2_93[(MATCH_w_16_0 & 0x7) 
06915                                     /* reg2 at 0 */]; 
06916                               goto MATCH_label_a58; 
06917                               
06918                               break;
06919                             case 4: 
06920                               MATCH_name = 
06921                                 MATCH_name_reg2_89[(MATCH_w_16_0 & 0x7) 
06922                                     /* reg2 at 0 */]; 
06923                               goto MATCH_label_a58; 
06924                               
06925                               break;
06926                             case 5: case 6: case 7: 
06927                               goto MATCH_label_a1; break;
06928                             default: assert(0);
06929                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
06930                         break;
06931                       default: assert(0);
06932                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
06933                   break;
06934                 default: assert(0);
06935               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
06936           else 
06937             
06938               switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
06939                 case 0: case 2: case 3: case 4: 
06940                   
06941                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
06942                       case 0: 
06943                         MATCH_name = 
06944                           MATCH_name_sz_5[(MATCH_w_16_0 >> 6 & 0x3) 
06945                               /* sz at 0 */]; 
06946                         goto MATCH_label_a53; 
06947                         
06948                         break;
06949                       case 1: 
06950                         MATCH_name = 
06951                           MATCH_name_sz_142[(MATCH_w_16_0 >> 6 & 0x3) 
06952                               /* sz at 0 */]; 
06953                         goto MATCH_label_a41; 
06954                         
06955                         break;
06956                       case 2: 
06957                         MATCH_name = 
06958                           MATCH_name_sz_142[(MATCH_w_16_0 >> 6 & 0x3) 
06959                               /* sz at 0 */]; 
06960                         goto MATCH_label_a54; 
06961                         
06962                         break;
06963                       case 3: 
06964                         MATCH_name = 
06965                           MATCH_name_sz_12[(MATCH_w_16_0 >> 6 & 0x3) 
06966                               /* sz at 0 */]; 
06967                         goto MATCH_label_a55; 
06968                         
06969                         break;
06970                       default: assert(0);
06971                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
06972                   break;
06973                 case 1: 
06974                   goto MATCH_label_a1; break;
06975                 case 5: case 6: 
06976                   
06977                     switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
06978                       case 0: 
06979                         MATCH_name = 
06980                           MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
06981                               /* sz at 0 */]; 
06982                         goto MATCH_label_a56; 
06983                         
06984                         break;
06985                       case 1: 
06986                         MATCH_name = 
06987                           MATCH_name_sz_143[(MATCH_w_16_0 >> 6 & 0x3) 
06988                               /* sz at 0 */]; 
06989                         goto MATCH_label_a42; 
06990                         
06991                         break;
06992                       case 2: 
06993                         MATCH_name = 
06994                           MATCH_name_sz_143[(MATCH_w_16_0 >> 6 & 0x3) 
06995                               /* sz at 0 */]; 
06996                         goto MATCH_label_a57; 
06997                         
06998                         break;
06999                       case 3: 
07000                         MATCH_name = 
07001                           MATCH_name_sz_14[(MATCH_w_16_0 >> 6 & 0x3) 
07002                               /* sz at 0 */]; 
07003                         goto MATCH_label_a58; 
07004                         
07005                         break;
07006                       default: assert(0);
07007                     } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/ 
07008                   break;
07009                 case 7: 
07010                   if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
07011                     (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 5) 
07012                     
07013                       switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
07014                         case 0: 
07015                           MATCH_name = 
07016                             MATCH_name_sz_7[(MATCH_w_16_0 >> 6 & 0x3) 
07017                                 /* sz at 0 */]; 
07018                           goto MATCH_label_a56; 
07019                           
07020                           break;
07021                         case 1: 
07022                           MATCH_name = 
07023                             MATCH_name_sz_143[(MATCH_w_16_0 >> 6 & 0x3) 
07024                                 /* sz at 0 */]; 
07025                           goto MATCH_label_a42; 
07026                           
07027                           break;
07028                         case 2: 
07029                           MATCH_name = 
07030                             MATCH_name_sz_143[(MATCH_w_16_0 >> 6 & 0x3) 
07031                                 /* sz at 0 */]; 
07032                           goto MATCH_label_a57; 
07033                           
07034                           break;
07035                         case 3: 
07036                           MATCH_name = 
07037                             MATCH_name_sz_14[(MATCH_w_16_0 >> 6 & 0x3) 
07038                                 /* sz at 0 */]; 
07039                           goto MATCH_label_a58; 
07040                           
07041                           break;
07042                         default: assert(0);
07043                       } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
07044                   else 
07045                     goto MATCH_label_a1;  /*opt-block+*/
07046                   break;
07047                 default: assert(0);
07048               } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/  
07049           break;
07050         case 13: 
07051           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
07052             
07053               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
07054                 case 0: 
07055                   
07056                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07057                       case 0: 
07058                         MATCH_name = 
07059                           MATCH_name_adrm_154[(MATCH_w_16_0 >> 3 & 0x7) 
07060                               /* adrm at 0 */]; 
07061                         goto MATCH_label_a59; 
07062                         
07063                         break;
07064                       case 1: 
07065                         MATCH_name = 
07066                           MATCH_name_adrm_128[(MATCH_w_16_0 >> 3 & 0x7) 
07067                               /* adrm at 0 */]; 
07068                         goto MATCH_label_a60; 
07069                         
07070                         break;
07071                       case 2: 
07072                         MATCH_name = 
07073                           MATCH_name_adrm_160[(MATCH_w_16_0 >> 3 & 0x7) 
07074                               /* adrm at 0 */]; 
07075                         goto MATCH_label_a61; 
07076                         
07077                         break;
07078                       case 3: 
07079                         MATCH_name = 
07080                           MATCH_name_adrm_158[(MATCH_w_16_0 >> 3 & 0x7) 
07081                               /* adrm at 0 */]; 
07082                         goto MATCH_label_a61; 
07083                         
07084                         break;
07085                       case 4: 
07086                         MATCH_name = 
07087                           MATCH_name_adrm_156[(MATCH_w_16_0 >> 3 & 0x7) 
07088                               /* adrm at 0 */]; 
07089                         goto MATCH_label_a61; 
07090                         
07091                         break;
07092                       case 5: case 6: 
07093                         MATCH_name = 
07094                           MATCH_name_adrm_160[(MATCH_w_16_0 >> 3 & 0x7) 
07095                               /* adrm at 0 */]; 
07096                         goto MATCH_label_a62; 
07097                         
07098                         break;
07099                       case 7: 
07100                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
07101                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07102                           MATCH_name = "addmb.ex"; 
07103                           goto MATCH_label_a62; 
07104                           
07105                         } /*opt-block*/
07106                         else 
07107                           goto MATCH_label_a1;  /*opt-block+*/
07108                         
07109                         break;
07110                       default: assert(0);
07111                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07112                   break;
07113                 case 1: 
07114                   
07115                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07116                       case 0: 
07117                         MATCH_name = 
07118                           MATCH_name_adrm_156[(MATCH_w_16_0 >> 3 & 0x7) 
07119                               /* adrm at 0 */]; 
07120                         goto MATCH_label_a75; 
07121                         
07122                         break;
07123                       case 1: 
07124                         MATCH_name = 
07125                           MATCH_name_adrm_130[(MATCH_w_16_0 >> 3 & 0x7) 
07126                               /* adrm at 0 */]; 
07127                         goto MATCH_label_a76; 
07128                         
07129                         break;
07130                       case 2: 
07131                         MATCH_name = 
07132                           MATCH_name_adrm_162[(MATCH_w_16_0 >> 3 & 0x7) 
07133                               /* adrm at 0 */]; 
07134                         goto MATCH_label_a63; 
07135                         
07136                         break;
07137                       case 3: 
07138                         MATCH_name = 
07139                           MATCH_name_adrm_160[(MATCH_w_16_0 >> 3 & 0x7) 
07140                               /* adrm at 0 */]; 
07141                         goto MATCH_label_a63; 
07142                         
07143                         break;
07144                       case 4: 
07145                         MATCH_name = 
07146                           MATCH_name_adrm_158[(MATCH_w_16_0 >> 3 & 0x7) 
07147                               /* adrm at 0 */]; 
07148                         goto MATCH_label_a63; 
07149                         
07150                         break;
07151                       case 5: case 6: 
07152                         MATCH_name = 
07153                           MATCH_name_adrm_162[(MATCH_w_16_0 >> 3 & 0x7) 
07154                               /* adrm at 0 */]; 
07155                         goto MATCH_label_a64; 
07156                         
07157                         break;
07158                       case 7: 
07159                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
07160                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07161                           MATCH_name = "addmw.ex"; 
07162                           goto MATCH_label_a64; 
07163                           
07164                         } /*opt-block*/
07165                         else 
07166                           goto MATCH_label_a1;  /*opt-block+*/
07167                         
07168                         break;
07169                       default: assert(0);
07170                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07171                   break;
07172                 case 2: 
07173                   
07174                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07175                       case 0: 
07176                         MATCH_name = 
07177                           MATCH_name_adrm_158[(MATCH_w_16_0 >> 3 & 0x7) 
07178                               /* adrm at 0 */]; 
07179                         goto MATCH_label_a77; 
07180                         
07181                         break;
07182                       case 1: 
07183                         MATCH_name = 
07184                           MATCH_name_adrm_132[(MATCH_w_16_0 >> 3 & 0x7) 
07185                               /* adrm at 0 */]; 
07186                         goto MATCH_label_a78; 
07187                         
07188                         break;
07189                       case 2: 
07190                         MATCH_name = 
07191                           MATCH_name_adrm_164[(MATCH_w_16_0 >> 3 & 0x7) 
07192                               /* adrm at 0 */]; 
07193                         goto MATCH_label_a65; 
07194                         
07195                         break;
07196                       case 3: 
07197                         MATCH_name = 
07198                           MATCH_name_adrm_162[(MATCH_w_16_0 >> 3 & 0x7) 
07199                               /* adrm at 0 */]; 
07200                         goto MATCH_label_a65; 
07201                         
07202                         break;
07203                       case 4: 
07204                         MATCH_name = 
07205                           MATCH_name_adrm_160[(MATCH_w_16_0 >> 3 & 0x7) 
07206                               /* adrm at 0 */]; 
07207                         goto MATCH_label_a65; 
07208                         
07209                         break;
07210                       case 5: case 6: 
07211                         MATCH_name = 
07212                           MATCH_name_adrm_164[(MATCH_w_16_0 >> 3 & 0x7) 
07213                               /* adrm at 0 */]; 
07214                         goto MATCH_label_a66; 
07215                         
07216                         break;
07217                       case 7: 
07218                         if (0 <= (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ && 
07219                           (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07220                           MATCH_name = "addml.ex"; 
07221                           goto MATCH_label_a66; 
07222                           
07223                         } /*opt-block*/
07224                         else 
07225                           goto MATCH_label_a1;  /*opt-block+*/
07226                         
07227                         break;
07228                       default: assert(0);
07229                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07230                   break;
07231                 case 3: 
07232                   
07233                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07234                       case 0: 
07235                         MATCH_name = 
07236                           MATCH_name_adrm_160[(MATCH_w_16_0 >> 3 & 0x7) 
07237                               /* adrm at 0 */]; 
07238                         goto MATCH_label_a79; 
07239                         
07240                         break;
07241                       case 1: 
07242                         MATCH_name = 
07243                           MATCH_name_adrm_134[(MATCH_w_16_0 >> 3 & 0x7) 
07244                               /* adrm at 0 */]; 
07245                         goto MATCH_label_a79; 
07246                         
07247                         break;
07248                       case 2: 
07249                         MATCH_name = 
07250                           MATCH_name_adrm_166[(MATCH_w_16_0 >> 3 & 0x7) 
07251                               /* adrm at 0 */]; 
07252                         goto MATCH_label_a79; 
07253                         
07254                         break;
07255                       case 3: 
07256                         MATCH_name = 
07257                           MATCH_name_adrm_164[(MATCH_w_16_0 >> 3 & 0x7) 
07258                               /* adrm at 0 */]; 
07259                         goto MATCH_label_a79; 
07260                         
07261                         break;
07262                       case 4: 
07263                         MATCH_name = 
07264                           MATCH_name_adrm_162[(MATCH_w_16_0 >> 3 & 0x7) 
07265                               /* adrm at 0 */]; 
07266                         goto MATCH_label_a79; 
07267                         
07268                         break;
07269                       case 5: case 6: 
07270                         MATCH_name = 
07271                           MATCH_name_adrm_166[(MATCH_w_16_0 >> 3 & 0x7) 
07272                               /* adrm at 0 */]; 
07273                         goto MATCH_label_a80; 
07274                         
07275                         break;
07276                       case 7: 
07277                         
07278                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
07279                             case 0: case 1: 
07280                               MATCH_name = "addal.ex"; 
07281                               goto MATCH_label_a80; 
07282                               
07283                               break;
07284                             case 2: 
07285                               MATCH_name = 
07286                                 MATCH_name_reg2_107[(MATCH_w_16_0 & 0x7) 
07287                                     /* reg2 at 0 */]; 
07288                               goto MATCH_label_a80; 
07289                               
07290                               break;
07291                             case 3: 
07292                               MATCH_name = 
07293                                 MATCH_name_reg2_109[(MATCH_w_16_0 & 0x7) 
07294                                     /* reg2 at 0 */]; 
07295                               goto MATCH_label_a80; 
07296                               
07297                               break;
07298                             case 4: 
07299                               MATCH_name = 
07300                                 MATCH_name_reg2_105[(MATCH_w_16_0 & 0x7) 
07301                                     /* reg2 at 0 */]; 
07302                               goto MATCH_label_a80; 
07303                               
07304                               break;
07305                             case 5: case 6: case 7: 
07306                               goto MATCH_label_a1; break;
07307                             default: assert(0);
07308                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
07309                         break;
07310                       default: assert(0);
07311                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07312                   break;
07313                 default: assert(0);
07314               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
07315           else 
07316             
07317               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
07318                 case 0: 
07319                   
07320                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07321                       case 0: 
07322                         MATCH_name = 
07323                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
07324                               /* adrm at 0 */]; 
07325                         goto MATCH_label_a67; 
07326                         
07327                         break;
07328                       case 1: 
07329                         MATCH_name = 
07330                           MATCH_name_adrm_120[(MATCH_w_16_0 >> 3 & 0x7) 
07331                               /* adrm at 0 */]; 
07332                         goto MATCH_label_a67; 
07333                         
07334                         break;
07335                       case 2: 
07336                         MATCH_name = 
07337                           MATCH_name_adrm_152[(MATCH_w_16_0 >> 3 & 0x7) 
07338                               /* adrm at 0 */]; 
07339                         goto MATCH_label_a67; 
07340                         
07341                         break;
07342                       case 3: 
07343                         MATCH_name = 
07344                           MATCH_name_adrm_150[(MATCH_w_16_0 >> 3 & 0x7) 
07345                               /* adrm at 0 */]; 
07346                         goto MATCH_label_a67; 
07347                         
07348                         break;
07349                       case 4: 
07350                         MATCH_name = 
07351                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
07352                               /* adrm at 0 */]; 
07353                         goto MATCH_label_a67; 
07354                         
07355                         break;
07356                       case 5: case 6: 
07357                         MATCH_name = 
07358                           MATCH_name_adrm_152[(MATCH_w_16_0 >> 3 & 0x7) 
07359                               /* adrm at 0 */]; 
07360                         goto MATCH_label_a68; 
07361                         
07362                         break;
07363                       case 7: 
07364                         
07365                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
07366                             case 0: case 1: 
07367                               MATCH_name = "addrb.ex"; 
07368                               goto MATCH_label_a68; 
07369                               
07370                               break;
07371                             case 2: 
07372                               MATCH_name = 
07373                                 MATCH_name_reg2_93[(MATCH_w_16_0 & 0x7) 
07374                                     /* reg2 at 0 */]; 
07375                               goto MATCH_label_a68; 
07376                               
07377                               break;
07378                             case 3: 
07379                               MATCH_name = 
07380                                 MATCH_name_reg2_95[(MATCH_w_16_0 & 0x7) 
07381                                     /* reg2 at 0 */]; 
07382                               goto MATCH_label_a68; 
07383                               
07384                               break;
07385                             case 4: 
07386                               MATCH_name = 
07387                                 MATCH_name_reg2_91[(MATCH_w_16_0 & 0x7) 
07388                                     /* reg2 at 0 */]; 
07389                               goto MATCH_label_a68; 
07390                               
07391                               break;
07392                             case 5: case 6: case 7: 
07393                               goto MATCH_label_a1; break;
07394                             default: assert(0);
07395                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
07396                         break;
07397                       default: assert(0);
07398                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07399                   break;
07400                 case 1: 
07401                   
07402                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07403                       case 0: 
07404                         MATCH_name = 
07405                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
07406                               /* adrm at 0 */]; 
07407                         goto MATCH_label_a69; 
07408                         
07409                         break;
07410                       case 1: 
07411                         MATCH_name = 
07412                           MATCH_name_adrm_122[(MATCH_w_16_0 >> 3 & 0x7) 
07413                               /* adrm at 0 */]; 
07414                         goto MATCH_label_a69; 
07415                         
07416                         break;
07417                       case 2: 
07418                         MATCH_name = 
07419                           MATCH_name_adrm_154[(MATCH_w_16_0 >> 3 & 0x7) 
07420                               /* adrm at 0 */]; 
07421                         goto MATCH_label_a69; 
07422                         
07423                         break;
07424                       case 3: 
07425                         MATCH_name = 
07426                           MATCH_name_adrm_152[(MATCH_w_16_0 >> 3 & 0x7) 
07427                               /* adrm at 0 */]; 
07428                         goto MATCH_label_a69; 
07429                         
07430                         break;
07431                       case 4: 
07432                         MATCH_name = 
07433                           MATCH_name_adrm_150[(MATCH_w_16_0 >> 3 & 0x7) 
07434                               /* adrm at 0 */]; 
07435                         goto MATCH_label_a69; 
07436                         
07437                         break;
07438                       case 5: case 6: 
07439                         MATCH_name = 
07440                           MATCH_name_adrm_154[(MATCH_w_16_0 >> 3 & 0x7) 
07441                               /* adrm at 0 */]; 
07442                         goto MATCH_label_a70; 
07443                         
07444                         break;
07445                       case 7: 
07446                         
07447                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
07448                             case 0: case 1: 
07449                               MATCH_name = "addrw.ex"; 
07450                               goto MATCH_label_a70; 
07451                               
07452                               break;
07453                             case 2: 
07454                               MATCH_name = 
07455                                 MATCH_name_reg2_95[(MATCH_w_16_0 & 0x7) 
07456                                     /* reg2 at 0 */]; 
07457                               goto MATCH_label_a70; 
07458                               
07459                               break;
07460                             case 3: 
07461                               MATCH_name = 
07462                                 MATCH_name_reg2_103[(MATCH_w_16_0 & 0x7) 
07463                                     /* reg2 at 0 */]; 
07464                               goto MATCH_label_a70; 
07465                               
07466                               break;
07467                             case 4: 
07468                               MATCH_name = 
07469                                 MATCH_name_reg2_93[(MATCH_w_16_0 & 0x7) 
07470                                     /* reg2 at 0 */]; 
07471                               goto MATCH_label_a70; 
07472                               
07473                               break;
07474                             case 5: case 6: case 7: 
07475                               goto MATCH_label_a1; break;
07476                             default: assert(0);
07477                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
07478                         break;
07479                       default: assert(0);
07480                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07481                   break;
07482                 case 2: 
07483                   
07484                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07485                       case 0: 
07486                         MATCH_name = 
07487                           MATCH_name_adrm_150[(MATCH_w_16_0 >> 3 & 0x7) 
07488                               /* adrm at 0 */]; 
07489                         goto MATCH_label_a71; 
07490                         
07491                         break;
07492                       case 1: 
07493                         MATCH_name = 
07494                           MATCH_name_adrm_124[(MATCH_w_16_0 >> 3 & 0x7) 
07495                               /* adrm at 0 */]; 
07496                         goto MATCH_label_a71; 
07497                         
07498                         break;
07499                       case 2: 
07500                         MATCH_name = 
07501                           MATCH_name_adrm_156[(MATCH_w_16_0 >> 3 & 0x7) 
07502                               /* adrm at 0 */]; 
07503                         goto MATCH_label_a71; 
07504                         
07505                         break;
07506                       case 3: 
07507                         MATCH_name = 
07508                           MATCH_name_adrm_154[(MATCH_w_16_0 >> 3 & 0x7) 
07509                               /* adrm at 0 */]; 
07510                         goto MATCH_label_a71; 
07511                         
07512                         break;
07513                       case 4: 
07514                         MATCH_name = 
07515                           MATCH_name_adrm_152[(MATCH_w_16_0 >> 3 & 0x7) 
07516                               /* adrm at 0 */]; 
07517                         goto MATCH_label_a71; 
07518                         
07519                         break;
07520                       case 5: case 6: 
07521                         MATCH_name = 
07522                           MATCH_name_adrm_156[(MATCH_w_16_0 >> 3 & 0x7) 
07523                               /* adrm at 0 */]; 
07524                         goto MATCH_label_a72; 
07525                         
07526                         break;
07527                       case 7: 
07528                         
07529                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
07530                             case 0: case 1: 
07531                               MATCH_name = "addrl.ex"; 
07532                               goto MATCH_label_a72; 
07533                               
07534                               break;
07535                             case 2: 
07536                               MATCH_name = 
07537                                 MATCH_name_reg2_103[(MATCH_w_16_0 & 0x7) 
07538                                     /* reg2 at 0 */]; 
07539                               goto MATCH_label_a72; 
07540                               
07541                               break;
07542                             case 3: 
07543                               MATCH_name = 
07544                                 MATCH_name_reg2_105[(MATCH_w_16_0 & 0x7) 
07545                                     /* reg2 at 0 */]; 
07546                               goto MATCH_label_a72; 
07547                               
07548                               break;
07549                             case 4: 
07550                               MATCH_name = 
07551                                 MATCH_name_reg2_95[(MATCH_w_16_0 & 0x7) 
07552                                     /* reg2 at 0 */]; 
07553                               goto MATCH_label_a72; 
07554                               
07555                               break;
07556                             case 5: case 6: case 7: 
07557                               goto MATCH_label_a1; break;
07558                             default: assert(0);
07559                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
07560                         break;
07561                       default: assert(0);
07562                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07563                   break;
07564                 case 3: 
07565                   
07566                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07567                       case 0: 
07568                         MATCH_name = 
07569                           MATCH_name_adrm_152[(MATCH_w_16_0 >> 3 & 0x7) 
07570                               /* adrm at 0 */]; 
07571                         goto MATCH_label_a73; 
07572                         
07573                         break;
07574                       case 1: 
07575                         MATCH_name = 
07576                           MATCH_name_adrm_126[(MATCH_w_16_0 >> 3 & 0x7) 
07577                               /* adrm at 0 */]; 
07578                         goto MATCH_label_a73; 
07579                         
07580                         break;
07581                       case 2: 
07582                         MATCH_name = 
07583                           MATCH_name_adrm_158[(MATCH_w_16_0 >> 3 & 0x7) 
07584                               /* adrm at 0 */]; 
07585                         goto MATCH_label_a73; 
07586                         
07587                         break;
07588                       case 3: 
07589                         MATCH_name = 
07590                           MATCH_name_adrm_156[(MATCH_w_16_0 >> 3 & 0x7) 
07591                               /* adrm at 0 */]; 
07592                         goto MATCH_label_a73; 
07593                         
07594                         break;
07595                       case 4: 
07596                         MATCH_name = 
07597                           MATCH_name_adrm_154[(MATCH_w_16_0 >> 3 & 0x7) 
07598                               /* adrm at 0 */]; 
07599                         goto MATCH_label_a73; 
07600                         
07601                         break;
07602                       case 5: case 6: 
07603                         MATCH_name = 
07604                           MATCH_name_adrm_158[(MATCH_w_16_0 >> 3 & 0x7) 
07605                               /* adrm at 0 */]; 
07606                         goto MATCH_label_a74; 
07607                         
07608                         break;
07609                       case 7: 
07610                         
07611                           switch((MATCH_w_16_0 & 0x7) /* reg2 at 0 */) {
07612                             case 0: case 1: 
07613                               MATCH_name = "addaw.ex"; 
07614                               goto MATCH_label_a74; 
07615                               
07616                               break;
07617                             case 2: 
07618                               MATCH_name = 
07619                                 MATCH_name_reg2_105[(MATCH_w_16_0 & 0x7) 
07620                                     /* reg2 at 0 */]; 
07621                               goto MATCH_label_a74; 
07622                               
07623                               break;
07624                             case 3: 
07625                               MATCH_name = 
07626                                 MATCH_name_reg2_107[(MATCH_w_16_0 & 0x7) 
07627                                     /* reg2 at 0 */]; 
07628                               goto MATCH_label_a74; 
07629                               
07630                               break;
07631                             case 4: 
07632                               MATCH_name = 
07633                                 MATCH_name_reg2_103[(MATCH_w_16_0 & 0x7) 
07634                                     /* reg2 at 0 */]; 
07635                               goto MATCH_label_a74; 
07636                               
07637                               break;
07638                             case 5: case 6: case 7: 
07639                               goto MATCH_label_a1; break;
07640                             default: assert(0);
07641                           } /* (MATCH_w_16_0 & 0x7) -- reg2 at 0 --*/ 
07642                         break;
07643                       default: assert(0);
07644                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07645                   break;
07646                 default: assert(0);
07647               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
07648           break;
07649         case 14: 
07650           if ((MATCH_w_16_0 >> 8 & 0x1) /* sb at 0 */ == 1) 
07651             
07652               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
07653                 case 0: 
07654                   
07655                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07656                       case 0: 
07657                         MATCH_name = 
07658                           MATCH_name_adrm_168[(MATCH_w_16_0 >> 3 & 0x7) 
07659                               /* adrm at 0 */]; 
07660                         goto MATCH_label_a95; 
07661                         
07662                         break;
07663                       case 1: 
07664                         MATCH_name = 
07665                           MATCH_name_adrm_144[(MATCH_w_16_0 >> 3 & 0x7) 
07666                               /* adrm at 0 */]; 
07667                         goto MATCH_label_a95; 
07668                         
07669                         break;
07670                       case 2: 
07671                         MATCH_name = 
07672                           MATCH_name_adrm_179[(MATCH_w_16_0 >> 3 & 0x7) 
07673                               /* adrm at 0 */]; 
07674                         goto MATCH_label_a95; 
07675                         
07676                         break;
07677                       case 3: 
07678                         MATCH_name = 
07679                           MATCH_name_adrm_177[(MATCH_w_16_0 >> 3 & 0x7) 
07680                               /* adrm at 0 */]; 
07681                         goto MATCH_label_a95; 
07682                         
07683                         break;
07684                       case 4: 
07685                         MATCH_name = 
07686                           MATCH_name_adrm_175[(MATCH_w_16_0 >> 3 & 0x7) 
07687                               /* adrm at 0 */]; 
07688                         goto MATCH_label_a96; 
07689                         
07690                         break;
07691                       case 5: case 6: 
07692                         MATCH_name = 
07693                           MATCH_name_adrm_179[(MATCH_w_16_0 >> 3 & 0x7) 
07694                               /* adrm at 0 */]; 
07695                         goto MATCH_label_a96; 
07696                         
07697                         break;
07698                       case 7: 
07699                         MATCH_name = 
07700                           MATCH_name_adrm_44[(MATCH_w_16_0 >> 3 & 0x7) 
07701                               /* adrm at 0 */]; 
07702                         goto MATCH_label_a96; 
07703                         
07704                         break;
07705                       default: assert(0);
07706                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07707                   break;
07708                 case 1: 
07709                   
07710                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07711                       case 0: 
07712                         MATCH_name = 
07713                           MATCH_name_adrm_169[(MATCH_w_16_0 >> 3 & 0x7) 
07714                               /* adrm at 0 */]; 
07715                         goto MATCH_label_a97; 
07716                         
07717                         break;
07718                       case 1: 
07719                         MATCH_name = 
07720                           MATCH_name_adrm_146[(MATCH_w_16_0 >> 3 & 0x7) 
07721                               /* adrm at 0 */]; 
07722                         goto MATCH_label_a97; 
07723                         
07724                         break;
07725                       case 2: 
07726                         MATCH_name = 
07727                           MATCH_name_adrm_180[(MATCH_w_16_0 >> 3 & 0x7) 
07728                               /* adrm at 0 */]; 
07729                         goto MATCH_label_a97; 
07730                         
07731                         break;
07732                       case 3: 
07733                         MATCH_name = 
07734                           MATCH_name_adrm_179[(MATCH_w_16_0 >> 3 & 0x7) 
07735                               /* adrm at 0 */]; 
07736                         goto MATCH_label_a97; 
07737                         
07738                         break;
07739                       case 4: 
07740                         MATCH_name = 
07741                           MATCH_name_adrm_177[(MATCH_w_16_0 >> 3 & 0x7) 
07742                               /* adrm at 0 */]; 
07743                         goto MATCH_label_a98; 
07744                         
07745                         break;
07746                       case 5: case 6: 
07747                         MATCH_name = 
07748                           MATCH_name_adrm_180[(MATCH_w_16_0 >> 3 & 0x7) 
07749                               /* adrm at 0 */]; 
07750                         goto MATCH_label_a98; 
07751                         
07752                         break;
07753                       case 7: 
07754                         MATCH_name = 
07755                           MATCH_name_adrm_49[(MATCH_w_16_0 >> 3 & 0x7) 
07756                               /* adrm at 0 */]; 
07757                         goto MATCH_label_a98; 
07758                         
07759                         break;
07760                       default: assert(0);
07761                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07762                   break;
07763                 case 2: 
07764                   
07765                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07766                       case 0: 
07767                         MATCH_name = 
07768                           MATCH_name_adrm_170[(MATCH_w_16_0 >> 3 & 0x7) 
07769                               /* adrm at 0 */]; 
07770                         goto MATCH_label_a99; 
07771                         
07772                         break;
07773                       case 1: 
07774                         MATCH_name = 
07775                           MATCH_name_adrm_148[(MATCH_w_16_0 >> 3 & 0x7) 
07776                               /* adrm at 0 */]; 
07777                         goto MATCH_label_a99; 
07778                         
07779                         break;
07780                       case 2: 
07781                         MATCH_name = 
07782                           MATCH_name_adrm_181[(MATCH_w_16_0 >> 3 & 0x7) 
07783                               /* adrm at 0 */]; 
07784                         goto MATCH_label_a99; 
07785                         
07786                         break;
07787                       case 3: 
07788                         MATCH_name = 
07789                           MATCH_name_adrm_180[(MATCH_w_16_0 >> 3 & 0x7) 
07790                               /* adrm at 0 */]; 
07791                         goto MATCH_label_a99; 
07792                         
07793                         break;
07794                       case 4: 
07795                         MATCH_name = 
07796                           MATCH_name_adrm_179[(MATCH_w_16_0 >> 3 & 0x7) 
07797                               /* adrm at 0 */]; 
07798                         goto MATCH_label_a100; 
07799                         
07800                         break;
07801                       case 5: case 6: 
07802                         MATCH_name = 
07803                           MATCH_name_adrm_181[(MATCH_w_16_0 >> 3 & 0x7) 
07804                               /* adrm at 0 */]; 
07805                         goto MATCH_label_a100; 
07806                         
07807                         break;
07808                       case 7: 
07809                         MATCH_name = 
07810                           MATCH_name_adrm_51[(MATCH_w_16_0 >> 3 & 0x7) 
07811                               /* adrm at 0 */]; 
07812                         goto MATCH_label_a100; 
07813                         
07814                         break;
07815                       default: assert(0);
07816                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07817                   break;
07818                 case 3: 
07819                   
07820                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
07821                       case 0: 
07822                         
07823                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07824                             case 0: case 1: 
07825                               goto MATCH_label_a1; break;
07826                             case 2: 
07827                               MATCH_name = 
07828                                 MATCH_name_adrm_182[(MATCH_w_16_0 >> 3 & 0x7) 
07829                                     /* adrm at 0 */]; 
07830                               goto MATCH_label_a101; 
07831                               
07832                               break;
07833                             case 3: 
07834                               MATCH_name = 
07835                                 MATCH_name_adrm_181[(MATCH_w_16_0 >> 3 & 0x7) 
07836                                     /* adrm at 0 */]; 
07837                               goto MATCH_label_a101; 
07838                               
07839                               break;
07840                             case 4: 
07841                               MATCH_name = 
07842                                 MATCH_name_adrm_180[(MATCH_w_16_0 >> 3 & 0x7) 
07843                                     /* adrm at 0 */]; 
07844                               goto MATCH_label_a101; 
07845                               
07846                               break;
07847                             case 5: case 6: 
07848                               MATCH_name = 
07849                                 MATCH_name_adrm_182[(MATCH_w_16_0 >> 3 & 0x7) 
07850                                     /* adrm at 0 */]; 
07851                               goto MATCH_label_a102; 
07852                               
07853                               break;
07854                             case 7: 
07855                               if (0 <= (MATCH_w_16_0 & 0x7) 
07856                                       /* reg2 at 0 */ && 
07857                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07858                                 MATCH_name = "aslm.ex"; 
07859                                 goto MATCH_label_a102; 
07860                                 
07861                               } /*opt-block*/
07862                               else 
07863                                 goto MATCH_label_a1;  /*opt-block+*/
07864                               
07865                               break;
07866                             default: assert(0);
07867                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07868                         break;
07869                       case 1: 
07870                         
07871                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07872                             case 0: case 1: 
07873                               goto MATCH_label_a1; break;
07874                             case 2: 
07875                               MATCH_name = 
07876                                 MATCH_name_adrm_184[(MATCH_w_16_0 >> 3 & 0x7) 
07877                                     /* adrm at 0 */]; 
07878                               goto MATCH_label_a101; 
07879                               
07880                               break;
07881                             case 3: 
07882                               MATCH_name = 
07883                                 MATCH_name_adrm_182[(MATCH_w_16_0 >> 3 & 0x7) 
07884                                     /* adrm at 0 */]; 
07885                               goto MATCH_label_a101; 
07886                               
07887                               break;
07888                             case 4: 
07889                               MATCH_name = 
07890                                 MATCH_name_adrm_181[(MATCH_w_16_0 >> 3 & 0x7) 
07891                                     /* adrm at 0 */]; 
07892                               goto MATCH_label_a101; 
07893                               
07894                               break;
07895                             case 5: case 6: 
07896                               MATCH_name = 
07897                                 MATCH_name_adrm_184[(MATCH_w_16_0 >> 3 & 0x7) 
07898                                     /* adrm at 0 */]; 
07899                               goto MATCH_label_a102; 
07900                               
07901                               break;
07902                             case 7: 
07903                               if (0 <= (MATCH_w_16_0 & 0x7) 
07904                                       /* reg2 at 0 */ && 
07905                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07906                                 MATCH_name = "lslm.ex"; 
07907                                 goto MATCH_label_a102; 
07908                                 
07909                               } /*opt-block*/
07910                               else 
07911                                 goto MATCH_label_a1;  /*opt-block+*/
07912                               
07913                               break;
07914                             default: assert(0);
07915                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07916                         break;
07917                       case 2: 
07918                         
07919                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07920                             case 0: case 1: 
07921                               goto MATCH_label_a1; break;
07922                             case 2: 
07923                               MATCH_name = 
07924                                 MATCH_name_adrm_186[(MATCH_w_16_0 >> 3 & 0x7) 
07925                                     /* adrm at 0 */]; 
07926                               goto MATCH_label_a101; 
07927                               
07928                               break;
07929                             case 3: 
07930                               MATCH_name = 
07931                                 MATCH_name_adrm_184[(MATCH_w_16_0 >> 3 & 0x7) 
07932                                     /* adrm at 0 */]; 
07933                               goto MATCH_label_a101; 
07934                               
07935                               break;
07936                             case 4: 
07937                               MATCH_name = 
07938                                 MATCH_name_adrm_182[(MATCH_w_16_0 >> 3 & 0x7) 
07939                                     /* adrm at 0 */]; 
07940                               goto MATCH_label_a101; 
07941                               
07942                               break;
07943                             case 5: case 6: 
07944                               MATCH_name = 
07945                                 MATCH_name_adrm_186[(MATCH_w_16_0 >> 3 & 0x7) 
07946                                     /* adrm at 0 */]; 
07947                               goto MATCH_label_a102; 
07948                               
07949                               break;
07950                             case 7: 
07951                               if (0 <= (MATCH_w_16_0 & 0x7) 
07952                                       /* reg2 at 0 */ && 
07953                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
07954                                 MATCH_name = "roxlm.ex"; 
07955                                 goto MATCH_label_a102; 
07956                                 
07957                               } /*opt-block*/
07958                               else 
07959                                 goto MATCH_label_a1;  /*opt-block+*/
07960                               
07961                               break;
07962                             default: assert(0);
07963                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
07964                         break;
07965                       case 3: 
07966                         
07967                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
07968                             case 0: case 1: 
07969                               goto MATCH_label_a1; break;
07970                             case 2: 
07971                               MATCH_name = 
07972                                 MATCH_name_adrm_188[(MATCH_w_16_0 >> 3 & 0x7) 
07973                                     /* adrm at 0 */]; 
07974                               goto MATCH_label_a101; 
07975                               
07976                               break;
07977                             case 3: 
07978                               MATCH_name = 
07979                                 MATCH_name_adrm_186[(MATCH_w_16_0 >> 3 & 0x7) 
07980                                     /* adrm at 0 */]; 
07981                               goto MATCH_label_a101; 
07982                               
07983                               break;
07984                             case 4: 
07985                               MATCH_name = 
07986                                 MATCH_name_adrm_184[(MATCH_w_16_0 >> 3 & 0x7) 
07987                                     /* adrm at 0 */]; 
07988                               goto MATCH_label_a101; 
07989                               
07990                               break;
07991                             case 5: case 6: 
07992                               MATCH_name = 
07993                                 MATCH_name_adrm_188[(MATCH_w_16_0 >> 3 & 0x7) 
07994                                     /* adrm at 0 */]; 
07995                               goto MATCH_label_a102; 
07996                               
07997                               break;
07998                             case 7: 
07999                               if (0 <= (MATCH_w_16_0 & 0x7) 
08000                                       /* reg2 at 0 */ && 
08001                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
08002                                 MATCH_name = "rolm.ex"; 
08003                                 goto MATCH_label_a102; 
08004                                 
08005                               } /*opt-block*/
08006                               else 
08007                                 goto MATCH_label_a1;  /*opt-block+*/
08008                               
08009                               break;
08010                             default: assert(0);
08011                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08012                         break;
08013                       case 4: case 5: case 6: case 7: 
08014                         goto MATCH_label_a1; break;
08015                       default: assert(0);
08016                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
08017                   break;
08018                 default: assert(0);
08019               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
08020           else 
08021             
08022               switch((MATCH_w_16_0 >> 6 & 0x3) /* sz at 0 */) {
08023                 case 0: 
08024                   
08025                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08026                       case 0: 
08027                         MATCH_name = 
08028                           MATCH_name_adrm_162[(MATCH_w_16_0 >> 3 & 0x7) 
08029                               /* adrm at 0 */]; 
08030                         goto MATCH_label_a87; 
08031                         
08032                         break;
08033                       case 1: 
08034                         MATCH_name = 
08035                           MATCH_name_adrm_136[(MATCH_w_16_0 >> 3 & 0x7) 
08036                               /* adrm at 0 */]; 
08037                         goto MATCH_label_a87; 
08038                         
08039                         break;
08040                       case 2: 
08041                         MATCH_name = 
08042                           MATCH_name_adrm_168[(MATCH_w_16_0 >> 3 & 0x7) 
08043                               /* adrm at 0 */]; 
08044                         goto MATCH_label_a87; 
08045                         
08046                         break;
08047                       case 3: 
08048                         MATCH_name = 
08049                           MATCH_name_adrm_166[(MATCH_w_16_0 >> 3 & 0x7) 
08050                               /* adrm at 0 */]; 
08051                         goto MATCH_label_a87; 
08052                         
08053                         break;
08054                       case 4: 
08055                         MATCH_name = 
08056                           MATCH_name_adrm_164[(MATCH_w_16_0 >> 3 & 0x7) 
08057                               /* adrm at 0 */]; 
08058                         goto MATCH_label_a88; 
08059                         
08060                         break;
08061                       case 5: case 6: 
08062                         MATCH_name = 
08063                           MATCH_name_adrm_168[(MATCH_w_16_0 >> 3 & 0x7) 
08064                               /* adrm at 0 */]; 
08065                         goto MATCH_label_a88; 
08066                         
08067                         break;
08068                       case 7: 
08069                         MATCH_name = 
08070                           MATCH_name_adrm_35[(MATCH_w_16_0 >> 3 & 0x7) 
08071                               /* adrm at 0 */]; 
08072                         goto MATCH_label_a88; 
08073                         
08074                         break;
08075                       default: assert(0);
08076                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08077                   break;
08078                 case 1: 
08079                   
08080                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08081                       case 0: 
08082                         MATCH_name = 
08083                           MATCH_name_adrm_164[(MATCH_w_16_0 >> 3 & 0x7) 
08084                               /* adrm at 0 */]; 
08085                         goto MATCH_label_a89; 
08086                         
08087                         break;
08088                       case 1: 
08089                         MATCH_name = 
08090                           MATCH_name_adrm_138[(MATCH_w_16_0 >> 3 & 0x7) 
08091                               /* adrm at 0 */]; 
08092                         goto MATCH_label_a89; 
08093                         
08094                         break;
08095                       case 2: 
08096                         MATCH_name = 
08097                           MATCH_name_adrm_169[(MATCH_w_16_0 >> 3 & 0x7) 
08098                               /* adrm at 0 */]; 
08099                         goto MATCH_label_a89; 
08100                         
08101                         break;
08102                       case 3: 
08103                         MATCH_name = 
08104                           MATCH_name_adrm_168[(MATCH_w_16_0 >> 3 & 0x7) 
08105                               /* adrm at 0 */]; 
08106                         goto MATCH_label_a89; 
08107                         
08108                         break;
08109                       case 4: 
08110                         MATCH_name = 
08111                           MATCH_name_adrm_166[(MATCH_w_16_0 >> 3 & 0x7) 
08112                               /* adrm at 0 */]; 
08113                         goto MATCH_label_a90; 
08114                         
08115                         break;
08116                       case 5: case 6: 
08117                         MATCH_name = 
08118                           MATCH_name_adrm_169[(MATCH_w_16_0 >> 3 & 0x7) 
08119                               /* adrm at 0 */]; 
08120                         goto MATCH_label_a90; 
08121                         
08122                         break;
08123                       case 7: 
08124                         MATCH_name = 
08125                           MATCH_name_adrm_37[(MATCH_w_16_0 >> 3 & 0x7) 
08126                               /* adrm at 0 */]; 
08127                         goto MATCH_label_a90; 
08128                         
08129                         break;
08130                       default: assert(0);
08131                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08132                   break;
08133                 case 2: 
08134                   
08135                     switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08136                       case 0: 
08137                         MATCH_name = 
08138                           MATCH_name_adrm_166[(MATCH_w_16_0 >> 3 & 0x7) 
08139                               /* adrm at 0 */]; 
08140                         goto MATCH_label_a91; 
08141                         
08142                         break;
08143                       case 1: 
08144                         MATCH_name = 
08145                           MATCH_name_adrm_140[(MATCH_w_16_0 >> 3 & 0x7) 
08146                               /* adrm at 0 */]; 
08147                         goto MATCH_label_a91; 
08148                         
08149                         break;
08150                       case 2: 
08151                         MATCH_name = 
08152                           MATCH_name_adrm_170[(MATCH_w_16_0 >> 3 & 0x7) 
08153                               /* adrm at 0 */]; 
08154                         goto MATCH_label_a91; 
08155                         
08156                         break;
08157                       case 3: 
08158                         MATCH_name = 
08159                           MATCH_name_adrm_169[(MATCH_w_16_0 >> 3 & 0x7) 
08160                               /* adrm at 0 */]; 
08161                         goto MATCH_label_a91; 
08162                         
08163                         break;
08164                       case 4: 
08165                         MATCH_name = 
08166                           MATCH_name_adrm_168[(MATCH_w_16_0 >> 3 & 0x7) 
08167                               /* adrm at 0 */]; 
08168                         goto MATCH_label_a92; 
08169                         
08170                         break;
08171                       case 5: case 6: 
08172                         MATCH_name = 
08173                           MATCH_name_adrm_170[(MATCH_w_16_0 >> 3 & 0x7) 
08174                               /* adrm at 0 */]; 
08175                         goto MATCH_label_a92; 
08176                         
08177                         break;
08178                       case 7: 
08179                         MATCH_name = 
08180                           MATCH_name_adrm_42[(MATCH_w_16_0 >> 3 & 0x7) 
08181                               /* adrm at 0 */]; 
08182                         goto MATCH_label_a92; 
08183                         
08184                         break;
08185                       default: assert(0);
08186                     } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08187                   break;
08188                 case 3: 
08189                   
08190                     switch((MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */) {
08191                       case 0: 
08192                         
08193                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08194                             case 0: case 1: 
08195                               goto MATCH_label_a1; break;
08196                             case 2: 
08197                               MATCH_name = 
08198                                 MATCH_name_adrm_171[(MATCH_w_16_0 >> 3 & 0x7) 
08199                                     /* adrm at 0 */]; 
08200                               goto MATCH_label_a93; 
08201                               
08202                               break;
08203                             case 3: 
08204                               MATCH_name = 
08205                                 MATCH_name_adrm_170[(MATCH_w_16_0 >> 3 & 0x7) 
08206                                     /* adrm at 0 */]; 
08207                               goto MATCH_label_a93; 
08208                               
08209                               break;
08210                             case 4: 
08211                               MATCH_name = 
08212                                 MATCH_name_adrm_169[(MATCH_w_16_0 >> 3 & 0x7) 
08213                                     /* adrm at 0 */]; 
08214                               goto MATCH_label_a93; 
08215                               
08216                               break;
08217                             case 5: case 6: 
08218                               MATCH_name = 
08219                                 MATCH_name_adrm_171[(MATCH_w_16_0 >> 3 & 0x7) 
08220                                     /* adrm at 0 */]; 
08221                               goto MATCH_label_a94; 
08222                               
08223                               break;
08224                             case 7: 
08225                               if (0 <= (MATCH_w_16_0 & 0x7) 
08226                                       /* reg2 at 0 */ && 
08227                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
08228                                 MATCH_name = "asrm.ex"; 
08229                                 goto MATCH_label_a94; 
08230                                 
08231                               } /*opt-block*/
08232                               else 
08233                                 goto MATCH_label_a1;  /*opt-block+*/
08234                               
08235                               break;
08236                             default: assert(0);
08237                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08238                         break;
08239                       case 1: 
08240                         
08241                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08242                             case 0: case 1: 
08243                               goto MATCH_label_a1; break;
08244                             case 2: 
08245                               MATCH_name = 
08246                                 MATCH_name_adrm_173[(MATCH_w_16_0 >> 3 & 0x7) 
08247                                     /* adrm at 0 */]; 
08248                               goto MATCH_label_a93; 
08249                               
08250                               break;
08251                             case 3: 
08252                               MATCH_name = 
08253                                 MATCH_name_adrm_171[(MATCH_w_16_0 >> 3 & 0x7) 
08254                                     /* adrm at 0 */]; 
08255                               goto MATCH_label_a93; 
08256                               
08257                               break;
08258                             case 4: 
08259                               MATCH_name = 
08260                                 MATCH_name_adrm_170[(MATCH_w_16_0 >> 3 & 0x7) 
08261                                     /* adrm at 0 */]; 
08262                               goto MATCH_label_a93; 
08263                               
08264                               break;
08265                             case 5: case 6: 
08266                               MATCH_name = 
08267                                 MATCH_name_adrm_173[(MATCH_w_16_0 >> 3 & 0x7) 
08268                                     /* adrm at 0 */]; 
08269                               goto MATCH_label_a94; 
08270                               
08271                               break;
08272                             case 7: 
08273                               if (0 <= (MATCH_w_16_0 & 0x7) 
08274                                       /* reg2 at 0 */ && 
08275                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
08276                                 MATCH_name = "lsrm.ex"; 
08277                                 goto MATCH_label_a94; 
08278                                 
08279                               } /*opt-block*/
08280                               else 
08281                                 goto MATCH_label_a1;  /*opt-block+*/
08282                               
08283                               break;
08284                             default: assert(0);
08285                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08286                         break;
08287                       case 2: 
08288                         
08289                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08290                             case 0: case 1: 
08291                               goto MATCH_label_a1; break;
08292                             case 2: 
08293                               MATCH_name = 
08294                                 MATCH_name_adrm_175[(MATCH_w_16_0 >> 3 & 0x7) 
08295                                     /* adrm at 0 */]; 
08296                               goto MATCH_label_a93; 
08297                               
08298                               break;
08299                             case 3: 
08300                               MATCH_name = 
08301                                 MATCH_name_adrm_173[(MATCH_w_16_0 >> 3 & 0x7) 
08302                                     /* adrm at 0 */]; 
08303                               goto MATCH_label_a93; 
08304                               
08305                               break;
08306                             case 4: 
08307                               MATCH_name = 
08308                                 MATCH_name_adrm_171[(MATCH_w_16_0 >> 3 & 0x7) 
08309                                     /* adrm at 0 */]; 
08310                               goto MATCH_label_a93; 
08311                               
08312                               break;
08313                             case 5: case 6: 
08314                               MATCH_name = 
08315                                 MATCH_name_adrm_175[(MATCH_w_16_0 >> 3 & 0x7) 
08316                                     /* adrm at 0 */]; 
08317                               goto MATCH_label_a94; 
08318                               
08319                               break;
08320                             case 7: 
08321                               if (0 <= (MATCH_w_16_0 & 0x7) 
08322                                       /* reg2 at 0 */ && 
08323                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
08324                                 MATCH_name = "roxrm.ex"; 
08325                                 goto MATCH_label_a94; 
08326                                 
08327                               } /*opt-block*/
08328                               else 
08329                                 goto MATCH_label_a1;  /*opt-block+*/
08330                               
08331                               break;
08332                             default: assert(0);
08333                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08334                         break;
08335                       case 3: 
08336                         
08337                           switch((MATCH_w_16_0 >> 3 & 0x7) /* adrm at 0 */) {
08338                             case 0: case 1: 
08339                               goto MATCH_label_a1; break;
08340                             case 2: 
08341                               MATCH_name = 
08342                                 MATCH_name_adrm_177[(MATCH_w_16_0 >> 3 & 0x7) 
08343                                     /* adrm at 0 */]; 
08344                               goto MATCH_label_a93; 
08345                               
08346                               break;
08347                             case 3: 
08348                               MATCH_name = 
08349                                 MATCH_name_adrm_175[(MATCH_w_16_0 >> 3 & 0x7) 
08350                                     /* adrm at 0 */]; 
08351                               goto MATCH_label_a93; 
08352                               
08353                               break;
08354                             case 4: 
08355                               MATCH_name = 
08356                                 MATCH_name_adrm_173[(MATCH_w_16_0 >> 3 & 0x7) 
08357                                     /* adrm at 0 */]; 
08358                               goto MATCH_label_a93; 
08359                               
08360                               break;
08361                             case 5: case 6: 
08362                               MATCH_name = 
08363                                 MATCH_name_adrm_177[(MATCH_w_16_0 >> 3 & 0x7) 
08364                                     /* adrm at 0 */]; 
08365                               goto MATCH_label_a94; 
08366                               
08367                               break;
08368                             case 7: 
08369                               if (0 <= (MATCH_w_16_0 & 0x7) 
08370                                       /* reg2 at 0 */ && 
08371                                 (MATCH_w_16_0 & 0x7) /* reg2 at 0 */ < 2) { 
08372                                 MATCH_name = "rorm.ex"; 
08373                                 goto MATCH_label_a94; 
08374                                 
08375                               } /*opt-block*/
08376                               else 
08377                                 goto MATCH_label_a1;  /*opt-block+*/
08378                               
08379                               break;
08380                             default: assert(0);
08381                           } /* (MATCH_w_16_0 >> 3 & 0x7) -- adrm at 0 --*/ 
08382                         break;
08383                       case 4: case 5: case 6: case 7: 
08384                         goto MATCH_label_a1; break;
08385                       default: assert(0);
08386                     } /* (MATCH_w_16_0 >> 9 & 0x7) -- reg1 at 0 --*/ 
08387                   break;
08388                 default: assert(0);
08389               } /* (MATCH_w_16_0 >> 6 & 0x3) -- sz at 0 --*/  
08390           break;
08391         default: assert(0);
08392       } /* (MATCH_w_16_0 >> 12 & 0xf) -- op at 0 --*/ 
08393     
08394   }goto MATCH_finished_a; 
08395   
08396   MATCH_label_a0: (void)0; /*placeholder for label*/ 
08397     { 
08398       char *name = MATCH_name;
08399       unsigned ea = addressToPC(MATCH_p);
08400       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08401       
08402       #line 227 "machine/mc68k/decoder_low.m"
08403        {
08404 
08405           // _toSR (i16) [names] is privileged (we should never see it)
08406 
08407           // _immEAb  is  addib | andib | cmpib | eorib | orib | subib
08408 
08409                               int bump = 0, bumpr;
08410 
08411                               chop2ndLast(name);
08412 
08413                               RTs = instantiate(pc, sslName, DIS_I8, daEA(ea, pc,
08414 
08415                                   bump, bumpr, 8));
08416 
08417                               ADDBUMP;
08418 
08419                               result.numBytes += 2;
08420 
08421                           }
08422 
08423       
08424 
08425       
08426 
08427       
08428       
08429       
08430     } 
08431     goto MATCH_finished_a; 
08432     
08433   MATCH_label_a1: (void)0; /*placeholder for label*/ 
08434     
08435     #line 1123 "machine/mc68k/decoder_low.m"
08436        {   // the toolkit reserves "else" as a keyword, hence this code
08437 
08438                     if (!prevIsTrap) {
08439 
08440                         ostrstream ost;
08441 
08442                         ost << "Undecoded instruction " << hex << getWord(pc+delta);
08443 
08444                         ost << " at " << pc;
08445 
08446                         warning(str(ost));
08447 
08448                         RTs = NULL;
08449 
08450                     }
08451 
08452                     if (prevIsTrap) 
08453 
08454                         decodeTrapName (pc);
08455 
08456         }  
08457 
08458     
08459      
08460     goto MATCH_finished_a; 
08461     
08462   MATCH_label_a2: (void)0; /*placeholder for label*/ 
08463     { 
08464       char *name = MATCH_name;
08465       unsigned ea = addressToPC(MATCH_p);
08466       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
08467       
08468       #line 246 "machine/mc68k/decoder_low.m"
08469        {
08470 
08471                               int bump = 0, bumpr;
08472 
08473                               chop2ndLast(name);
08474 
08475                               RTs = instantiate(pc, sslName, DIS_I16, daEA(ea, pc,
08476 
08477                                   bump, bumpr, 16));
08478 
08479                               ADDBUMP;
08480 
08481                               result.numBytes += 2;
08482 
08483                           }
08484 
08485       
08486 
08487       
08488 
08489       
08490       
08491       
08492     } 
08493     goto MATCH_finished_a; 
08494     
08495   MATCH_label_a3: (void)0; /*placeholder for label*/ 
08496     { 
08497       char *name = MATCH_name;
08498       unsigned ea = addressToPC(MATCH_p);
08499       unsigned i32 = 
08500         ((MATCH_w_16_16 & 0xffff) /* d16 at 16 */ << 16) + 
08501         (MATCH_w_16_32 & 0xffff) /* d16 at 32 */;
08502       
08503       #line 263 "machine/mc68k/decoder_low.m"
08504        {
08505 
08506                               int bump = 0, bumpr;
08507 
08508                               chop2ndLast(name);
08509 
08510                               RTs = instantiate(pc, sslName, DIS_I32, daEA(ea, pc,
08511 
08512                                   bump, bumpr, 32));
08513 
08514                               ADDBUMP;
08515 
08516                               result.numBytes += 4;
08517 
08518                           }
08519 
08520       
08521 
08522       
08523       
08524       
08525     } 
08526     goto MATCH_finished_a; 
08527     
08528   MATCH_label_a4: (void)0; /*placeholder for label*/ 
08529     { 
08530       char *name = MATCH_name;
08531       unsigned ea = addressToPC(MATCH_p);
08532       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08533       
08534       #line 297 "machine/mc68k/decoder_low.m"
08535        {
08536 
08537                               int bump = 0, bumpr;
08538 
08539                               strcpy(sslName, name);
08540 
08541                               sslName[4] = '\0';         // Truncate name
08542 
08543                               RTs = instantiate(pc, sslName, DIS_I8, daEA(ea, pc,
08544 
08545                                   bump, bumpr, 8));
08546 
08547                               ADDBUMP;
08548 
08549                               result.numBytes += 2;
08550 
08551                           }
08552 
08553       
08554 
08555       
08556       
08557       
08558     } 
08559     goto MATCH_finished_a; 
08560     
08561   MATCH_label_a5: (void)0; /*placeholder for label*/ 
08562     { 
08563       char *name = MATCH_name;
08564       unsigned ea = addressToPC(MATCH_p);
08565       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
08566       
08567       #line 280 "machine/mc68k/decoder_low.m"
08568        {
08569 
08570               // _bits    is  bchg  | bclr  | bset
08571 
08572               // _bitsi   is  bchgi | bclri | bseti
08573 
08574               // This series are assumed to be 8 bits where memory is involved,
08575 
08576               // or 32 for registers
08577 
08578                               int bump = 0, bumpr;
08579 
08580                               RTs = instantiate(pc, name, DIS_DN(32), daEA(ea, pc,
08581 
08582                                   bump, bumpr, 8));
08583 
08584                               ADDBUMP;
08585 
08586                           }
08587 
08588       
08589 
08590       
08591       
08592       
08593     } 
08594     goto MATCH_finished_a; 
08595     
08596   MATCH_label_a6: (void)0; /*placeholder for label*/ 
08597     { 
08598       char *name = MATCH_name;
08599       unsigned eax = addressToPC(MATCH_p);
08600       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08601       unsigned x = 4 + addressToPC(MATCH_p);
08602       
08603       #line 239 "machine/mc68k/decoder_low.m"
08604        {
08605 
08606                               chopBoth(name);
08607 
08608                               RTs = instantiate(pc, sslName, DIS_I8,
08609 
08610                                   daEAX(eax, x, result, pc, 8));
08611 
08612                               result.numBytes += 2;
08613 
08614                           }
08615 
08616           
08617 
08618       
08619       
08620       
08621     } 
08622     goto MATCH_finished_a; 
08623     
08624   MATCH_label_a7: (void)0; /*placeholder for label*/ 
08625     { 
08626       char *name = MATCH_name;
08627       unsigned eax = addressToPC(MATCH_p);
08628       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
08629       unsigned x = 4 + addressToPC(MATCH_p);
08630       
08631       #line 256 "machine/mc68k/decoder_low.m"
08632        {
08633 
08634                               chopBoth(name);
08635 
08636                               RTs = instantiate(pc, sslName, DIS_I16,
08637 
08638                                   daEAX(eax, x, result, pc, 16));
08639 
08640                               result.numBytes += 2;
08641 
08642                           }
08643 
08644           
08645 
08646       
08647       
08648       
08649     } 
08650     goto MATCH_finished_a; 
08651     
08652   MATCH_label_a8: (void)0; /*placeholder for label*/ 
08653     { 
08654       char *name = MATCH_name;
08655       unsigned eax = addressToPC(MATCH_p);
08656       unsigned i32 = 
08657         ((MATCH_w_16_16 & 0xffff) /* d16 at 16 */ << 16) + 
08658         (MATCH_w_16_32 & 0xffff) /* d16 at 32 */;
08659       unsigned x = 6 + addressToPC(MATCH_p);
08660       
08661       #line 272 "machine/mc68k/decoder_low.m"
08662        {
08663 
08664                               chopBoth(name);
08665 
08666                               RTs = instantiate(pc, sslName, DIS_I32,
08667 
08668                                   daEAX(eax, x, result, pc, 32));
08669 
08670                               result.numBytes += 4;
08671 
08672                           }
08673 
08674       
08675 
08676           
08677 
08678       
08679       
08680       
08681     } 
08682     goto MATCH_finished_a; 
08683     
08684   MATCH_label_a9: (void)0; /*placeholder for label*/ 
08685     { 
08686       unsigned eax = addressToPC(MATCH_p);
08687       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08688       unsigned x = 4 + addressToPC(MATCH_p);
08689       
08690       #line 335 "machine/mc68k/decoder_low.m"
08691        { 
08692 
08693                   RTs = instantiate (pc, "btst", DIS_I8,
08694 
08695                       dBEAX (eax, x, result, pc, delta, 8));
08696 
08697                   result.numBytes += 2; 
08698 
08699               // MOVEP: privileged (and uncommon as well)
08700 
08701               }
08702 
08703       
08704 
08705       
08706       
08707       
08708     } 
08709     goto MATCH_finished_a; 
08710     
08711   MATCH_label_a10: (void)0; /*placeholder for label*/ 
08712     { 
08713       char *name = MATCH_name;
08714       unsigned eax = addressToPC(MATCH_p);
08715       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08716       unsigned x = 4 + addressToPC(MATCH_p);
08717       
08718       #line 307 "machine/mc68k/decoder_low.m"
08719        {
08720 
08721                               strcpy(sslName, name);
08722 
08723                               sslName[4] = '\0';         // Truncate name
08724 
08725                               RTs = instantiate(pc, sslName, DIS_I8,
08726 
08727                                   daEAX(eax, x, result, pc, 8));
08728 
08729                               result.numBytes += 2;
08730 
08731                           }
08732 
08733           
08734 
08735       
08736       
08737       
08738     } 
08739     goto MATCH_finished_a; 
08740     
08741   MATCH_label_a11: (void)0; /*placeholder for label*/ 
08742     { 
08743       unsigned eax = addressToPC(MATCH_p);
08744       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
08745       unsigned x = 2 + addressToPC(MATCH_p);
08746       
08747       #line 323 "machine/mc68k/decoder_low.m"
08748        { 
08749 
08750                   RTs = instantiate (pc, "btst", DIS_DN(32),
08751 
08752                       dBEAX (eax, x, result, pc, delta, 8));
08753 
08754               }
08755 
08756       
08757 
08758       
08759       
08760       
08761     } 
08762     goto MATCH_finished_a; 
08763     
08764   MATCH_label_a12: (void)0; /*placeholder for label*/ 
08765     { 
08766       char *name = MATCH_name;
08767       unsigned eax = addressToPC(MATCH_p);
08768       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
08769       unsigned x = 2 + addressToPC(MATCH_p);
08770       
08771       #line 291 "machine/mc68k/decoder_low.m"
08772        {
08773 
08774                               chopDotex(name);
08775 
08776                               RTs = instantiate(pc, sslName, DIS_DN(32),
08777 
08778                                   daEAX(eax, x, result, pc, 8));
08779 
08780                           }
08781 
08782       
08783 
08784       
08785       
08786       
08787     } 
08788     goto MATCH_finished_a; 
08789     
08790   MATCH_label_a13: (void)0; /*placeholder for label*/ 
08791     { 
08792       char *name = MATCH_name;
08793       unsigned i8 = (MATCH_w_16_16 & 0xff) /* disp8 at 16 */;
08794       
08795       #line 220 "machine/mc68k/decoder_low.m"
08796        {
08797 
08798           // _toCCR   is  andiToCCR | eoriToCCR | oriToCCR
08799 
08800                               RTs = instantiate(pc, name, DIS_I8);
08801 
08802                           }
08803 
08804       
08805 
08806       
08807 
08808       
08809 
08810       
08811       
08812       
08813     } 
08814     goto MATCH_finished_a; 
08815     
08816   MATCH_label_a14: (void)0; /*placeholder for label*/ 
08817     { 
08818       char *name = MATCH_name;
08819       unsigned ea = addressToPC(MATCH_p);
08820       unsigned ea2 = addressToPC(MATCH_p);
08821       
08822       #line 342 "machine/mc68k/decoder_low.m"
08823        { 
08824 
08825               // MOVE
08826 
08827               // _move is  moveb | movew | movel
08828 
08829               // check b|w|l
08830 
08831                   int bump = 0, bumpr, siz=32;
08832 
08833                   SemStr* t1;     // Ptr to SemStr with src
08834 
08835                   SemStr* t2;     // Ptr to SemStr with dest
08836 
08837                   SemStr* t3;     // Ptr to SemStr with "temp1"
08838 
08839                   strcpy(sslName, name);
08840 
08841                   sslName[5] = '\0';  // truncate name
08842 
08843                   if (name[4] == 'b') siz = 8;
08844 
08845                   if (name[4] == 'w') siz = 16;
08846 
08847                   t1 = msEA(ea, pc, bump, bumpr, siz);
08848 
08849                   RTs = new list<RT*>;    // Empty list of RTs
08850 
08851                   ADDBUMP;                // Src may cause a bump
08852 
08853                   bump = 0;
08854 
08855                   t2 = mdEA(ea2, pc, bump, bumpr, siz);
08856 
08857                   ADDBUMP;                // Dest may cause a bump as well
08858 
08859                   // Check for An as a dest, and not 32 bits size
08860 
08861                   RT* rt;
08862 
08863                   bool sgnex = ((siz != 32) && (t2->getFirstIdx() == idRegOf) &&
08864 
08865                     (t2->getThirdIdx() >= 8));
08866 
08867                   if (sgnex) {
08868 
08869                       // Yes, therefore this is a sign extent to 32 bits
08870 
08871                       rt = sgnExTemp(t1, siz, 32, t3);
08872 
08873                       siz = 32;
08874 
08875                       t2->getType().setSize(32);
08876 
08877                       sslName[4] = 'l';       // So the second assignment will be long
08878 
08879                   }
08880 
08881                   if (!sgnex)     // else
08882 
08883                       // Just assign the source to temp1
08884 
08885                       rt = assignTemp(t1, siz, t3); 
08886 
08887                   // We instantiate RTs2 to be dest = temp1
08888 
08889                   list<RT*>* RTs2 = (instantiate (pc, sslName, t3, t2));
08890 
08891                   // RTs has 0-2 bumps (in the correct order). We must insert
08892 
08893                   // before that dest = temp1, and before that rt (temp1 = src etc)
08894 
08895                   RTs->insert(RTs->begin(), RTs2->begin(), RTs2->end());
08896 
08897                   RTs->insert(RTs->begin(), rt);
08898 
08899                   delete RTs2;
08900 
08901               }
08902 
08903       
08904 
08905       
08906       
08907       
08908     } 
08909     goto MATCH_finished_a; 
08910     
08911   MATCH_label_a15: (void)0; /*placeholder for label*/ 
08912     { 
08913       char *name = MATCH_name;
08914       unsigned ea2 = addressToPC(MATCH_p);
08915       unsigned eax = addressToPC(MATCH_p);
08916       unsigned x = 2 + addressToPC(MATCH_p);
08917       
08918       #line 383 "machine/mc68k/decoder_low.m"
08919        { 
08920 
08921                   int bump = 0, bumpr, siz=32;
08922 
08923                   if (name[4] == 'b') siz = 8;
08924 
08925                   if (name[4] == 'w') siz = 16;
08926 
08927                   strcpy(sslName, name);
08928 
08929                   sslName[5] = '\0';  // truncate name
08930 
08931                   RTs = instantiate (pc, sslName,
08932 
08933                       msEAX (eax, x, result, pc, delta, siz),
08934 
08935                       mdEA (ea2, pc, bump, bumpr, siz));
08936 
08937                   ADDBUMP;
08938 
08939               }
08940 
08941       
08942 
08943       
08944       
08945       
08946     } 
08947     goto MATCH_finished_a; 
08948     
08949   MATCH_label_a16: (void)0; /*placeholder for label*/ 
08950     { 
08951       char *name = MATCH_name;
08952       unsigned d32 = 
08953         ((MATCH_w_16_16 & 0xffff) /* d16 at 16 */ << 16) + 
08954         (MATCH_w_16_32 & 0xffff) /* d16 at 32 */;
08955       unsigned ea2 = addressToPC(MATCH_p);
08956       unsigned eaxl = addressToPC(MATCH_p);
08957       
08958       #line 395 "machine/mc68k/decoder_low.m"
08959        { 
08960 
08961                   int bump = 0, bumpr;
08962 
08963                   int siz = 32;
08964 
08965                   if (name[4] == 'b') siz = 8;
08966 
08967                   if (name[4] == 'w') siz = 16;
08968 
08969                   strcpy(sslName, name);
08970 
08971                   sslName[5] = '\0';  // truncate name
08972 
08973                   RTs = instantiate (pc, sslName,
08974 
08975                       msEAXL (eaxl, d32, result, pc, siz),
08976 
08977                       mdEA (ea2, pc, bump, bumpr, siz)); 
08978 
08979                   ADDBUMP;
08980 
08981               }
08982 
08983       
08984 
08985       
08986       
08987       
08988     } 
08989     goto MATCH_finished_a; 
08990     
08991   MATCH_label_a17: (void)0; /*placeholder for label*/ 
08992     { 
08993       char *name = MATCH_name;
08994       unsigned ea = addressToPC(MATCH_p);
08995       unsigned eax2 = addressToPC(MATCH_p);
08996       unsigned x2 = 2 + addressToPC(MATCH_p);
08997       
08998       #line 408 "machine/mc68k/decoder_low.m"
08999        { 
09000 
09001                   int bump = 0, bumpr;
09002 
09003                   int siz = 32;
09004 
09005                   if (name[4] == 'b') siz = 8;
09006 
09007                   if (name[4] == 'w') siz = 16;
09008 
09009                   strcpy(sslName, name);
09010 
09011                   sslName[5] = '\0';  // truncate name
09012 
09013                   RTs = instantiate (pc, sslName,
09014 
09015                       msEA (ea, pc, bump, bumpr, siz), 
09016 
09017                       mdEAX (eax2, x2, result, pc, siz)); 
09018 
09019                   ADDBUMP;
09020 
09021               }
09022 
09023       
09024 
09025       
09026       
09027       
09028     } 
09029     goto MATCH_finished_a; 
09030     
09031   MATCH_label_a18: (void)0; /*placeholder for label*/ 
09032     { 
09033       char *name = MATCH_name;
09034       unsigned eax = addressToPC(MATCH_p);
09035       unsigned eax2 = addressToPC(MATCH_p);
09036       unsigned x = 2 + addressToPC(MATCH_p);
09037       unsigned x2 = 4 + addressToPC(MATCH_p);
09038       
09039       #line 421 "machine/mc68k/decoder_low.m"
09040        { 
09041 
09042                   int siz = 32;
09043 
09044                   if (name[4] == 'b') siz = 8;
09045 
09046                   if (name[4] == 'w') siz = 16;
09047 
09048                   strcpy(sslName, name);
09049 
09050                   sslName[5] = '\0';  // truncate name
09051 
09052                   RTs = instantiate (pc, sslName,
09053 
09054                       msEAX (eax, x, result, pc, delta, siz),
09055 
09056                       mdEAX (eax2, x2, result, pc, siz)); 
09057 
09058               }
09059 
09060       
09061 
09062       
09063       
09064       
09065     } 
09066     goto MATCH_finished_a; 
09067     
09068   MATCH_label_a19: (void)0; /*placeholder for label*/ 
09069     { 
09070       char *name = MATCH_name;
09071       unsigned d32 = 
09072         ((MATCH_w_16_16 & 0xffff) /* d16 at 16 */ << 16) + 
09073         (MATCH_w_16_32 & 0xffff) /* d16 at 32 */;
09074       unsigned eax2 = addressToPC(MATCH_p);
09075       unsigned eaxl = addressToPC(MATCH_p);
09076       unsigned x2 = 6 + addressToPC(MATCH_p);
09077       
09078       #line 432 "machine/mc68k/decoder_low.m"
09079        { 
09080 
09081                   int siz = 32;
09082 
09083                   if (name[4] == 'b') siz = 8;
09084 
09085                   if (name[4] == 'w') siz = 16;
09086 
09087                   strcpy(sslName, name);
09088 
09089                   sslName[5] = '\0';  // truncate name
09090 
09091                   RTs = instantiate (pc, sslName,
09092 
09093                       msEAXL (eaxl, d32, result, pc, siz),
09094 
09095                       mdEAX (eax2, x2, result, pc, siz)); 
09096 
09097               }
09098 
09099       
09100 
09101       
09102 
09103       
09104       
09105       
09106     } 
09107     goto MATCH_finished_a; 
09108     
09109   MATCH_label_a20: (void)0; /*placeholder for label*/ 
09110     { 
09111       char *name = MATCH_name;
09112       unsigned ea = addressToPC(MATCH_p);
09113       
09114       #line 444 "machine/mc68k/decoder_low.m"
09115        { 
09116 
09117               // One operand instructions 
09118 
09119               //  _oneEAdaB is  clrb | negb | negxb | notb | tstb | nbcd | tas
09120 
09121               //  _oneEAdaW is  clrw | negw | negxw | notw | tstw
09122 
09123               //  _oneEAdaL is  clrl | negl | negxl | notl | tstl
09124 
09125                   int bump = 0, bumpr;
09126 
09127                   chopDotex(name);
09128 
09129                   RTs = instantiate (pc, sslName, daEA (ea, pc, bump, bumpr, 8)); 
09130 
09131                   ADDBUMP;
09132 
09133               }  
09134 
09135       
09136 
09137       
09138       
09139       
09140     } 
09141     goto MATCH_finished_a; 
09142     
09143   MATCH_label_a21: (void)0; /*placeholder for label*/ 
09144     { 
09145       char *name = MATCH_name;
09146       unsigned eax = addressToPC(MATCH_p);
09147       unsigned x = 2 + addressToPC(MATCH_p);
09148       
09149       #line 455 "machine/mc68k/decoder_low.m"
09150        { 
09151 
09152                   chopDotex(name);
09153 
09154                   RTs = instantiate (pc, sslName, daEAX (eax, x, result, pc, 8)); 
09155 
09156               }
09157 
09158       
09159 
09160       
09161       
09162       
09163     } 
09164     goto MATCH_finished_a; 
09165     
09166   MATCH_label_a22: (void)0; /*placeholder for label*/ 
09167     { 
09168       char *name = MATCH_name;
09169       unsigned ea = addressToPC(MATCH_p);
09170       
09171       #line 460 "machine/mc68k/decoder_low.m"
09172        { 
09173 
09174                   int bump = 0, bumpr;
09175 
09176                   chopDotex(name);
09177 
09178                   RTs = instantiate (pc, sslName, daEA (ea, pc, bump, bumpr, 16)); 
09179 
09180                   ADDBUMP;
09181 
09182               }
09183 
09184       
09185 
09186       
09187       
09188       
09189     } 
09190     goto MATCH_finished_a; 
09191     
09192   MATCH_label_a23: (void)0; /*placeholder for label*/ 
09193     { 
09194       char *name = MATCH_name;
09195       unsigned eax = addressToPC(MATCH_p);
09196       unsigned x = 2 + addressToPC(MATCH_p);
09197       
09198       #line 467 "machine/mc68k/decoder_low.m"
09199        { 
09200 
09201                   chopDotex(name);
09202 
09203                   RTs = instantiate (pc, sslName, daEAX (eax, x, result, pc, 16)); 
09204 
09205               }
09206 
09207       
09208 
09209       
09210       
09211       
09212     } 
09213     goto MATCH_finished_a; 
09214     
09215   MATCH_label_a24: (void)0; /*placeholder for label*/ 
09216     { 
09217       char *name = MATCH_name;
09218       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
09219       
09220       #line 504 "machine/mc68k/decoder_low.m"
09221        { 
09222 
09223               // _reg2only is  extw | extl | swap
09224 
09225               // extbl is 68020 specific
09226 
09227                   chopDotex(name);
09228 
09229                   int siz = 16;
09230 
09231                   if (sslName[3] == 'l') siz = 32;
09232 
09233                   RTs = instantiate (pc, sslName, DIS_DN(siz)); 
09234 
09235               }
09236 
09237       
09238 
09239       
09240       
09241       
09242     } 
09243     goto MATCH_finished_a; 
09244     
09245   MATCH_label_a25: (void)0; /*placeholder for label*/ 
09246     { 
09247       char *name = MATCH_name;
09248       unsigned ea = addressToPC(MATCH_p);
09249       
09250       #line 485 "machine/mc68k/decoder_low.m"
09251        { 
09252 
09253               // _oneEAc   is  jsr | jmp | pea    
09254 
09255                   strcpy(sslName, name);
09256 
09257                   sslName[3] = '\0'; 
09258 
09259                   RTs = instantiate (pc, sslName, cEA (ea, pc, 32)); 
09260 
09261               }
09262 
09263       
09264 
09265       
09266       
09267       
09268     } 
09269     goto MATCH_finished_a; 
09270     
09271   MATCH_label_a26: (void)0; /*placeholder for label*/ 
09272     { 
09273       char *name = MATCH_name;
09274       unsigned eax = addressToPC(MATCH_p);
09275       unsigned x = 2 + addressToPC(MATCH_p);
09276       
09277       #line 492 "machine/mc68k/decoder_low.m"
09278        { 
09279 
09280                   strcpy(sslName, name);
09281 
09282                   sslName[3] = '\0';
09283 
09284                   RTs = instantiate (pc, sslName,
09285 
09286                       cEAX (eax, x, result, pc, delta, 32)); 
09287 
09288               } 
09289 
09290       
09291 
09292       
09293       
09294       
09295     } 
09296     goto MATCH_finished_a; 
09297     
09298   MATCH_label_a27: (void)0; /*placeholder for label*/ 
09299     { 
09300       unsigned d4 = (MATCH_w_16_0 & 0xf) /* vect at 0 */;
09301       
09302       #line 541 "machine/mc68k/decoder_low.m"
09303        {
09304 
09305               // Trap: as far as Palm Pilots are concerned, these are NOPs, except
09306 
09307               // that an A-line instruction can then legally follow
09308 
09309                   RTs = instantiate(pc, "NOP");
09310 
09311                   IsTrap = true;
09312 
09313                   assert(d4 == d4);       // Suppress unused var warning
09314 
09315               }
09316 
09317       
09318 
09319       
09320       
09321       
09322     } 
09323     goto MATCH_finished_a; 
09324     
09325   MATCH_label_a28: (void)0; /*placeholder for label*/ 
09326     { 
09327       char *name = MATCH_name;
09328       
09329       #line 513 "machine/mc68k/decoder_low.m"
09330        { 
09331 
09332               // _noArg is illegal | reset | nop | rte | rts | trapv | rtr
09333 
09334                   RTs = instantiate (pc, name); 
09335 
09336               // MOVE to/from SR is priveleged
09337 
09338               } 
09339 
09340       
09341 
09342       
09343       
09344       
09345     } 
09346     goto MATCH_finished_a; 
09347     
09348   MATCH_label_a29: (void)0; /*placeholder for label*/ 
09349     { 
09350       char *name = MATCH_name;
09351       unsigned ea = addressToPC(MATCH_p);
09352       
09353       #line 472 "machine/mc68k/decoder_low.m"
09354        { 
09355 
09356                   int bump = 0, bumpr;
09357 
09358                   chopDotex(name);
09359 
09360                   RTs = instantiate (pc, sslName, daEA (ea, pc, bump, bumpr, 32));
09361 
09362                   ADDBUMP;
09363 
09364               }
09365 
09366       
09367 
09368       
09369       
09370       
09371     } 
09372     goto MATCH_finished_a; 
09373     
09374   MATCH_label_a30: (void)0; /*placeholder for label*/ 
09375     { 
09376       unsigned ea = addressToPC(MATCH_p);
09377       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09378       
09379       #line 556 "machine/mc68k/decoder_low.m"
09380        { 
09381 
09382               // MOVEA -- These are any moves where the destination is an address reg
09383 
09384               // MOVEM rm means registers to memory
09385 
09386               // HACK! This requires work! Need to bump after EACH register has been
09387 
09388               // moved! Mostly, these will be in prologues/epilogues
09389 
09390                   int bump = 0, bumpr;
09391 
09392                   RTs = instantiate (pc, "storem.w", DIS_I16,
09393 
09394                       rmEA (ea, pc, bump, bumpr, 16));
09395 
09396                   result.numBytes += 2; 
09397 
09398                   ADDBUMP;
09399 
09400               }   
09401 
09402       
09403 
09404       
09405       
09406       
09407     } 
09408     goto MATCH_finished_a; 
09409     
09410   MATCH_label_a31: (void)0; /*placeholder for label*/ 
09411     { 
09412       unsigned ea = addressToPC(MATCH_p);
09413       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09414       
09415       #line 574 "machine/mc68k/decoder_low.m"
09416        {
09417 
09418               // HACK! Requires work
09419 
09420                   int bump = 0, bumpr;
09421 
09422                   RTs = instantiate (pc, "loadm.w", DIS_I16,
09423 
09424                       mrEA (ea, pc, bump, bumpr, 16));
09425 
09426                   result.numBytes += 2;
09427 
09428                   ADDBUMP;
09429 
09430               }
09431 
09432       
09433 
09434       
09435       
09436       
09437     } 
09438     goto MATCH_finished_a; 
09439     
09440   MATCH_label_a32: (void)0; /*placeholder for label*/ 
09441     { 
09442       char *name = MATCH_name;
09443       unsigned eax = addressToPC(MATCH_p);
09444       unsigned x = 2 + addressToPC(MATCH_p);
09445       
09446       #line 479 "machine/mc68k/decoder_low.m"
09447        { 
09448 
09449                   chopDotex(name);
09450 
09451                   RTs = instantiate (pc, sslName,
09452 
09453                       daEAX (eax, x, result, pc, 32));
09454 
09455               }
09456 
09457       
09458 
09459       
09460       
09461       
09462     } 
09463     goto MATCH_finished_a; 
09464     
09465   MATCH_label_a33: (void)0; /*placeholder for label*/ 
09466     { 
09467       unsigned eax = addressToPC(MATCH_p);
09468       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09469       unsigned x = 4 + addressToPC(MATCH_p);
09470       
09471       #line 568 "machine/mc68k/decoder_low.m"
09472        { 
09473 
09474                   RTs = instantiate (pc, "storem.w", DIS_I16, 
09475 
09476                       rmEAX (eax, x, result, pc, 16)); 
09477 
09478                   result.numBytes += 2; 
09479 
09480               }  
09481 
09482       
09483 
09484       
09485       
09486       
09487     } 
09488     goto MATCH_finished_a; 
09489     
09490   MATCH_label_a34: (void)0; /*placeholder for label*/ 
09491     { 
09492       unsigned eax = addressToPC(MATCH_p);
09493       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09494       unsigned x = 4 + addressToPC(MATCH_p);
09495       
09496       #line 583 "machine/mc68k/decoder_low.m"
09497        {
09498 
09499                   RTs = instantiate (pc, "loadm.w", DIS_I16, 
09500 
09501                       mrEAX (eax, x, result, pc, delta, 16)); 
09502 
09503                   result.numBytes += 2; 
09504 
09505               }  
09506 
09507       
09508 
09509       
09510       
09511       
09512     } 
09513     goto MATCH_finished_a; 
09514     
09515   MATCH_label_a35: (void)0; /*placeholder for label*/ 
09516     { 
09517       char *name = MATCH_name;
09518       unsigned ea = addressToPC(MATCH_p);
09519       
09520       #line 531 "machine/mc68k/decoder_low.m"
09521        {
09522 
09523                   int bump = 0, bumpr;
09524 
09525                   RTs = instantiate (pc, name, daEA(ea, pc, bump, bumpr, 16));
09526 
09527                   ADDBUMP;
09528 
09529               }
09530 
09531       
09532 
09533       
09534       
09535       
09536     } 
09537     goto MATCH_finished_a; 
09538     
09539   MATCH_label_a36: (void)0; /*placeholder for label*/ 
09540     { 
09541       char *name = MATCH_name;
09542       unsigned eax = addressToPC(MATCH_p);
09543       unsigned x = 2 + addressToPC(MATCH_p);
09544       
09545       #line 537 "machine/mc68k/decoder_low.m"
09546        {
09547 
09548                   RTs = instantiate (pc, name, daEAX(eax, x, result, pc, 16));
09549 
09550               }
09551 
09552       
09553 
09554       
09555       
09556       
09557     } 
09558     goto MATCH_finished_a; 
09559     
09560   MATCH_label_a37: (void)0; /*placeholder for label*/ 
09561     { 
09562       char *name = MATCH_name;
09563       unsigned ea = addressToPC(MATCH_p);
09564       
09565       #line 519 "machine/mc68k/decoder_low.m"
09566        {
09567 
09568               // MOVE to/from CCR
09569 
09570                   int bump = 0, bumpr;
09571 
09572                   RTs = instantiate (pc, name, dWEA(ea, pc, bump, bumpr, 16));
09573 
09574                   ADDBUMP;
09575 
09576               }
09577 
09578       
09579 
09580       
09581       
09582       
09583     } 
09584     goto MATCH_finished_a; 
09585     
09586   MATCH_label_a38: (void)0; /*placeholder for label*/ 
09587     { 
09588       char *name = MATCH_name;
09589       unsigned eax = addressToPC(MATCH_p);
09590       unsigned x = 2 + addressToPC(MATCH_p);
09591       
09592       #line 526 "machine/mc68k/decoder_low.m"
09593        {
09594 
09595                   RTs = instantiate (pc, name,
09596 
09597                       dWEAX(eax, x, result, pc, delta, 16));
09598 
09599               }
09600 
09601       
09602 
09603       
09604       
09605       
09606     } 
09607     goto MATCH_finished_a; 
09608     
09609   MATCH_label_a39: (void)0; /*placeholder for label*/ 
09610     { 
09611       unsigned eax = addressToPC(MATCH_p);
09612       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09613       unsigned x = 4 + addressToPC(MATCH_p);
09614       
09615       #line 598 "machine/mc68k/decoder_low.m"
09616        { 
09617 
09618                   RTs = instantiate (pc, "storem.l", DIS_I16, 
09619 
09620                       rmEAX(eax, x, result, pc, 32));
09621 
09622                   result.numBytes += 2; 
09623 
09624               }   
09625 
09626       
09627 
09628       
09629       
09630       
09631     } 
09632     goto MATCH_finished_a; 
09633     
09634   MATCH_label_a40: (void)0; /*placeholder for label*/ 
09635     { 
09636       unsigned eax = addressToPC(MATCH_p);
09637       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09638       unsigned x = 4 + addressToPC(MATCH_p);
09639       
09640       #line 613 "machine/mc68k/decoder_low.m"
09641        {
09642 
09643                   RTs = instantiate (pc, "loadm.l", DIS_I16, 
09644 
09645                           mrEAX(eax, x, result, pc, delta, 32));
09646 
09647                   result.numBytes += 2; 
09648 
09649               }   
09650 
09651       
09652 
09653       
09654       
09655       
09656     } 
09657     goto MATCH_finished_a; 
09658     
09659   MATCH_label_a41: (void)0; /*placeholder for label*/ 
09660     { 
09661       char *name = MATCH_name;
09662       unsigned ea = addressToPC(MATCH_p);
09663       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09664       
09665       #line 837 "machine/mc68k/decoder_low.m"
09666        {
09667 
09668                   int bump = 0, bumpr;
09669 
09670                   chop2ndLast(name);
09671 
09672                   RTs = instantiate (pc, sslName, dEA(ea, pc, bump, bumpr, 16),
09673 
09674                       DIS_DN(16));
09675 
09676                   ADDBUMP;
09677 
09678               }
09679 
09680       
09681 
09682       
09683       
09684       
09685     } 
09686     goto MATCH_finished_a; 
09687     
09688   MATCH_label_a42: (void)0; /*placeholder for label*/ 
09689     { 
09690       char *name = MATCH_name;
09691       unsigned eax = addressToPC(MATCH_p);
09692       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09693       unsigned x = 2 + addressToPC(MATCH_p);
09694       
09695       #line 845 "machine/mc68k/decoder_low.m"
09696        {
09697 
09698                   chopBoth(name);
09699 
09700                   RTs = instantiate (pc, sslName,
09701 
09702                       dEAX(eax, x, result, pc, delta, 16), DIS_DN(16));
09703 
09704               }
09705 
09706       
09707 
09708       
09709       
09710       
09711     } 
09712     goto MATCH_finished_a; 
09713     
09714   MATCH_label_a43: (void)0; /*placeholder for label*/ 
09715     { 
09716       unsigned eax = addressToPC(MATCH_p);
09717       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09718       unsigned x = 2 + addressToPC(MATCH_p);
09719       
09720       #line 624 "machine/mc68k/decoder_low.m"
09721        { 
09722 
09723                   RTs = instantiate (pc, "lea",
09724 
09725                       cEAX (eax, x, result, pc, delta, 32), DIS_AN); 
09726 
09727               }
09728 
09729       
09730 
09731       
09732       
09733       
09734     } 
09735     goto MATCH_finished_a; 
09736     
09737   MATCH_label_a44: (void)0; /*placeholder for label*/ 
09738     { 
09739       char *name = MATCH_name;
09740       unsigned ea = addressToPC(MATCH_p);
09741       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09742       
09743       #line 629 "machine/mc68k/decoder_low.m"
09744        { 
09745 
09746               // ADDQ, SUBQ     
09747 
09748               // The data parameter is 3 bits (d3) but a byte will be returned anyway
09749 
09750                   int bump = 0, bumpr;
09751 
09752                   chop2ndLast(name);          // addqb -> addb
09753 
09754                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09755 
09756                   RTs = instantiate (pc, sslName, DIS_I8, alEA (ea, pc, bump, bumpr, 8)); 
09757 
09758                   ADDBUMP;
09759 
09760               }
09761 
09762       
09763 
09764       
09765       
09766       
09767     } 
09768     goto MATCH_finished_a; 
09769     
09770   MATCH_label_a45: (void)0; /*placeholder for label*/ 
09771     { 
09772       char *name = MATCH_name;
09773       unsigned eax = addressToPC(MATCH_p);
09774       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09775       unsigned x = 2 + addressToPC(MATCH_p);
09776       
09777       #line 639 "machine/mc68k/decoder_low.m"
09778        { 
09779 
09780                   chopBoth(name);             // addqb.ex -> addb
09781 
09782                   sslName[3] = '\0'; 
09783 
09784                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09785 
09786                   RTs = instantiate (pc, sslName, DIS_I8, alEAX (eax, x, result, pc, 8));
09787 
09788               }
09789 
09790       
09791 
09792       
09793       
09794       
09795     } 
09796     goto MATCH_finished_a; 
09797     
09798   MATCH_label_a46: (void)0; /*placeholder for label*/ 
09799     { 
09800       char *name = MATCH_name;
09801       unsigned ea = addressToPC(MATCH_p);
09802       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09803       
09804       #line 646 "machine/mc68k/decoder_low.m"
09805        { 
09806 
09807                   int bump = 0, bumpr;
09808 
09809                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09810 
09811                   SemStr* dst = alEA (ea, pc, bump, bumpr, 16);
09812 
09813                   bool b = (dst->getFirstIdx() == idRegOf) && 
09814 
09815                       (dst->getSecondIdx() == idIntConst) && 
09816 
09817                       (dst->getThirdIdx() >= 8);
09818 
09819                   if (b) {
09820 
09821                       // We have addq/subq to an address register. These do not
09822 
09823                       // affect the flags (all others do). Also, the instruction
09824 
09825                       // is always 32 bits. So we give it a different SSL name
09826 
09827                       strcpy(sslName, name);
09828 
09829                       sslName[3] = '\0';
09830 
09831                       strcat(sslName, "qa");     // addqw -> addqa
09832 
09833                   }
09834 
09835                   if (!b)                         // Can't use else
09836 
09837                       chop2ndLast(name);          // addqw -> addw
09838 
09839                   RTs = instantiate (pc, sslName, DIS_I8, dst); 
09840 
09841                   ADDBUMP;
09842 
09843               } 
09844 
09845       
09846 
09847       
09848       
09849       
09850     } 
09851     goto MATCH_finished_a; 
09852     
09853   MATCH_label_a47: (void)0; /*placeholder for label*/ 
09854     { 
09855       char *name = MATCH_name;
09856       unsigned eax = addressToPC(MATCH_p);
09857       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09858       unsigned x = 2 + addressToPC(MATCH_p);
09859       
09860       #line 667 "machine/mc68k/decoder_low.m"
09861        { 
09862 
09863                   chopBoth(name);             // addqb.ex -> addb
09864 
09865                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09866 
09867                   RTs = instantiate (pc, sslName, DIS_I8,
09868 
09869                       alEAX (eax, x, result, pc, 16)); 
09870 
09871               } 
09872 
09873       
09874 
09875       
09876       
09877       
09878     } 
09879     goto MATCH_finished_a; 
09880     
09881   MATCH_label_a48: (void)0; /*placeholder for label*/ 
09882     { 
09883       char *name = MATCH_name;
09884       unsigned ea = addressToPC(MATCH_p);
09885       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09886       
09887       #line 674 "machine/mc68k/decoder_low.m"
09888        { 
09889 
09890                   int bump = 0, bumpr;
09891 
09892                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09893 
09894                   SemStr* dst = alEA (ea, pc, bump, bumpr, 32);
09895 
09896                   bool b = (dst->getFirstIdx() == idRegOf) && 
09897 
09898                       (dst->getSecondIdx() == idIntConst) && 
09899 
09900                       (dst->getThirdIdx() >= 8);
09901 
09902                   if (b) {
09903 
09904                       // We have addq/subq to an address register. These do not
09905 
09906                       // affect the flags (all others do). So we give it a different
09907 
09908                       // SSL name
09909 
09910                       strcpy(sslName, name);
09911 
09912                       sslName[3] = '\0';
09913 
09914                       strcat(sslName, "qa");      // subl -> subqa
09915 
09916                   }
09917 
09918                   if (!b)                         // Can't use else
09919 
09920                       chop2ndLast(name);          // addqw -> addw
09921 
09922                   RTs = instantiate (pc, sslName, DIS_I8, dst); 
09923 
09924                   ADDBUMP;
09925 
09926               }   
09927 
09928       
09929 
09930       
09931       
09932       
09933     } 
09934     goto MATCH_finished_a; 
09935     
09936   MATCH_label_a49: (void)0; /*placeholder for label*/ 
09937     { 
09938       char *name = MATCH_name;
09939       unsigned eax = addressToPC(MATCH_p);
09940       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
09941       unsigned x = 2 + addressToPC(MATCH_p);
09942       
09943       #line 695 "machine/mc68k/decoder_low.m"
09944        { 
09945 
09946                   chopBoth(name);             // addql.ex -> addl
09947 
09948                   if (i8 == 0) i8 = 8;        // Quirk of the addq/subq instr
09949 
09950                   RTs = instantiate (pc, sslName, DIS_I8, alEAX (eax, x, result, pc, 32));
09951 
09952               }   
09953 
09954       
09955 
09956       
09957       
09958       
09959     } 
09960     goto MATCH_finished_a; 
09961     
09962   MATCH_label_a50: (void)0; /*placeholder for label*/ 
09963     { 
09964       char *name = MATCH_name;
09965       unsigned ea = addressToPC(MATCH_p);
09966       
09967       #line 707 "machine/mc68k/decoder_low.m"
09968        { 
09969 
09970               // Scc
09971 
09972               // I assume that these are 8 bits where memory is involved, but
09973 
09974               // 32 where registers are involved
09975 
09976                   int bump = 0, bumpr;
09977 
09978                   RTs = instantiate (pc, name, daEA (ea, pc, bump, bumpr, 8));
09979 
09980                   ADDBUMP;
09981 
09982               }
09983 
09984       
09985 
09986       
09987       
09988       
09989     } 
09990     goto MATCH_finished_a; 
09991     
09992   MATCH_label_a51: (void)0; /*placeholder for label*/ 
09993     { 
09994       char *name = MATCH_name;
09995       unsigned i16 = (MATCH_w_16_16 & 0xffff) /* d16 at 16 */;
09996       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
09997       
09998       #line 701 "machine/mc68k/decoder_low.m"
09999        { 
10000 
10001               // DBcc     
10002 
10003                   RTs = instantiate (pc, name, DIS_DN(32), DIS_I16); 
10004 
10005                   result.numBytes += 2; 
10006 
10007               }
10008 
10009           
10010 
10011       
10012       
10013       
10014     } 
10015     goto MATCH_finished_a; 
10016     
10017   MATCH_label_a52: (void)0; /*placeholder for label*/ 
10018     { 
10019       char *name = MATCH_name;
10020       unsigned eax = addressToPC(MATCH_p);
10021       unsigned x = 2 + addressToPC(MATCH_p);
10022       
10023       #line 716 "machine/mc68k/decoder_low.m"
10024        { 
10025 
10026                   RTs = instantiate (pc, name, daEAX (eax, x, result, pc, 8));
10027 
10028               } 
10029 
10030       
10031 
10032           
10033 
10034       
10035       
10036       
10037     } 
10038     goto MATCH_finished_a; 
10039     
10040   MATCH_label_a53: (void)0; /*placeholder for label*/ 
10041     { 
10042       char *name = MATCH_name;
10043       unsigned ea = addressToPC(MATCH_p);
10044       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10045       
10046       #line 823 "machine/mc68k/decoder_low.m"
10047        {
10048 
10049               // _alurdB  is  andrb | orrb
10050 
10051                   int bump = 0, bumpr;
10052 
10053                   chop2ndLast(name);
10054 
10055                   RTs = instantiate (pc, sslName, dEA(ea, pc, bump, bumpr, 8), DIS_DN(8));
10056 
10057                   ADDBUMP;
10058 
10059               }
10060 
10061       
10062 
10063       
10064       
10065       
10066     } 
10067     goto MATCH_finished_a; 
10068     
10069   MATCH_label_a54: (void)0; /*placeholder for label*/ 
10070     { 
10071       char *name = MATCH_name;
10072       unsigned ea = addressToPC(MATCH_p);
10073       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10074       
10075       #line 851 "machine/mc68k/decoder_low.m"
10076        {
10077 
10078                   int bump = 0, bumpr;
10079 
10080                   chop2ndLast(name);
10081 
10082                   RTs = instantiate (pc, sslName, dEA(ea, pc, bump, bumpr, 32), DIS_DN(32));
10083 
10084                   ADDBUMP;
10085 
10086               }
10087 
10088       
10089 
10090       
10091       
10092       
10093     } 
10094     goto MATCH_finished_a; 
10095     
10096   MATCH_label_a55: (void)0; /*placeholder for label*/ 
10097     { 
10098       char *name = MATCH_name;
10099       unsigned ea = addressToPC(MATCH_p);
10100       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10101       
10102       #line 739 "machine/mc68k/decoder_low.m"
10103        { 
10104 
10105               // _alurdw is divs | divu | muls | mulu
10106 
10107               //// in order for this to match, the 'w' needs to be dropped off the
10108 
10109               //// SSL names DIVUw and MUL[idx]w
10110 
10111                   int bump = 0, bumpr;
10112 
10113                   RTs = instantiate (pc, name, dWEA (ea, pc, bump, bumpr, 16), DIS_DN(16)); 
10114 
10115                   ADDBUMP;
10116 
10117               }   
10118 
10119       
10120 
10121       
10122       
10123       
10124     } 
10125     goto MATCH_finished_a; 
10126     
10127   MATCH_label_a56: (void)0; /*placeholder for label*/ 
10128     { 
10129       char *name = MATCH_name;
10130       unsigned eax = addressToPC(MATCH_p);
10131       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10132       unsigned x = 2 + addressToPC(MATCH_p);
10133       
10134       #line 831 "machine/mc68k/decoder_low.m"
10135        {
10136 
10137                   chopBoth(name);
10138 
10139                   RTs = instantiate (pc, sslName,
10140 
10141                       dEAX(eax, x, result, pc, delta, 8), DIS_DN(8));
10142 
10143               }
10144 
10145       
10146 
10147       
10148       
10149       
10150     } 
10151     goto MATCH_finished_a; 
10152     
10153   MATCH_label_a57: (void)0; /*placeholder for label*/ 
10154     { 
10155       char *name = MATCH_name;
10156       unsigned eax = addressToPC(MATCH_p);
10157       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10158       unsigned x = 2 + addressToPC(MATCH_p);
10159       
10160       #line 858 "machine/mc68k/decoder_low.m"
10161        {
10162 
10163                   chopBoth(name);
10164 
10165                   RTs = instantiate (pc, sslName,
10166 
10167                       dEAX(eax, x, result, pc, delta, 32), DIS_DN(32));
10168 
10169               }
10170 
10171       
10172 
10173       
10174 
10175       
10176       
10177       
10178     } 
10179     goto MATCH_finished_a; 
10180     
10181   MATCH_label_a58: (void)0; /*placeholder for label*/ 
10182     { 
10183       char *name = MATCH_name;
10184       unsigned eax = addressToPC(MATCH_p);
10185       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10186       unsigned x = 2 + addressToPC(MATCH_p);
10187       
10188       #line 748 "machine/mc68k/decoder_low.m"
10189        { 
10190 
10191                   RTs = instantiate (pc, name,
10192 
10193                       dWEAX (eax, x, result, pc, delta, 16), DIS_DN(16)); 
10194 
10195               }
10196 
10197       
10198 
10199       
10200       
10201       
10202     } 
10203     goto MATCH_finished_a; 
10204     
10205   MATCH_label_a59: (void)0; /*placeholder for label*/ 
10206     { 
10207       char *name = MATCH_name;
10208       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10209       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10210       
10211       #line 753 "machine/mc68k/decoder_low.m"
10212        {
10213 
10214               // _twoReg** (addx | subx | abcd | sbcd | cmp) 
10215 
10216                   strcpy(sslName, name);
10217 
10218                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10219 
10220                   sslName[4] = '\0';
10221 
10222                   strcat(sslName, "b");         // Force 8 bit size
10223 
10224                   RTs = instantiate (pc, sslName, DIS_DN(8), DIS_DN2(8));
10225 
10226               } 
10227 
10228       
10229 
10230       
10231       
10232       
10233     } 
10234     goto MATCH_finished_a; 
10235     
10236   MATCH_label_a60: (void)0; /*placeholder for label*/ 
10237     { 
10238       char *name = MATCH_name;
10239       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10240       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10241       
10242       #line 762 "machine/mc68k/decoder_low.m"
10243        {
10244 
10245                   int bump = 0, bumpr;
10246 
10247                   strcpy(sslName, name);
10248 
10249                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10250 
10251                   sslName[4] = '\0';
10252 
10253                   strcat(sslName, "b");         // Force 8 bit size
10254 
10255                   SemStr* t1;
10256 
10257                   RT* rt = assignTemp(pPreDec(n, bump, bumpr, 8), 8, t1);
10258 
10259                   ADDBUMP;
10260 
10261                   bump = 0;
10262 
10263                   RTs = instantiate (pc, sslName, t1, pPreDec(n2, bump, bumpr, 8));
10264 
10265                   RTs->insert(RTs->begin(), rt);
10266 
10267                   ADDBUMP;
10268 
10269               } 
10270 
10271       
10272 
10273       
10274       
10275       
10276     } 
10277     goto MATCH_finished_a; 
10278     
10279   MATCH_label_a61: (void)0; /*placeholder for label*/ 
10280     { 
10281       char *name = MATCH_name;
10282       unsigned ea = addressToPC(MATCH_p);
10283       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10284       
10285       #line 865 "machine/mc68k/decoder_low.m"
10286        {
10287 
10288               // _alumB   is  addmb | andmb | ormb  | submb
10289 
10290                   int bump = 0, bumpr;
10291 
10292                   chop2ndLast(name);
10293 
10294                   RTs = instantiate (pc, sslName, DIS_DN(8), maEA(ea, pc, bump, bumpr, 8));
10295 
10296                   ADDBUMP;
10297 
10298               }
10299 
10300       
10301 
10302       
10303       
10304       
10305     } 
10306     goto MATCH_finished_a; 
10307     
10308   MATCH_label_a62: (void)0; /*placeholder for label*/ 
10309     { 
10310       char *name = MATCH_name;
10311       unsigned eax = addressToPC(MATCH_p);
10312       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10313       unsigned x = 2 + addressToPC(MATCH_p);
10314       
10315       #line 873 "machine/mc68k/decoder_low.m"
10316        {
10317 
10318                   chopBoth(name);
10319 
10320                   RTs = instantiate (pc, sslName, DIS_DN(8),
10321 
10322                       maEAX(eax, x, result, pc, 8));
10323 
10324               }
10325 
10326       
10327 
10328       
10329       
10330       
10331     } 
10332     goto MATCH_finished_a; 
10333     
10334   MATCH_label_a63: (void)0; /*placeholder for label*/ 
10335     { 
10336       char *name = MATCH_name;
10337       unsigned ea = addressToPC(MATCH_p);
10338       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10339       
10340       #line 879 "machine/mc68k/decoder_low.m"
10341        {
10342 
10343                   int bump = 0, bumpr;
10344 
10345                   chop2ndLast(name);
10346 
10347                   RTs = instantiate (pc, sslName, DIS_DN(16), maEA(ea, pc, bump, bumpr,
10348 
10349                       16));
10350 
10351                   ADDBUMP;
10352 
10353               }
10354 
10355       
10356 
10357       
10358       
10359       
10360     } 
10361     goto MATCH_finished_a; 
10362     
10363   MATCH_label_a64: (void)0; /*placeholder for label*/ 
10364     { 
10365       char *name = MATCH_name;
10366       unsigned eax = addressToPC(MATCH_p);
10367       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10368       unsigned x = 2 + addressToPC(MATCH_p);
10369       
10370       #line 887 "machine/mc68k/decoder_low.m"
10371        {
10372 
10373                   chopBoth(name);
10374 
10375                   RTs = instantiate (pc, sslName, DIS_DN(16),
10376 
10377                       maEAX(eax, x, result, pc, 16));
10378 
10379               }
10380 
10381       
10382 
10383       
10384       
10385       
10386     } 
10387     goto MATCH_finished_a; 
10388     
10389   MATCH_label_a65: (void)0; /*placeholder for label*/ 
10390     { 
10391       char *name = MATCH_name;
10392       unsigned ea = addressToPC(MATCH_p);
10393       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10394       
10395       #line 893 "machine/mc68k/decoder_low.m"
10396        {
10397 
10398                   int bump = 0, bumpr;
10399 
10400                   chop2ndLast(name);
10401 
10402                   RTs = instantiate (pc, sslName, DIS_DN(32), maEA(ea, pc, bump, bumpr,
10403 
10404                       32));
10405 
10406                   ADDBUMP;
10407 
10408               }
10409 
10410       
10411 
10412       
10413       
10414       
10415     } 
10416     goto MATCH_finished_a; 
10417     
10418   MATCH_label_a66: (void)0; /*placeholder for label*/ 
10419     { 
10420       char *name = MATCH_name;
10421       unsigned eax = addressToPC(MATCH_p);
10422       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10423       unsigned x = 2 + addressToPC(MATCH_p);
10424       
10425       #line 901 "machine/mc68k/decoder_low.m"
10426        {
10427 
10428                   chopBoth(name);
10429 
10430                   RTs = instantiate (pc, sslName, DIS_DN(32),
10431 
10432                       maEAX(eax, x, result, pc, 32));
10433 
10434               }
10435 
10436       
10437 
10438       
10439 
10440       
10441 
10442       
10443       
10444       
10445     } 
10446     goto MATCH_finished_a; 
10447     
10448   MATCH_label_a67: (void)0; /*placeholder for label*/ 
10449     { 
10450       char *name = MATCH_name;
10451       unsigned ea = addressToPC(MATCH_p);
10452       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10453       
10454       #line 983 "machine/mc68k/decoder_low.m"
10455        {
10456 
10457               // ADD, AND, CHK, CMP, CMPA, DIVS, DIVU, MULS, MULU, OR, SUB, SUBA
10458 
10459                   int bump = 0, bumpr;
10460 
10461                   chopDotex(name);           // Fix the name
10462 
10463                   RTs = instantiate (pc, sslName, amEA(ea, pc, bump, bumpr, 8), DIS_DN(8));
10464 
10465                   ADDBUMP;
10466 
10467               }
10468 
10469       
10470 
10471       
10472       
10473       
10474     } 
10475     goto MATCH_finished_a; 
10476     
10477   MATCH_label_a68: (void)0; /*placeholder for label*/ 
10478     { 
10479       char *name = MATCH_name;
10480       unsigned eax = addressToPC(MATCH_p);
10481       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10482       unsigned x = 2 + addressToPC(MATCH_p);
10483       
10484       #line 991 "machine/mc68k/decoder_low.m"
10485        {
10486 
10487                   chopDotex(name);           // Fix the name
10488 
10489                   RTs = instantiate (pc, sslName,
10490 
10491                       amEAX(eax, x, result, pc, delta, 8), DIS_DN(8));
10492 
10493               }
10494 
10495           
10496 
10497       
10498       
10499       
10500     } 
10501     goto MATCH_finished_a; 
10502     
10503   MATCH_label_a69: (void)0; /*placeholder for label*/ 
10504     { 
10505       char *name = MATCH_name;
10506       unsigned ea = addressToPC(MATCH_p);
10507       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10508       
10509       #line 997 "machine/mc68k/decoder_low.m"
10510        {
10511 
10512                   int bump = 0, bumpr;
10513 
10514                   chopDotex(name);           // Fix the name
10515 
10516                   RTs = instantiate (pc, sslName, amEA(ea, pc, bump, bumpr, 16),
10517 
10518                       DIS_DN(16));
10519 
10520                   ADDBUMP;
10521 
10522               }
10523 
10524       
10525 
10526       
10527       
10528       
10529     } 
10530     goto MATCH_finished_a; 
10531     
10532   MATCH_label_a70: (void)0; /*placeholder for label*/ 
10533     { 
10534       char *name = MATCH_name;
10535       unsigned eax = addressToPC(MATCH_p);
10536       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10537       unsigned x = 2 + addressToPC(MATCH_p);
10538       
10539       #line 1005 "machine/mc68k/decoder_low.m"
10540        {
10541 
10542                   chopDotex(name);           // Fix the name
10543 
10544                   RTs = instantiate (pc, sslName,
10545 
10546                       amEAX(eax, x, result, pc, delta, 16), DIS_DN(16));
10547 
10548               }
10549 
10550       
10551 
10552       
10553       
10554       
10555     } 
10556     goto MATCH_finished_a; 
10557     
10558   MATCH_label_a71: (void)0; /*placeholder for label*/ 
10559     { 
10560       char *name = MATCH_name;
10561       unsigned ea = addressToPC(MATCH_p);
10562       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10563       
10564       #line 1011 "machine/mc68k/decoder_low.m"
10565        {
10566 
10567                   int bump = 0, bumpr;
10568 
10569                   chopDotex(name);           // Fix the name
10570 
10571                   RTs = instantiate (pc, sslName, amEA(ea, pc, bump, bumpr, 32),
10572 
10573                       DIS_DN(32));
10574 
10575                   ADDBUMP;
10576 
10577               }
10578 
10579       
10580 
10581       
10582       
10583       
10584     } 
10585     goto MATCH_finished_a; 
10586     
10587   MATCH_label_a72: (void)0; /*placeholder for label*/ 
10588     { 
10589       char *name = MATCH_name;
10590       unsigned eax = addressToPC(MATCH_p);
10591       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10592       unsigned x = 2 + addressToPC(MATCH_p);
10593       
10594       #line 1019 "machine/mc68k/decoder_low.m"
10595        {
10596 
10597                   chopDotex(name);           // Fix the name
10598 
10599                   RTs = instantiate (pc, sslName,
10600 
10601                       amEAX(eax, x, result, pc, delta, 32), DIS_DN(32));
10602 
10603               }
10604 
10605       
10606 
10607       
10608 
10609       
10610       
10611       
10612     } 
10613     goto MATCH_finished_a; 
10614     
10615   MATCH_label_a73: (void)0; /*placeholder for label*/ 
10616     { 
10617       char *name = MATCH_name;
10618       unsigned ea = addressToPC(MATCH_p);
10619       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10620       
10621       #line 909 "machine/mc68k/decoder_low.m"
10622        {
10623 
10624               // _aluaW   is  addaw | cmpaw | subaw 
10625 
10626                   int bump = 0, bumpr;
10627 
10628                   chop2ndLast(name);
10629 
10630                   RTs = instantiate (pc, sslName, awlEA(ea, pc, bump, bumpr, 16), DIS_AN);
10631 
10632                   ADDBUMP;
10633 
10634               }
10635 
10636       
10637 
10638       
10639       
10640       
10641     } 
10642     goto MATCH_finished_a; 
10643     
10644   MATCH_label_a74: (void)0; /*placeholder for label*/ 
10645     { 
10646       char *name = MATCH_name;
10647       unsigned eax = addressToPC(MATCH_p);
10648       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10649       unsigned x = 2 + addressToPC(MATCH_p);
10650       
10651       #line 917 "machine/mc68k/decoder_low.m"
10652        {
10653 
10654                   chopBoth(name);
10655 
10656                   RTs = instantiate(pc, sslName,
10657 
10658                       awlEAX(eax, x, result, pc, delta, 16), DIS_AN);
10659 
10660               }
10661 
10662       
10663 
10664       
10665       
10666       
10667     } 
10668     goto MATCH_finished_a; 
10669     
10670   MATCH_label_a75: (void)0; /*placeholder for label*/ 
10671     { 
10672       char *name = MATCH_name;
10673       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10674       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10675       
10676       #line 777 "machine/mc68k/decoder_low.m"
10677        {
10678 
10679                   strcpy(sslName, name);
10680 
10681                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10682 
10683                   sslName[4] = '\0';
10684 
10685                   strcat(name, "w");         // Force 16 bit size
10686 
10687                   RTs = instantiate (pc, sslName, DIS_DN(16), DIS_DN2(16));
10688 
10689               } 
10690 
10691       
10692 
10693       
10694       
10695       
10696     } 
10697     goto MATCH_finished_a; 
10698     
10699   MATCH_label_a76: (void)0; /*placeholder for label*/ 
10700     { 
10701       char *name = MATCH_name;
10702       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10703       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10704       
10705       #line 785 "machine/mc68k/decoder_low.m"
10706        {
10707 
10708                   int bump = 0, bumpr;
10709 
10710                   strcpy(sslName, name);
10711 
10712                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10713 
10714                   sslName[4] = '\0';
10715 
10716                   strcat(sslName, "w");         // Force 16 bit size
10717 
10718                   SemStr* t1;
10719 
10720                   RT* rt = assignTemp(pPreDec(n, bump, bumpr, 16), 16, t1);
10721 
10722                   ADDBUMP;
10723 
10724                   bump = 0;
10725 
10726                   RTs = instantiate (pc, sslName, t1, pPreDec(n2, bump, bumpr, 16));
10727 
10728                   RTs->insert(RTs->begin(), rt);
10729 
10730                   ADDBUMP;
10731 
10732               } 
10733 
10734       
10735 
10736       
10737       
10738       
10739     } 
10740     goto MATCH_finished_a; 
10741     
10742   MATCH_label_a77: (void)0; /*placeholder for label*/ 
10743     { 
10744       char *name = MATCH_name;
10745       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10746       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10747       
10748       #line 800 "machine/mc68k/decoder_low.m"
10749        {
10750 
10751                   strcpy(sslName, name);
10752 
10753                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10754 
10755                   sslName[4] = '\0';
10756 
10757                   strcat(sslName, "l");         // Force 32 bit size
10758 
10759                   RTs = instantiate (pc, sslName, DIS_DN(32), DIS_DN2(32));
10760 
10761               } 
10762 
10763       
10764 
10765       
10766       
10767       
10768     } 
10769     goto MATCH_finished_a; 
10770     
10771   MATCH_label_a78: (void)0; /*placeholder for label*/ 
10772     { 
10773       char *name = MATCH_name;
10774       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
10775       unsigned n2 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10776       
10777       #line 808 "machine/mc68k/decoder_low.m"
10778        {
10779 
10780                   int bump = 0, bumpr;
10781 
10782                   strcpy(sslName, name);
10783 
10784                   if (strncmp(sslName, "cmp", 3) == 0) sslName[3] = '\0';
10785 
10786                   sslName[4] = '\0';
10787 
10788                   strcat(sslName, "l");         // Force 32 bit size
10789 
10790                   SemStr* t1;
10791 
10792                   RT* rt = assignTemp(pPreDec(n, bump, bumpr, 32), 32, t1);
10793 
10794                   ADDBUMP;
10795 
10796                   bump = 0;
10797 
10798                   RTs = instantiate (pc, sslName, t1, pPreDec(n2, bump, bumpr, 32));
10799 
10800                   RTs->insert(RTs->begin(), rt);
10801 
10802                   ADDBUMP;
10803 
10804               } 
10805 
10806       
10807 
10808       
10809       
10810       
10811     } 
10812     goto MATCH_finished_a; 
10813     
10814   MATCH_label_a79: (void)0; /*placeholder for label*/ 
10815     { 
10816       char *name = MATCH_name;
10817       unsigned ea = addressToPC(MATCH_p);
10818       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10819       
10820       #line 923 "machine/mc68k/decoder_low.m"
10821        {
10822 
10823                   int bump = 0, bumpr;
10824 
10825                   chop2ndLast(name);
10826 
10827                   RTs = instantiate (pc, sslName, awlEA(ea, pc, bump, bumpr, 32), DIS_AN);
10828 
10829                   ADDBUMP;
10830 
10831               }
10832 
10833       
10834 
10835       
10836       
10837       
10838     } 
10839     goto MATCH_finished_a; 
10840     
10841   MATCH_label_a80: (void)0; /*placeholder for label*/ 
10842     { 
10843       char *name = MATCH_name;
10844       unsigned eax = addressToPC(MATCH_p);
10845       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10846       unsigned x = 2 + addressToPC(MATCH_p);
10847       
10848       #line 930 "machine/mc68k/decoder_low.m"
10849        {
10850 
10851                   chopBoth(name);
10852 
10853                   RTs = instantiate(pc, sslName,
10854 
10855                       awlEAX(eax, x, result, pc, delta, 32), DIS_AN);
10856 
10857               }
10858 
10859       
10860 
10861       
10862       
10863       
10864     } 
10865     goto MATCH_finished_a; 
10866     
10867   MATCH_label_a81: (void)0; /*placeholder for label*/ 
10868     { 
10869       char *name = MATCH_name;
10870       unsigned ea = addressToPC(MATCH_p);
10871       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10872       
10873       #line 936 "machine/mc68k/decoder_low.m"
10874        {
10875 
10876                   int bump = 0, bumpr;
10877 
10878                   RTs = instantiate (pc, name, DIS_DN(8), daEA(ea, pc, bump, bumpr, 8));
10879 
10880                   ADDBUMP;
10881 
10882               }
10883 
10884       
10885 
10886       
10887       
10888       
10889     } 
10890     goto MATCH_finished_a; 
10891     
10892   MATCH_label_a82: (void)0; /*placeholder for label*/ 
10893     { 
10894       char *name = MATCH_name;
10895       unsigned eax = addressToPC(MATCH_p);
10896       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10897       unsigned x = 2 + addressToPC(MATCH_p);
10898       
10899       #line 942 "machine/mc68k/decoder_low.m"
10900        {
10901 
10902                   RTs = instantiate (pc, name, DIS_DN(8),
10903 
10904                       daEAX(eax, x, result, pc, 8));
10905 
10906               }
10907 
10908       
10909 
10910       
10911       
10912       
10913     } 
10914     goto MATCH_finished_a; 
10915     
10916   MATCH_label_a83: (void)0; /*placeholder for label*/ 
10917     { 
10918       char *name = MATCH_name;
10919       unsigned ea = addressToPC(MATCH_p);
10920       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10921       
10922       #line 947 "machine/mc68k/decoder_low.m"
10923        {
10924 
10925                   int bump = 0, bumpr;
10926 
10927                   RTs = instantiate (pc, name, DIS_DN(16), daEA(ea, pc, bump, bumpr, 16));
10928 
10929                   ADDBUMP;
10930 
10931               }
10932 
10933       
10934 
10935       
10936       
10937       
10938     } 
10939     goto MATCH_finished_a; 
10940     
10941   MATCH_label_a84: (void)0; /*placeholder for label*/ 
10942     { 
10943       char *name = MATCH_name;
10944       unsigned eax = addressToPC(MATCH_p);
10945       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10946       unsigned x = 2 + addressToPC(MATCH_p);
10947       
10948       #line 953 "machine/mc68k/decoder_low.m"
10949        {
10950 
10951                   RTs = instantiate (pc, name, DIS_DN(16),
10952 
10953                       daEAX(eax, x, result, pc, 16));
10954 
10955               }
10956 
10957       
10958 
10959       
10960       
10961       
10962     } 
10963     goto MATCH_finished_a; 
10964     
10965   MATCH_label_a85: (void)0; /*placeholder for label*/ 
10966     { 
10967       char *name = MATCH_name;
10968       unsigned ea = addressToPC(MATCH_p);
10969       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10970       
10971       #line 958 "machine/mc68k/decoder_low.m"
10972        {
10973 
10974                   int bump = 0, bumpr;
10975 
10976                   RTs = instantiate (pc, name, DIS_DN(32), daEA(ea, pc, bump, bumpr, 32));
10977 
10978                   ADDBUMP;
10979 
10980               }
10981 
10982       
10983 
10984       
10985       
10986       
10987     } 
10988     goto MATCH_finished_a; 
10989     
10990   MATCH_label_a86: (void)0; /*placeholder for label*/ 
10991     { 
10992       char *name = MATCH_name;
10993       unsigned eax = addressToPC(MATCH_p);
10994       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
10995       unsigned x = 2 + addressToPC(MATCH_p);
10996       
10997       #line 964 "machine/mc68k/decoder_low.m"
10998        {
10999 
11000                   RTs = instantiate (pc, name, DIS_DN(32),
11001 
11002                       daEAX(eax, x, result, pc, 32));
11003 
11004               }
11005 
11006       
11007 
11008           
11009 
11010       
11011       
11012       
11013     } 
11014     goto MATCH_finished_a; 
11015     
11016   MATCH_label_a87: (void)0; /*placeholder for label*/ 
11017     { 
11018       char *name = MATCH_name;
11019       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11020       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11021       
11022       #line 1060 "machine/mc68k/decoder_low.m"
11023        {
11024 
11025               // _shiftIRB    is  asrib | lsrib | rorib | roxrib
11026 
11027                   chop2ndLast(name);
11028 
11029                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(8));
11030 
11031               }
11032 
11033           
11034 
11035       
11036       
11037       
11038     } 
11039     goto MATCH_finished_a; 
11040     
11041   MATCH_label_a88: (void)0; /*placeholder for label*/ 
11042     { 
11043       char *name = MATCH_name;
11044       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11045       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11046       
11047       #line 1092 "machine/mc68k/decoder_low.m"
11048        {
11049 
11050               // _shiftRRB    is  asrrb | lsrrb | rorrb | roxrrb
11051 
11052                   chop2ndLast(name);
11053 
11054                   RTs = instantiate (pc, sslName, DIS_DN(8), DIS_DN2(8));
11055 
11056               }
11057 
11058       
11059 
11060       
11061       
11062       
11063     } 
11064     goto MATCH_finished_a; 
11065     
11066   MATCH_label_a89: (void)0; /*placeholder for label*/ 
11067     { 
11068       char *name = MATCH_name;
11069       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11070       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11071       
11072       #line 1071 "machine/mc68k/decoder_low.m"
11073        {
11074 
11075                   chop2ndLast(name);
11076 
11077                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(16));
11078 
11079               }
11080 
11081           
11082 
11083       
11084       
11085       
11086     } 
11087     goto MATCH_finished_a; 
11088     
11089   MATCH_label_a90: (void)0; /*placeholder for label*/ 
11090     { 
11091       char *name = MATCH_name;
11092       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11093       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11094       
11095       #line 1103 "machine/mc68k/decoder_low.m"
11096        {
11097 
11098                   chop2ndLast(name);
11099 
11100                   RTs = instantiate (pc, sslName, DIS_DN(16), DIS_DN2(16));
11101 
11102               }
11103 
11104           
11105 
11106       
11107       
11108       
11109     } 
11110     goto MATCH_finished_a; 
11111     
11112   MATCH_label_a91: (void)0; /*placeholder for label*/ 
11113     { 
11114       char *name = MATCH_name;
11115       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11116       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11117       
11118       #line 1081 "machine/mc68k/decoder_low.m"
11119        {
11120 
11121                   chop2ndLast(name);
11122 
11123                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(32));
11124 
11125               }
11126 
11127           
11128 
11129       
11130       
11131       
11132     } 
11133     goto MATCH_finished_a; 
11134     
11135   MATCH_label_a92: (void)0; /*placeholder for label*/ 
11136     { 
11137       char *name = MATCH_name;
11138       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11139       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11140       
11141       #line 1113 "machine/mc68k/decoder_low.m"
11142        {
11143 
11144                   chop2ndLast(name);
11145 
11146                   RTs = instantiate (pc, sslName, DIS_DN(32), DIS_DN2(32));
11147 
11148               }
11149 
11150           
11151 
11152       
11153       
11154       
11155     } 
11156     goto MATCH_finished_a; 
11157     
11158   MATCH_label_a93: (void)0; /*placeholder for label*/ 
11159     { 
11160       char *name = MATCH_name;
11161       unsigned ea = addressToPC(MATCH_p);
11162       
11163       #line 1026 "machine/mc68k/decoder_low.m"
11164        {
11165 
11166               // ASL, ASR, LSL, LSR, ROL, ROR, ROXL, ROXR
11167 
11168                   int bump = 0, bumpr;
11169 
11170                   chopDotex(name);           // Fix the name
11171 
11172                   int lst = strlen(sslName) - 1;
11173 
11174                   int siz = 32;
11175 
11176                   if (sslName[lst] == 'b') siz = 8;
11177 
11178                   if (sslName[lst] == 'w') siz = 16;
11179 
11180                   RTs = instantiate (pc, sslName, maEA(ea, pc, bump, bumpr, siz));
11181 
11182                   ADDBUMP;
11183 
11184               }
11185 
11186       
11187 
11188       
11189       
11190       
11191     } 
11192     goto MATCH_finished_a; 
11193     
11194   MATCH_label_a94: (void)0; /*placeholder for label*/ 
11195     { 
11196       char *name = MATCH_name;
11197       unsigned eax = addressToPC(MATCH_p);
11198       unsigned x = 2 + addressToPC(MATCH_p);
11199       
11200       #line 1038 "machine/mc68k/decoder_low.m"
11201        {
11202 
11203                   chopDotex(name);           // Fix the name
11204 
11205                   RTs = instantiate (pc, sslName, maEAX(eax, x, result, pc, 16));
11206 
11207               }
11208 
11209       
11210 
11211       
11212       
11213       
11214     } 
11215     goto MATCH_finished_a; 
11216     
11217   MATCH_label_a95: (void)0; /*placeholder for label*/ 
11218     { 
11219       char *name = MATCH_name;
11220       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11221       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11222       
11223       #line 1066 "machine/mc68k/decoder_low.m"
11224        {
11225 
11226                   chop2ndLast(name);
11227 
11228                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(8));
11229 
11230               }
11231 
11232           
11233 
11234       
11235       
11236       
11237     } 
11238     goto MATCH_finished_a; 
11239     
11240   MATCH_label_a96: (void)0; /*placeholder for label*/ 
11241     { 
11242       char *name = MATCH_name;
11243       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11244       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11245       
11246       #line 1098 "machine/mc68k/decoder_low.m"
11247        {
11248 
11249                   chop2ndLast(name);
11250 
11251                   RTs = instantiate (pc, sslName, DIS_DN(8), DIS_DN2(8));
11252 
11253               }
11254 
11255           
11256 
11257       
11258       
11259       
11260     } 
11261     goto MATCH_finished_a; 
11262     
11263   MATCH_label_a97: (void)0; /*placeholder for label*/ 
11264     { 
11265       char *name = MATCH_name;
11266       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11267       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11268       
11269       #line 1076 "machine/mc68k/decoder_low.m"
11270        {
11271 
11272                   chop2ndLast(name);
11273 
11274                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(16));
11275 
11276               }
11277 
11278           
11279 
11280       
11281       
11282       
11283     } 
11284     goto MATCH_finished_a; 
11285     
11286   MATCH_label_a98: (void)0; /*placeholder for label*/ 
11287     { 
11288       char *name = MATCH_name;
11289       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11290       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11291       
11292       #line 1108 "machine/mc68k/decoder_low.m"
11293        {
11294 
11295                   chop2ndLast(name);
11296 
11297                   RTs = instantiate (pc, sslName, DIS_DN(16), DIS_DN2(16));
11298 
11299               }
11300 
11301           
11302 
11303       
11304       
11305       
11306     } 
11307     goto MATCH_finished_a; 
11308     
11309   MATCH_label_a99: (void)0; /*placeholder for label*/ 
11310     { 
11311       char *name = MATCH_name;
11312       unsigned i8 = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11313       unsigned n = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11314       
11315       #line 1086 "machine/mc68k/decoder_low.m"
11316        {
11317 
11318                   chop2ndLast(name);
11319 
11320                   RTs = instantiate (pc, sslName, DIS_I8, DIS_DN(32));
11321 
11322               }
11323 
11324           
11325 
11326           
11327 
11328       
11329       
11330       
11331     } 
11332     goto MATCH_finished_a; 
11333     
11334   MATCH_label_a100: (void)0; /*placeholder for label*/ 
11335     { 
11336       char *name = MATCH_name;
11337       unsigned n = (MATCH_w_16_0 >> 9 & 0x7) /* reg1 at 0 */;
11338       unsigned n2 = (MATCH_w_16_0 & 0x7) /* reg2 at 0 */;
11339       
11340       #line 1118 "machine/mc68k/decoder_low.m"
11341        {
11342 
11343                   chop2ndLast(name);
11344 
11345                   RTs = instantiate (pc, sslName, DIS_DN(32), DIS_DN2(32));
11346 
11347               }
11348 
11349       
11350 
11351       
11352       
11353       
11354     } 
11355     goto MATCH_finished_a; 
11356     
11357   MATCH_label_a101: (void)0; /*placeholder for label*/ 
11358     { 
11359       char *name = MATCH_name;
11360       unsigned ea = addressToPC(MATCH_p);
11361       
11362       #line 1043 "machine/mc68k/decoder_low.m"
11363        {
11364 
11365                   int bump = 0, bumpr;
11366 
11367                   chopDotex(name);           // Fix the name
11368 
11369                   int lst = strlen(sslName) - 1;
11370 
11371                   int siz = 32;
11372 
11373                   if (sslName[lst] == 'b') siz = 8;
11374 
11375                   if (sslName[lst] == 'w') siz = 16;
11376 
11377                   RTs = instantiate (pc, sslName, maEA(ea, pc, bump, bumpr, siz));
11378 
11379                   ADDBUMP;
11380 
11381               }
11382 
11383       
11384 
11385       
11386       
11387       
11388     } 
11389     goto MATCH_finished_a; 
11390     
11391   MATCH_label_a102: (void)0; /*placeholder for label*/ 
11392     { 
11393       char *name = MATCH_name;
11394       unsigned eax = addressToPC(MATCH_p);
11395       unsigned x = 2 + addressToPC(MATCH_p);
11396       
11397       #line 1054 "machine/mc68k/decoder_low.m"
11398        {
11399 
11400                   chopDotex(name);           // Fix the name
11401 
11402                   RTs = instantiate (pc, sslName, maEAX(eax, x, result, pc, 16));
11403 
11404               }
11405 
11406       
11407 
11408           
11409 
11410       
11411       
11412       
11413     } 
11414     goto MATCH_finished_a; 
11415     
11416   MATCH_finished_a: (void)0; /*placeholder for label*/
11417   
11418 }
11419 
11420 #line 1135 "machine/mc68k/decoder_low.m"
11421 
11422     result.numBytes += 2;           // Count the main opcode
11423     return RTs;
11424 }
11425 
11426 
11427 
11428
mc68k/decoder_low.cpp
